100 coups sur le traitement d'image !! (001 --010) Soigneusement et soigneusement

1.Tout d'abord

Pratiquez ceci pour améliorer les capacités techniques du prétraitement d'image 100 coups pour le traitement d'image !! Je vais le faire avec Colaboratory pour qu'il soit facile de démarrer. Nous travaillerons pour atteindre l'objectif dans deux semaines. Je vais l'expliquer soigneusement. Veuillez poser une question!

2. Préparation

Introduit les bibliothèques, etc. comme suit.

python


#Importer la bibliothèque
from google.colab import drive
import numpy as np
import matplotlib.pyplot as plt
import cv2
from google.colab.patches import cv2_imshow

#Chargement des images
img = cv2.imread('Chemin de l'image/imori.jpg')
img_noise = cv2.imread('Chemin de l'image/imori_noise.jpg')
#Pour le stockage d'images
OUT_DIR = 'Chemin de destination de sortie/OUTPUT/'

3. Explication

Q.1. Remplacement du canal

Chargez l'image et remplacez RVB dans l'ordre BGR. Vous pouvez utiliser le code suivant pour extraire le composant rouge de l'image. Notez que dans la fonction cv2.imread (), les canaux sont dans l'ordre BGR! Cela met uniquement le composant rouge de imori.jpg dans la variable red.

A1


#OpenCV, fonction cvtColor()Convertissez BGR et RVB avec
img1 = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
#Sauvegarder le résultat
cv2.imwrite(OUT_DIR + 'ans1_a.jpg', img1)
#Afficher l'image
cv2_imshow(img1)
cv2.waitKey(0)
cv2.destroyAllWindows()

img1.png

Référence: cvtColor qui convertit BGR et RVB avec Python, OpenCV

Q.2. Échelle de gris

Faites l'échelle de gris de l'image. L'échelle de gris est une sorte de méthode d'expression de la luminosité de l'image et est calculée par la formule suivante. Y = 0.2126 R + 0.7152 G + 0.0722 B

A2


#Fonction OpenCV cv2.cvtColor(), cv2.COLOR_Convertir avec BGR2GRAY
img2 = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#Sauvegarder le résultat
cv2.imwrite(OUT_DIR + 'ans2_.jpg', img2)
#Afficher l'image
cv2_imshow(img2)
cv2.waitKey(0)
cv2.destroyAllWindows()

img2.png

Référence: Convertir une image couleur en noir et blanc (échelle de gris) avec Python, OpenCV, NumPy

Q.3. Binarisation

Binarisez l'image. La binarisation est une méthode d'expression d'une image avec deux valeurs, noir et blanc. Ici, le seuil est fixé à 128 dans l'échelle de gris et binarisé par l'équation suivante.

A3


#image(niveaux de gris)copie de
img3 = img2.copy()

#Définition du seuil
threshold = 128

#Binarisation(Le nombre de pixels dépassant le seuil 128 est défini sur 255.)
ret, img3 = cv2.threshold(img3, threshold, 255, cv2.THRESH_BINARY)

#Sauvegarder le résultat
cv2.imwrite(OUT_DIR + 'ans3_.jpg', img3)
#Afficher l'image
cv2_imshow(img3)
cv2.waitKey(0)
cv2.destroyAllWindows()

img3.png

Référence: Dualification of OpenCV image Référence: Traitement du seuil d'image

Q.4. Binarisation d'Otsu

Implémentez la binarisation d'Otsu. La binarisation d'Otsu est appelée une méthode d'analyse discriminante, qui est une méthode de détermination automatique du seuil de séparation lors de la binarisation. Ceci est calculé à partir du rapport de la distribution intra-classe à la distribution inter-classe.

A4


#Implémenté dans OpenCV
#image(niveaux de gris)copie de
gray = img2.copy()
#Processus de binarisation d'Otsu
ret, image4 = cv2.threshold(gray, 0, 255, cv2.THRESH_OTSU)

#Sauvegarder le résultat
cv2.imwrite(OUT_DIR + 'ans4.jpg', img4)
#Afficher l'image
cv2_imshow(img4)
cv2.waitKey(0)
cv2.destroyAllWindows()

img4.png

Référence: [Python / OpenCV] Binarisation à l'aide de la méthode d'Otsu

Q.5. Conversion HSV

Implémentez la conversion HSV pour inverser la teinte H. La conversion HSV est une méthode d'expression des couleurs avec Teinte (teinte), Saturation (saturation) et Valeur (luminosité). Teinte ... Exprime la teinte de 0 à 360 degrés et indique le type de couleur comme le rouge ou le bleu. (0 <= H <360) La teinte correspond aux couleurs suivantes. Rouge Jaune Vert Bleu Clair Bleu Violet Rouge 0 60 120 180 240 300 360 Saturation ... éclat des couleurs. Lorsque la saturation est faible, la couleur grise devient perceptible et la couleur devient terne. (0 <= S <1) Valeur ... Luminosité des couleurs. Plus la valeur est élevée, plus le blanc est proche et plus la valeur est basse, plus le noir est proche. (0 <= V <1)

A5


#Copiez l'image
img5 = img.copy()
# RGB ->Convertir en HSV
hsv = cv2.cvtColor(img5, cv2.COLOR_BGR2HSV)
#Ajouter 180 à la teinte
hsv[..., 0] = (hsv[..., 0] + 180) % 360
# HSV ->Convertir en RVB
img5 = cv2.cvtColor(hsv, cv2.COLOR_HSV2RGB)
#Sauvegarder le résultat
cv2.imwrite(OUT_DIR + 'ans5.jpg', img5)
#Afficher l'image
cv2_imshow(img5)
cv2.waitKey(0)
cv2.destroyAllWindows()

img5.png

Pour une raison quelconque, il est légèrement différent de l'image de réponse. S'il vous plaît laissez-moi savoir si vous faites une erreur

Référence: [Python / OpenCV] Convertir de RVB en HSV (cv2.cvtColor)](https://algorithm.joho.info/programming/python/opencv-rgb-to-hsv-color-space/)

Q.6. Traitement de réduction des couleurs

Ici, réduisez les valeurs d'image de 256 ^ 3 à 4 ^ 3, c'est-à-dire R, V, B dans {32, 96, 160, 224}. Il s'agit d'une opération de quantification. Chaque valeur est définie comme suit.

A6


def decrease_color(img):
    """
    R,G,Réglez B sur 256 et définissez une valeur sur 4.
    [0, 64), [64, 128), [128, 192), (192, 256)Divisez en 4 parties égales *[]: Section fermée(Ci-dessus et ci-dessous), (): Section ouverte(Grand ou petit)
    [0, 64)->32,  [64, 128)->96,  [128, 192)->160,  (192, 256) ->Convertir chaque plage en 2224

    parameters
    -------------------------
    param: numpy.image au format ndarray

    returns
    -------------------------
    numpy.ndarray format Convertir comme indiqué à droite[132  80  67] >>> [160  96  96]
    """
    #Copier l'image
    out = img.copy()
    print(out)
    # 256/4 =Parce qu'il est 64, il est divisé par 64+32 en faisant 32, 96, 160,Transformer en 224
    out = out // 64 * 64 + 32
    return out

img6 = img.copy()

img6 = decrease_color(img6)
#Sauvegarder le résultat
cv2.imwrite(OUT_DIR + 'ans6.jpg', img6)
#Afficher l'image
cv2_imshow(img6)
cv2.waitKey(0)
cv2.destroyAllWindows()

img6.png

Référence: Somehow blog

Q.7. Mise en commun moyenne

Ici, l'image est divisée en grilles (divisée en certaines zones de longueur fixe), et les valeurs de la zone sont remplies avec la valeur moyenne de la zone (cellule). L'opération consistant à diviser la grille de cette manière et à trouver la valeur représentative dans la zone est appelée mise en commun. Ces opérations de mise en commun jouent un rôle important dans CNN (Convolutional Neural Network).

A7


def average_pooling(img, G=8):
    """
Mise en commun moyenne

    parameters
    -------------------------
    param1: numpy.image au format ndarray
    param2:Division de la grille en 8x8

    returns
    -------------------------
Nombre moyen mis en commun.image au format ndarray
    """
    #Copier l'image
    out = img.copy()
    # H(Hauteur de l'image), W(Largeur de l'image), C(Couleur)Avoir
    H, W, C = img.shape
    #Division du réseau
    Nh = int(H / G)
    Nw = int(W / G)

    #Regroupement moyen pour chaque plage divisée en 8
    for y in range(Nh):
        for x in range(Nw):
            for c in range(C):
                out[G*y:G*(y+1), G*x:G*(x+1), c] = np.mean(out[G*y:G*(y+1), G*x:G*(x+1), c]).astype(np.int)
    
    return out

#Mise en commun moyenne
img7 = average_pooling(img)
#Sauvegarder le résultat
cv2.imwrite(OUT_DIR + 'ans7.jpg', img7)
#Afficher l'image
cv2_imshow(img7)
cv2.waitKey(0)
cv2.destroyAllWindows()

img7.png

Q.8. Mise en commun maximale

Ici, pool avec la valeur maximale au lieu de la valeur moyenne.

A8


def max_pooling(img, G=8):
    """
Mise en commun maximale

    parameters
    -------------------------
    param1: numpy.image au format ndarray
    param2:Division de la grille en 8x8

    returns
    -------------------------
Nombre maximum groupé.image au format ndarray
    """
    #Copier l'image
    out = img.copy()
    # H(Hauteur de l'image), W(Largeur de l'image), C(Couleur)Avoir
    H, W, C = img.shape
    #Division du réseau
    Nh = int(H / G)
    Nw = int(W / G)

    #Regroupement moyen pour chaque plage divisée en 8
    for y in range(Nh):
        for x in range(Nw):
            for c in range(C):
                out[G*y:G*(y+1), G*x:G*(x+1), c] = np.max(out[G*y:G*(y+1), G*x:G*(x+1), c]).astype(np.int)
    
    return out

#Mise en commun maximale
img8 = average_pooling(img)
#Sauvegarder le résultat
cv2.imwrite(OUT_DIR + 'ans8.jpg', img8)
#Afficher l'image
cv2_imshow(img8)
cv2.waitKey(0)
cv2.destroyAllWindows()

img8.png

Q.9. Filtre gaussien

Implémentez un filtre gaussien (3x3, écart type 1,3) pour supprimer le bruit dans imori_noise.jpg. Le filtre gaussien est un type de filtre qui lisse (lisse) l'image, et est également utilisé pour la suppression du bruit. D'autres méthodes d'élimination du bruit comprennent un filtre médian (Q.10), un filtre de lissage (Q.11) et un filtre LoG (Q.19). Le filtre gaussien lisse les pixels périphériques du pixel d'intérêt par pondération avec une distribution gaussienne, et est défini par l'équation suivante. Ces poids sont appelés noyaux ou filtres. Cependant, comme les bords de l'image ne peuvent pas être filtrés tels quels, la partie avec des pixels insuffisants est remplie de 0. C'est ce qu'on appelle le remplissage 0. Et les poids sont normalisés. (somme g = 1)

A9


#Traité par OpenCV
# cv2.GaussianBlur(src, ksize, sigmaX)
# src:Image d'entrée, ksize:Taille du noyau, sigmaX:Distribution gaussienne sigma_x
img9 = cv2.GaussianBlur(img_noise, ksize=(3, 3), sigmaX=1.3)

#Sauvegarder le résultat
cv2.imwrite(OUT_DIR + 'ans9.jpg', img9)
#Afficher l'image
cv2_imshow(img9)
cv2.waitKey(0)
cv2.destroyAllWindows()

img9.png

Référence: [Python / OpenCV] Blur / Smooth with Gaussian Filter

Q.10 Filtre médian

Implémentez un filtre médian (3x3) pour supprimer le bruit de imori_noise.jpg. Un filtre médian est un type de filtre qui lisse une image. Il s'agit d'un filtre qui génère la valeur médiane (valeur médiane) dans la zone 3x3 du pixel d'intérêt. Il s'agit également de zéro remplissage.

A10


#Traité par OpenCV
"""
cv2.medianBlur(src, ksize)
image d'entrée src
Taille du noyau du filtre du noyau (près de 8 si 3)
"""
#Filtre médian
img10 = cv2.medianBlur(img_noise, ksize=3)
#Sauvegarder le résultat
cv2.imwrite(OUT_DIR + 'ans10.jpg', img10)
#Afficher l'image
cv2_imshow(img10)
cv2.waitKey(0)
cv2.destroyAllWindows()

img10.png

Référence: [Python / OpenCV] Blur / Smooth / Noise Removal with Median Filter

Impressions

Le prétraitement est important dans l'apprentissage automatique. Si vous ne connaissez pas la méthode, vous ne proposerez aucune idée, donc cela en vaut la peine. Le format Knock facilite le travail

Recommended Posts

100 coups sur le traitement d'image !! (001 --010) Soigneusement et soigneusement
Traitement d'image 100 coups ①
100 coups sur le traitement d'image !! (011-020) Début de partie
Traitement de l'expansion et de la contraction de l'image
Traitement d'image avec la binarisation Python 100 knocks # 3
Traitement d'image 100 coups Q9, Q10 (filtre) speedup
100 traitement d'image par Python Knock # 2 Échelle de gris
100 traitements linguistiques frappent 03 ~ 05
[Traitement d'image] Postérisation
100 coups de traitement linguistique (2020): 40
100 coups de traitement linguistique (2020): 32
100 coups de traitement linguistique (2020): 35
traitement d'image python
100 coups de traitement linguistique (2020): 39
100 coups de traitement linguistique (2020): 22
100 coups de traitement linguistique (2020): 26
100 coups de traitement linguistique (2020): 34
100 traitement d'image avec Python Knock # 8 Max Pooling
100 coups de traitement linguistique (2020): 42
100 coups de traitement linguistique (2020): 29
Le traitement de 100 langues frappe 06 ~ 09
100 coups de traitement linguistique (2020): 43
100 coups de traitement linguistique (2020): 24
100 coups de traitement linguistique (2020): 45
100 coups de traitement linguistique (2020): 10-19
100 coups de traitement linguistique (2020): 30
100 coups de traitement linguistique (2020): 00-09
100 coups de traitement linguistique (2020): 31
100 coups de traitement linguistique (2020): 48
100 coups de traitement linguistique (2020): 44
100 coups de traitement linguistique (2020): 41
100 coups de traitement linguistique (2020): 37
Traitement d'image avec Python 100 knocks # 7 pooling moyen
100 coups de traitement linguistique (2020): 25
100 coups de traitement linguistique (2020): 23
100 coups de traitement linguistique (2020): 33
100 coups de traitement linguistique (2020): 20
100 coups de traitement linguistique (2020): 27
100 coups de traitement linguistique (2020): 46
100 coups de traitement linguistique (2020): 21
Traitement d'image par Python 100 knock # 9 Filtre Gaussien
100 coups de traitement linguistique (2020): 36
100 coups de traitement du langage amateur: 71
100 coups de traitement du langage amateur: 56
100 coups de traitement du langage amateur: 24
100 coups de traitement du langage amateur: 50
100 coups de traitement du langage amateur: 59
100 coups de traitement du langage amateur: 70
Traitement d'image avec MyHDL
100 coups de traitement du langage amateur: 62
100 coups de traitement du langage amateur: 60
100 coups de traitement du langage amateur: 92
100 coups de langue amateur: 30
100 coups de langue amateur: 06
100 coups de traitement du langage amateur: 84
100 coups de traitement du langage amateur: 81
100 coups de langue amateur: 33
100 coups de traitement du langage amateur: 46
100 coups de traitement du langage amateur: 88
100 coups de traitement du langage amateur: 89