[PYTHON] 100 coups sur le traitement d'image !! (011-020) Début de partie

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! 001 --010 provient du lien de droite Traitement d'image Knock 100 !! (001 --010) Soigneusement et soigneusement

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.11. Filtre de lissage

Mettre en place un filtre de lissage (3x3). Le filtre de lissage est un filtre qui produit la valeur moyenne des pixels dans le filtre.

A11

"""
Filtre lissant
cv2.filter2D(src, -1, kernel)
image d'entrée src
noyau de filtre noyau(* Donner comme un tableau NumPy)
"""

#Filtrer le noyau
kernel = np.ones((3,3),np.float32)/9
#Filtre lissant
img11 = cv2.filter2D(img, -1, kernel)

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

Référence: [Python / OpenCV] Lissage / détection de contour par filtrage spatial Référence: Viser à être un débutant

Q.12. Filtre de mouvement

Mettre en place un filtre de mouvement (3x3).

A12

def motion_filter(img, k_size=3):
    """
Filtre de mouvement(Un filtre qui prend une moyenne diagonale)

    parameters
    -------------------------
    param1: numpy.image au format ndarray
    param2:Taille du noyau

    returns
    -------------------------
    (130x130)Numpy.image au format ndarray
    """
    #Obtenez la hauteur, la largeur et la couleur de l'image
    H, W, C = img.shape

    #noyau(numpy.diag()Extraire les composants diagonaux avec)
    K = np.diag([1] * k_size).astype(np.float)  # array([[1., 0., 0.],[0., 1., 0.],[0., 0., 1.]])
    K /= k_size                                # array([[0.33333333, 0., 0.],[0., 0.33333333, 0.],[0., 0., 0.33333333]])

    #Zéro rembourrage
    pad = k_size // 2
    out = np.zeros((H + pad * 2, W + pad * 2, C), dtype=np.float)     #out.shape >>> (130, 130, 3)
    out[pad:pad+H, pad:pad+W] = img.copy().astype(np.float)
    tmp = out.copy()

    #filtration
    for y in range(H):
        for x in range(W):
            for c in range(C):
                out[pad + y, pad + x, c] = np.sum(K * tmp[y:y+k_size, x:x+k_size, c])
    out = out[pad: pad + H, pad: pad + W].astype(np.uint8)

    return out

#Filtre de mouvement
img12 = motion_filter(img, k_size=3)
#Sauvegarder le résultat
cv2.imwrite(OUT_DIR + 'ans12.jpg', img12)
#Afficher l'image
cv2_imshow(img12)
cv2.waitKey(0)
cv2.destroyAllWindows()

Q.13. Filtre MAX-MIN

Mettre en place le filtre MAX-MIN (3x3). Le filtre MAX-MIN est un filtre qui produit la différence entre la valeur maximale et la valeur minimale des pixels dans le filtre, et est l'un des filtres de détection de bord. La détection des bords consiste à détecter des lignes dans une image, et une telle opération d'extraction d'informations dans une image est appelée extraction de caractéristiques. La détection des contours filtre souvent les images en niveaux de gris.

A13

