introduction

Je pense qu'il y a beaucoup de gens qui partagent des photos sur SNS, y compris Instagram. À ce moment-là, je pense que vous pouvez utiliser l'application pour traiter l'image. Il a diverses fonctions telles que le réglage de la luminosité et des couleurs, la retouche pour rendre la peau belle et le traitement des photos dans un style d'esquisse.

Cette fois, j'ai essayé un simple traitement d'image de style dessin au crayon à l'aide d'OpenCV.

Traitement d'image en "style dessin au crayon" avec OpenCV

environnement

L'environnement utilise Google Colaboratory. La version Python est ci-dessous.

import platform
print("python " + platform.python_version())
# python 3.6.9

Affichage de l'image

Maintenant écrivons le code. Tout d'abord, importez et définissez la bibliothèque requise pour afficher l'image.

import cv2
import matplotlib.pyplot as plt
import matplotlib

%matplotlib inline
matplotlib.rcParams['image.cmap'] = 'gray'

Préparez également un exemple d'image. Cette fois, j'utiliserai l'image gratuite de Pixabay.

Maintenant, affichons l'exemple d'image préparé.

image = cv2.imread(input_file) # input_file est le chemin de l'image

plt.figure(figsize=[10,10])
plt.axis('off')
plt.imshow(image[:,:,::-1])

Conclusion

Utilisons maintenant OpenCV pour traiter cette image comme un dessin au crayon. J'ai essayé de l'afficher avec l'image d'origine.

def pencilSketch(image):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    median = cv2.medianBlur(gray, 5)
    laplacian = cv2.Laplacian(median, cv2.CV_8U, ksize=5)
    _, thresh = cv2.threshold(laplacian, 100, 255, cv2.THRESH_BINARY_INV)
    pencilSketchImage = cv2.cvtColor(thresh, cv2.COLOR_GRAY2BGR)
    return pencilSketchImage

pencilSketchImage = pencilSketch(image)

plt.figure(figsize=[20,10])
plt.subplot(121);plt.imshow(image[:,:,::-1]);plt.axis('off')
plt.title("original image")
plt.subplot(122);plt.imshow(pencilSketchImage[:,:,::-1]);plt.axis('off')
plt.title("pencil sketch image")

Le processus de traitement comme un dessin au crayon est défini comme la fonction PencilSketch. Le flux de traitement de la fonction PencilSketch est le suivant.

niveaux de gris --Lissage (flou médian) -Différenciation d'image (laplacien)
Binarisation

Description de chaque processus

Chaque processus sera expliqué ci-dessous.

niveaux de gris

** L'échelle de gris ** (échelle de gris ou échelle de gris) est un type de représentation des couleurs. En termes simples, transformer une image couleur en une image en noir et blanc.

Le code de l'échelle de gris est ci-dessous.

image = cv2.imread(input_file) #Chargement de l'image originale
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) #niveaux de gris

plt.figure(figsize=[20,10])
plt.subplot(121);plt.axis('off');plt.imshow(image[:,:,::-1])
plt.subplot(122);plt.axis('off');plt.imshow(gray)

J'utilise cv2.cvtColor pour convertir la couleur en niveaux de gris. L'utilisation de cv2.cvtColor est la suivante.

dst = cv2.cvtColor(src, code) --src: Image d'entrée --dst: image de sortie --code: Comment convertir l'espace colorimétrique

Lissage (medianBlur)

** Le lissage ** ou le lissage est simplement ** un flou de l'image **. On peut également dire que le flou de l'image adoucit le changement de valeur de pixel. Le bruit et les bords sont des changements soudains des valeurs de pixels. Le lissage peut éliminer ou rendre les bords moins visibles.

Il existe plusieurs méthodes de lissage, et le flou médian en fait partie. median est la "valeur médiane", qui prend la valeur médiane des pixels contenus dans le noyau spécifié et remplit tout le noyau avec cette valeur.

Le "noyau" est la zone de l'image d'intérêt, mais si c'est difficile, vous pouvez utiliser l'image d'une "boîte".

Pour plus d'informations sur le lissage, veuillez consulter ici.

Le code pour medianBlur est ci-dessous.

median = cv2.medianBlur(gray, 5) # medianBlur

