Redimensionner, mosaïque, détection de visage avec OpenCV, parfois tampon d'éléphant

introduction

Cela devient de plus en plus.

Redimensionner cv2.resize (src, dsize, fx, fy, interpolation)

Il existe deux façons de spécifier le redimensionnement d'image dans OpenCV. Grossissement et spécifications de taille.

• src * et * dsize * sont requis.

• • src * est l'image d'origine.
• • dsize * spécifie la taille de sortie en ** taple dans l'ordre de (largeur, hauteur). ** Obligatoire même lors de la spécification de l'agrandissement, auquel cas (0, 0) ou Aucun est spécifié. Naturellement un entier.
• • fx * et * fy * sont des agrandissements dans les directions de la largeur et de la hauteur. Cela peut être une fraction.
• • Interpolation * indique comment compléter l'image. Il y en a plusieurs, mais vous devez vous rappeler les deux suivants. Puisque cv2.INTER_LINEAR est la valeur par défaut, cv2.INTER_NEAREST seul est suffisant. --cv2.INTER_LINEAR Interpolation bilinéaire (par défaut) --cv2.INTER_NEAREST Interpolation la plus proche

La différence est difficile à voir dans les images d'arrière-plan et jpeg des personnes, mais elle est facile à voir dans les images de points.

L'image originale	cv2.INTER_LINEAR	cv2.INTER_NEAREST
Je suis là ↓

Lorsque Trimming, n'oubliez pas d'écrire img [r: r + h, c: c + w] dans l'ordre des lignes et des colonnes car c'est une matrice. Cependant, le redimensionnement n'a rien à voir avec la matrice, donc l'ordre est (w, h). Ceci est déroutant. Il est également déroutant que la taille doive être décrite même lorsque le grossissement est spécifié, et il est nécessaire de prendre la peine d'écrire Aucun.

Programme de base

resize.py

import cv2

filename = "hoge.jpg "
img = cv2.imread(filename)

fx, fy = 3.5, 2  #Le grossissement peut être petit

#Comment spécifier avec dsize
h, w = img.shape[:2]
h_resize, w_resize = round(h*fy), round(w*fx)  #La taille est un entier
img_resize = cv2.resize(img, dsize=(w_resize, h_resize) ,interpolation=cv2.INTER_LINEAR)

# fx,Comment spécifier avec fy
#img_resize = cv2.resize(img, dsize=(0,0), fx=fx, fy=fy ,interpolation=cv2.INTER_LINEAR)

#Cela entraînera une erreur
#img_resize = cv2.resize(img, fx=fx, fy=fy ,interpolation=cv2.INTER_LINEAR)

cv2.imshow("originai image",img)
cv2.imshow("resized image",img_resize)
cv2.waitKey(0)
cv2.destroyAllWindows()

mosaïque

Mosaic n'a pas de méthode spéciale pour appliquer une mosaïque. Tout ce que vous avez à faire est de le réduire et de le redimensionner à sa taille d'origine. Bien sûr avec cv2.INTER_NEAREST.

Exemple d'application 1 Focus avec des indices

Si vous rendez progressivement la mosaïque plus dense, vous pouvez créer un quiz comme un focus avec des indices. Dans la source suivante, la partie qui crée un GIF animé est omise, veuillez donc essayer d'appuyer sur la touche de manière appropriée.

hinto_de_pinto.py

import cv2

filename = "hoge.jpg "
img_origin = cv2.imread(filename)
imgH, imgW = img_origin.shape[:2]

i = 2
isComplete = False
while not isComplete:
    ratio = 1/2**(8-i*0.6)  #Je fais un calcul délicat, mais veuillez le changer librement
    print (ratio)
    if ratio > 0.7:
        img_mosaic = img_origin
        isComplete = True
    else :
        img_mosaic = cv2.resize(img_origin, dsize=None ,fx=ratio, fy=ratio)
        img_mosaic = cv2.resize(img_mosaic, dsize=(imgW, imgH),
                                interpolation=cv2.INTER_NEAREST)
    cv2.imshow("mosaic", img_mosaic)
    cv2.waitKey(0)
    i += 1
    
cv2.destroyAllWindows()

L'image originale est Skimanas comme d'habitude.

Détection facial