def max_min_filter(img, k_size=3):
    """
    Max-Filtre min(Un filtre qui prend une moyenne diagonale)
Puisqu'il s'agit d'un processus d'échelle de gris, il est divisé en cas pour les images couleur et en cas.

    parameters
    -------------------------
    param1: numpy.image au format ndarray
    param2:Taille du noyau

    returns
    -------------------------
    (130x130)Numpy.image au format ndarray
    """
    #Lorsque l'image d'entrée est en couleur
    if len(img.shape) == 3:
        # H(la taille), W(largeur), C(Couleur)
        H, W, C = img.shape

        #Zéro rembourrage
        pad = k_size // 2
        out = np.zeros((H + pad * 2, W + pad * 2, C), dtype=np.float)     #out.shape >>> (130, 130, 3)
        out[pad:pad+H, pad:pad+W] = img.copy().astype(np.float)
        tmp = out.copy()

        #filtration
        for y in range(H):
            for x in range(W):
                for c in range(C):
                    #Soustrayez le minimum du maximum dans le noyau 3x3
                    out[pad + y, pad + x, c] = np.max(tmp[y:y+k_size, x:x+k_size, c]) - np.min(tmp[y:y+k_size, x:x+k_size, c])
        out = out[pad: pad + H, pad: pad + W].astype(np.uint8)

    #Lorsque l'image d'entrée est en échelle de gris
    else:
        H, W = img.shape
        #Zéro rembourrage
        pad = k_size // 2
        out = np.zeros((H + pad * 2, W + pad * 2), dtype=np.float)
        out[pad:pad+H, pad:pad+W] = img.copy().astype(np.float)
        tmp = out.copy()

        #filtration
        for y in range(H):
            for x in range(W):
                #Soustrayez le minimum du maximum dans le noyau 3x3
                out[pad + y, pad + x] = np.max(tmp[y:y+k_size, x:x+k_size]) - np.min(tmp[y:y+k_size, x:x+k_size])

        out = out[pad: pad + H, pad: pad + W].astype(np.uint8)

    return out

# Max-Filtre min
img13 = max_min_filter(img, k_size=3)
#Sauvegarder le résultat
cv2.imwrite(OUT_DIR + 'ans13.jpg', img13)
#Afficher l'image
cv2_imshow(img13)
cv2.waitKey(0)
cv2.destroyAllWindows()

Référence: Laboratoire de traitement d'images-traitement d'image / compréhension du laboratoire Murakami

Q.14. Filtre différentiel

Mettre en place un filtre différentiel (3x3). Le filtre différentiel est un filtre qui extrait le bord d'une partie où un changement soudain de luminosité se produit et prend la différence entre les pixels adjacents. C'est la partie où la luminosité change radicalement qui devient un bord de l'image. La couleur de la partie rouge change à peine, mais la couleur du cadre bleu change radicalement. Ce changement devient le bord.

A14

"""
cv2.Sobel(src, ddepth, dx, dy[, dst[, ksize[, scale[, delta[, borderType]]]]])
src:Image d'entrée
ddepth:Profondeur de couleur de sortie
dx:Degré de différenciation dans la direction x
dy:L'ordre de différenciation dans la direction y
ksize:Taille du noyau, 1, 3, 5,Spécifiez l'un des 7
"""
#Direction latérale
dx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
#Direction longitudinale
dy = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)

#Sauvegarder le résultat
cv2.imwrite(OUT_DIR + 'ans14_v.jpg', dy)
cv2.imwrite(OUT_DIR + 'ans14_h.jpg', dx)

#Afficher l'image
cv2_imshow(dy)
cv2_imshow(dx)
cv2.waitKey(0)
cv2.destroyAllWindows()

Impression que la partie blanche est plus claire que l'image de la réponse du modèle

Référence: Extraction des bords avec python + OpenCV (filtre Sobel, filtre laplacien)

Q.15. Filtre Prewitt

Implémentez le filtre Prewitt (3x3). Le filtre Prewitt est un type de filtre d'extraction de bord et est défini par l'équation suivante. Il s'agit d'une extension du filtre différentiel à 3x3.

A15

"""
Prewitt(Previt)Est l'un des filtres spatiaux qui extrait les contours d'une image
cv2.filter2D(src, -1, kernel)
image d'entrée src
cv2.CV_64F float64
noyau de filtre noyau(* Donner comme un tableau NumPy)
"""

#Noyau (pour la détection des contours horizontaux et verticaux)
kernel_x = np.array([[1, 0, -1],
                     [1, 0, -1],
                     [1, 0, -1]])

kernel_y = np.array([[1, 1, 1],
                     [0, 0, 0],
                     [-1, -1, -1]])

dx = cv2.filter2D(gray, cv2.CV_64F, kernel_x)
dy = cv2.filter2D(gray, cv2.CV_64F, kernel_y)

