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 dispose de diverses fonctions telles que le réglage de la luminosité et de la couleur, 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 type croquis en utilisant OpenCV.

Traitement d'image en "style d'esquisse" 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 croquis. Le code est ci-dessous.

def sketch(image):
    pencilSketch_img = pencilSketch(image)
    bilateral_img = cv2.bilateralFilter(image, 75, 100, 100)
    sketch_img = cv2.bitwise_and(bilateral_img, pencilSketch_img)
    return sketch_img

def pencilSketch(image):
    gray_img = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    median_img = cv2.medianBlur(gray_img, 5)
    laplacian_img = cv2.Laplacian(median_img, cv2.CV_8U, ksize=5)
    _, thresh_img = cv2.threshold(laplacian_img, 100, 255, cv2.THRESH_BINARY_INV)
    pencilSketch_img = cv2.cvtColor(thresh_img, cv2.COLOR_GRAY2BGR)
    return pencilSketch_img

sketch = sketch(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(sketch[:,:,::-1]);plt.axis('off')
plt.title("sketch image")

Le processus de traitement comme une esquisse est défini comme la fonction d'esquisse. Le flux de traitement de la fonction d'esquisse est le suivant.

--Création d'image de style de dessin au crayon (fonction PencilSketch)

Lissage (cv2.bilateralFilter) --Traitement du masque (cv2.bitwise_and)

L'ordre est de dessiner une ligne avec un crayon et de la peindre.

Description de chaque processus

Chaque processus sera expliqué ci-dessous.

Création d'images de style crayon (fonction PencilSketch)

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

J'afficherai l'image.

image = cv2.imread(input_file) #Chargement de l'image originale
pencilSketch_img = pencilSketch(image) #Image de style crayon

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

Pour plus de détails sur la fonction PencilSketch, consultez ici.

Lissage (cv2.bilateralFilter)

** 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 filtre bilatéral en fait partie. Bilatéral signifie «les deux», mais ce filtre peut bien laisser des bords. Le filtre de lissage rend l'image floue, y compris les pics tels que les bords. Vous pouvez utiliser le ** filtre bilatéral ** pour rendre l'image floue tout en laissant ** les bords **.

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

Le code de bilatéralFilter est ci-dessous.

bilateral_img = cv2.bilateralFilter(image, 75, 100, 100)

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

Vous pouvez voir que l'image est floue.

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

dst = cv2.bilateralFilter(src, d, sigmaColor, sigmaSpace[, dst[, borderType]] ) --src: Image d'entrée --dst: image de sortie --d: le diamètre de la zone d'intérêt. --sigmaColor: Paramètres liés à l'espace colorimétrique. Plus la valeur est élevée, plus les couleurs séparées dans l'espace colorimétrique s'influencent mutuellement. --sigmaSpace: paramètres liés à l'espace de coordonnées. Plus la valeur est élevée, plus les pixels séparés dans l'espace de coordonnées s'affectent.

Traitement du masque (cv2.bitwise_and)

Enfin, le traitement du masque est utilisé pour combiner l'image couleur et l'image d'esquisse de style dessin au crayon. Utilisez cv2.bitwise_and pour le masquage. cv2.bitwise_and est une fonction qui effectue un traitement ET bit par bit de deux images.

Le code de masquage est ci-dessous.

merged_img = cv2.bitwise_and(bilateral_img, pencilSketch_img)

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

J'ai réussi à mettre un croquis de style de dessin au crayon sur une image en couleur.

Résumé

Comment était-ce.

Cette fois, j'ai essayé le traitement d'image de type croquis en utilisant OpenCV. Passons en revue le flux de traitement.