La détection de visage est possible avec le classificateur en cascade OpenCV. Il existe de nombreux classificateurs sur le net, et vous pouvez également créer les vôtres.

Voici une référence pour le mécanisme. [Explication pour les débutants] Mécanisme de détection de visage OpenCV et pratique (détecter MultiScale) 　https://qiita.com/FukuharaYohei/items/ec6dce7cc5ea21a51a82

Programme de base

face_detect.py

import cv2

filename = "hoge.jpg "
img_origin = cv2.imread(filename)
img_gray= cv2.cvtColor(img_origin, cv2.COLOR_BGR2GRAY) #Échelle de gris pour la vitesse

# https://github.com/opencv/opencv/tree/master/data/Obtenez des fichiers en cascade de haarcascades
cascade_path = "./models/haarcascade_frontalface_alt2.xml"
cascade = cv2.CascadeClassifier(cascade_path)
faces = cascade.detectMultiScale(img_gray)

print (faces)

Jusqu'à présent, divers paramètres ont été décrits, mais ici seuls les résultats de sortie seront décrits. Tout d'abord, l'image originale que je n'ai pas présentée plus tôt.

L'exécution du programme sur cette image donne les résultats suivants:

résultat

[[374  78  88  88]
 [137  90 127 127]]

Référence officielle dit seulement "liste de rectangles", mais écrivez plus spécifiquement. Et ** une liste de "une liste de rectangles détectés stockés dans l'ordre x, y, w, h" **. N'oubliez pas que les crochets sont doublés même s'il n'y a qu'un seul résultat de détection car il s'agit d'une liste de listes.

Exemple d'application 2 Mosaïque liée à la détection de visage

En parlant de détection de visage, nous voyons souvent des programmes qui entourent la zone détectée dans un carré, mais si vous comprenez la sortie, il est facile de faire une mosaïque. L'homme qui rit pourra bientôt le faire pour la vidéo acquise par la caméra au lieu de l'image. Je n'ai jamais vu de corps d'obus.

rectangle_and_mosaic.py

import cv2

filename = "hoge.jpg "
img_origin = cv2.imread(filename)
img_gray = cv2.imread(filename,0)  #Il existe également un moyen de lire en échelle de gris au lieu de convertir avec cvtColor

# img_origin.copy()Pas img_Voyons ce qui se passe avec l'origine elle-même
img_rect = img_origin.copy()
img_mosaic = img_origin.copy()

cascade_path = "./models/haarcascade_frontalface_alt2.xml"
cascade = cv2.CascadeClassifier(cascade_path)
faces = cascade.detectMultiScale(img_gray)

if len(faces) > 0:
    for face in faces:
        x, y, w, h = face

        #Entourez la zone du visage détecté d'un carré
        img_rect = cv2.rectangle(img_rect, (x, y), (x+w, y+h), color=(255, 255, 255), thickness=2)

        #Mosaïque de la zone du visage détectée
        roi = img_mosaic[y:y+h, x:x+w]
        roi = cv2.resize(roi, (w//10, h//10))
        roi = cv2.resize(roi, (w, h), interpolation=cv2.INTER_NEAREST)
        img_mosaic[y:y+h, x:x+w] = roi               

cv2.imshow("face originai", img_origin)
cv2.imshow("face rectangle", img_rect)
cv2.imshow("face mosaic", img_mosaic)
cv2.waitKey(0)
cv2.destroyAllWindows()

Exemple d'application 3 Miroir qui semble mince

J'ai créé un miroir fin qui utilise la détection et la mise à l'échelle des visages. J'avais l'illusion que ce serait très populaire auprès des lycéennes de tout le pays si je publiais une application pour smartphone qui me permette de perdre du poids et de prendre du poids en me pinçant et en retirant, mais malheureusement, je n'avais pas la technologie pour créer une application pour smartphone. Ou plutôt, il avait une fonction similaire à SNOW. Je ne pense pas que la fonction beauté de SNOW soit si simple.

Ci-dessus: Image originale (Pakutaso) Moyen: après traitement En bas: un GIF animé en bon état

Eh bien, la source de ceci ... les marges ici sont trop étroites pour l'écrire.

À la fin

OpenCV est intéressant, mais je dois étudier le deep learning, qui est l'histoire principale, le plus tôt possible.