#Sauvegarder le résultat
cv2.imwrite(OUT_DIR + 'ans15_v.jpg', dy)
cv2.imwrite(OUT_DIR + 'ans15_h.jpg', dx)

#Afficher l'image
cv2_imshow(dy)
cv2_imshow(dx)
cv2.waitKey(0)
cv2.destroyAllWindows()

Référence: Filtre différentiel du premier ordre Filtre Prewitt - extraction de bord de l'image Référence: [Python / OpenCV] Détection de contour avec filtre Prewitt

Q.16. Filtre Sobel

Mettre en place le filtre Sobel (3x3). Le filtre Sobel est également un filtre qui extrait les arêtes et est défini par l'équation suivante. Il s'agit d'un filtre qui pondère la partie centrale du filtre prewitt.

A16

"""
Le filtre Sobel accentue également les bords avec peu de différence de luminosité.
cv2.filter2D(src, -1, kernel)
image d'entrée src
cv2.CV_64F float64
noyau de filtre noyau(* Donner comme un tableau NumPy)
"""

#Noyau (pour la détection des contours horizontaux et verticaux)
kernel_x = np.array([[1, 0, -1],
                     [2, 0, -2],
                     [1, 0, -1]])

kernel_y = np.array([[1, 2, 1],
                     [0, 0, 0],
                     [-1, -2, -1]])

dx = cv2.filter2D(gray, cv2.CV_64F, kernel_x)
dy = cv2.filter2D(gray, cv2.CV_64F, kernel_y)

#Sauvegarder le résultat
cv2.imwrite(OUT_DIR + 'ans16_v.jpg', dy)
cv2.imwrite(OUT_DIR + 'ans16_h.jpg', dx)

#Afficher l'image
cv2_imshow(dy)
cv2_imshow(dx)
cv2.waitKey(0)
cv2.destroyAllWindows()

Référence: Filtre différentiel de premier ordre Sobel d'extraction des bords du filtre de l'image Référence: [Python / OpenCV] Détection de contour avec filtre Prewitt

Q.17. Filtre laplacien

Implémentez le filtre laplacien. Le filtre laplacien est un filtre qui détecte les contours en effectuant une différenciation quadratique de la luminosité. Puisque les images numériques sont des données discrètes, les différentiels de premier ordre dans la direction x et la direction y sont exprimés par les équations suivantes, respectivement. (Identique au filtre différentiel)

A17

"""
Filtre laplacien(Laplacian Filter)Est un filtre spatial qui utilise la différenciation quadratique pour extraire les contours d'une image
cv2.filter2D(src, -1, kernel)
image d'entrée src
cv2.CV_64F float64
noyau de filtre noyau(* Donner comme un tableau NumPy)
"""

#noyau
kernel = np.array([[0, 1, 0],
                     [1, -4, 1],
                     [0, 1, 0]])

#Filtre laplacien
img17 = cv2.filter2D(gray, cv2.CV_64F, kernel)

#Sauvegarder le résultat
cv2.imwrite(OUT_DIR + 'ans17.jpg', img17)

#Afficher l'image
cv2_imshow(img17)
cv2.waitKey(0)
cv2.destroyAllWindows()