plt.figure(figsize=[20,10])
plt.subplot(121);plt.axis('off');plt.imshow(gray)
plt.subplot(122);plt.axis('off');plt.imshow(median)

Vous pouvez voir que l'image est floue.

J'ai utilisé cv2.medianBlur pour brouiller une image en niveaux de gris. L'utilisation de cv2.medianBlur est la suivante.

dst = cv2.medianBlur(src, ksize) --src: Image d'entrée --dst: image de sortie --ksize: taille du noyau (cependant, nombre impair de 3 ou plus)

Différenciation d'image (laplacien)

** La différenciation de l'image ** détecte les zones où les valeurs de pixels changent rapidement, c'est-à-dire ** les bords **.

Il existe plusieurs façons de différencier une image, le laplacien en fait partie. Le filtre laplacien est un double différentiel et est utile lorsque vous souhaitez une détection des bords plus fine que le filtre Sobel différentiel unique.

Pour plus d'informations sur la différenciation des images, voir ici.

Le code pour le laplacien est ci-dessous.

laplacian = cv2.Laplacian(median, cv2.CV_8U, ksize=5) # Laplacian

plt.figure(figsize=[20,10])
plt.subplot(121);plt.axis('off');plt.imshow(median)
plt.subplot(122);plt.axis('off');plt.imshow(laplacian)

Vous pouvez voir que les bords ont été détectés.

J'ai utilisé cv2.Laplacian pour différencier l'image. L'utilisation de cv2.Laplacian est la suivante.

dst = cv2.Laplacian(src, ddepth, ksize) --src: Image d'entrée --dst: image de sortie --ddepth: Type d'image de sortie (profondeur de bits) --ksize: taille du noyau (impair)

Binarisation

La binarisation est le processus de conversion d'une image en deux valeurs (binaires), blanc et noir. Il est différent de l'échelle de gris qui s'affiche entre le blanc et le noir par étapes. Une valeur appelée seuil (seuil) est déterminée, et si la valeur du pixel est plus grande que cela, elle est convertie en blanc, et si elle est plus petite, elle est convertie en noir.

Il existe plusieurs façons de binariser une image. Cette fois, nous avons effectué une binarisation générale.

Pour plus d'informations sur la binarisation, veuillez consulter ici.

Le code de binarisation est ci-dessous.

_, thresh = cv2.threshold(laplacian, 100, 255, cv2.THRESH_BINARY_INV) #Binarisation

plt.figure(figsize=[20,10])
plt.subplot(121);plt.axis('off');plt.imshow(laplacian)
plt.subplot(122);plt.axis('off');plt.imshow(thresh)

J'ai pu ne laisser que ceux avec des valeurs de pixels relativement élevées.

J'ai utilisé cv2.threshold pour binariser l'image. L'utilisation de cv2.threshold est la suivante.

ret, dst = cv2.threshold(src, thresh, maxVal, method) --src: Image d'entrée (échelle de gris) --ret: valeur du seuil utilisé --dst: image de sortie --thresh: seuil --maxVal: valeur maximale (valeur au-dessus du seuil) --method: Traitement des seuils - cv2.THRESH_BINARY --cv2.THRESH_BINARY_INV etc.

Cette fois, le seuil est fixé à 100. Cette fois, le seuil de valeur de retour (100) n'est pas utilisé, il est donc défini sur _ (trait de soulignement).

Dans le traitement de seuil, cv2.THRESH_BINARY_INV est utilisé pour l'inversion noir et blanc. cv2.THRESH_BINARY_INV est le processus permettant de définir 0 (noir) pour les pixels qui dépassent le seuil (100 cette fois) et maxVal (255 cette fois) pour les autres pixels.

Résumé

Comment était-ce.

Cette fois, j'ai essayé une esquisse de style dessin au crayon en utilisant OpenCV. Passons en revue le flux de traitement.

niveaux de gris --Lissage (flou médian) -Différenciation d'image (laplacien)
Binarisation

En modifiant des paramètres tels que le seuil et la taille du noyau, vous pouvez modifier la finesse de la ligne. Je pense qu'il serait intéressant de sortir une image en modifiant divers paramètres.

[PYTHON] J'ai essayé de traiter l'image dans un "style de dessin au crayon" avec OpenCV