Référence: [Python / OpenCV] Détection de contour avec filtre laplacien (extraction d'arête)

Q.18. Filtre de gaufrage

Implémentez le filtre Emboss. Le filtre Emboss est un filtre qui fait ressortir la partie de contour et est défini par la formule suivante.

A18

"""
Filtre gaufré(Emboss Filter)Est un remplissage d'espace qui met en valeur la partie du contour
cv2.filter2D(src, -1, kernel)
image d'entrée src
cv2.CV_64F float64
noyau de filtre noyau(* Donner comme un tableau NumPy)
"""

#noyau
kernel = np.array([[-2, -1, 0],
                     [-1, 1, 1],
                     [0, 1, 2]])

#Filtre laplacien
img18 = cv2.filter2D(gray, cv2.CV_64F, kernel)

#Sauvegarder le résultat
cv2.imwrite(OUT_DIR + 'ans18.jpg', img18)

#Afficher l'image
cv2_imshow(img18)
cv2.waitKey(0)
cv2.destroyAllWindows()

Référence: [Python / OpenCV] Process with emboss filter

Q.19. Filtre LoG

Implémentez un filtre LoG (sigma = 3, taille du noyau = 5) et détectez les bords de imori_noise.jpg. Le filtre LoG est le laplacien de gaussien, qui est un filtre qui lisse une image avec un filtre gaussien puis extrait les contours avec un filtre laplacien. Puisque le filtre laplcien prend une différenciation quadratique, le filtre gaussien supprime le bruit à l'avance afin d'éviter que le bruit ne soit accentué. Le filtre LoG est défini par l'équation suivante.

A19

"""
Filtre LoG(Laplacian Of Gaussian Filter)Est un filtre qui combine un filtre gaussien et un filtre laplacien.
Après avoir lissé l'image avec le filtre gaussien pour réduire le bruit, le filtre laplacien extrait le contour.

Filtre gaussien
    cv2.GaussianBlur(src, ksize, sigmaX)
    src:Image d'entrée, ksize:Taille du noyau, sigmaX:Distribution gaussienne sigma_x
Filtre laplacien
    cv2.filter2D(src, -1, kernel)
image d'entrée src
    cv2.CV_64F float64
noyau de filtre noyau(* Donner comme un tableau NumPy)
"""

#Filtre gaussien
gauss_img = cv2.GaussianBlur(gray_noise, ksize=(3, 3), sigmaX=1.3)

#noyau
kernel = np.array([[0, 0, 1, 0, 0],
                [0, 1, 2, 1, 0],
                [1, 2, -16, 2, 1],
                [0, 1, 2, 1, 0],
                [0, 0, 1, 0, 0]])

#Filtre laplacien
img19 = cv2.filter2D(gauss_img, cv2.CV_64F, kernel)

#Sauvegarder le résultat
cv2.imwrite(OUT_DIR + 'ans19.jpg', img19)

#Afficher l'image
cv2_imshow(img19)
cv2.waitKey(0)
cv2.destroyAllWindows()

Une image différente de la réponse. Mais quand j'utilise un filtre laplacien, je me sens comme ça. Veuillez me faire savoir si vous faites une erreur.

Référence: [Traitement d'image] Principe du filtre LoG / caractéristiques / formule de calcul

Affichage de l'histogramme Q.20.

Utilisez matplotlib pour afficher l'histogramme de imori_dark.jpg. L'histogramme est un graphique du nombre d'apparitions de pixels. Puisque matplotlib a déjà une fonction appelée hist (), utilisez-la.

A

#histogramme
"""
matplotlib.pyplot.hist(x, bins=10, range=None, normed=False, weights=None,
                       cumulative=False, bottom=None, histtype='bar',
                       align='mid', orientation='vertical', rwidth=None,
                       log=False, color=None, label=None, stacked=False,
                       hold=None, data=None, **kwargs)
x (Obligatoire)Un tableau de données brutes pour créer un histogramme.
bacs bacs(Barre à afficher)Nombre de. Nombre de cours.(Valeur par défaut: 10)
Spécifiez les valeurs minimale et maximale pour le casier de plage.(Valeur par défaut: (x.min(), x.max()))
rwidth Spécifiez la largeur de chaque barre sous forme de valeur numérique ou de tableau.
"""
# ravel:Liste multidimensionnelle en liste 1 dimension,Nombre de bacs:255,Gamme 0~255
plt.hist(img_dark.ravel(), bins=255, rwidth=0.8, range=(0, 255))
plt.savefig("out.png ")
plt.show()

Référence: Science des données avec Python

Impressions

Dans la version officielle, numpy est utilisé et cela se fait selon le principe, mais OpenCV est utilisé autant que possible pour le rendre facile à implémenter.