OpenCV est une bibliothèque pratique pour travailler avec des images. Gestion d'image de base à l'aide de cv2
Chargez l'image et sortez-la. Pour charger une image
OpenCV Utilisez la fonction cv2.imread ().
cv2.imread("nom de fichier")
Pour sortir une image Utilisez la fonction cv2.imshow (). La taille de la fenêtre qui affiche l'image est automatiquement ajustée.
cv2.imshow("Nom de la fenêtre",Lire les données d'image)
Je vais lire l'image et la sortir.
#Importer la bibliothèque
import numpy as np
import cv2
#Chargez l'image
img = cv2.imread("./4050_data_cleansing_data/sample.jpg ")
#Le nom de la fenêtre qui affiche l'image est"sample"
#L'image chargée est"img"est
cv2.imshow("sample", img)
Comment créer et enregistrer une image monochrome. Lors du traitement d'images avec cv2, l'ordre de spécification des couleurs n'est pas RVB Veuillez noter que ce sera BGR.
Créer une matrice NumPy pour créer une image Utilisation de la fonction np.array () De plus, par plusieurs boucles qui combinent l'instruction for et la fonction range () Effectue un traitement tel que le dessin côte à côte des informations de couleur de chaque pixel. L'exemple de code ci-dessous spécifie des valeurs pour [B, G, R] 512 images horizontalement avec la première pour Le second pour est une boucle multiple qui crée 512 images verticalement. Le type de données est un type entier non signé 8 bits avec une plage de valeurs de 0 à 255. Spécifiez uint8
np.array([[[B, G, R] for _ in range(Taille d'image horizontale)] for _ in range(Taille d'image verticale)], dtype="uint8")
_ In "for _ in range" est utilisé lorsque le nom de variable correspondant à _ n'est pas spécifié lors de la répétition du processus dans l'instruction for.
Pour enregistrer une image
OpenCV
cv2.imwrite()Utilisez une fonction.
cv2.imwrite("nom de fichier",Données d'image créées)
Par exemple, créez une image rouge solide avec une taille d'image de 512 px en hauteur et 512 px en largeur.
import numpy as np
import cv2
#Déterminez la taille de l'image
img_size = (512, 512)
#Créer une matrice avec des informations d'image avec NumPy
#Puisqu'il s'agit d'une image rouge, chaque élément est[0, 0, 255]Sur, 512*Pensez à créer une matrice de 512
#Notez que la matrice est transposée
#Chaque élément des données d'image est 0~Comme il ne prend qu'une valeur de 255, spécifiez le type de données avec l'option dtype pour que cela soit clair.
my_img = np.array([[[0, 0, 255] for _ in range(img_size[1])] for _ in range(img_size[0])], dtype="uint8")
#afficher
cv2.imshow("sample", my_img)
#sauvegarder
#Le nom du fichier est"my_red_img.jpg "
cv2.imwrite("my_red_img.jpg ", my_img)
Comment recadrer et redimensionner une image. Le rognage est l'opération d'extraction d'une partie de l'image. Le redimensionnement consiste à redimensionner (agrandir ou réduire) l'image.
Le rognage consiste à spécifier la plage de la matrice qui représente l'image. Coupez la partie spécifiée de l'image en carré. Lors de la spécification de la plage, le coin supérieur gauche de l'image est 0.
img[y point de départ: y point de fin,x point de départ: x point de fin]
Resize utilise la fonction cv2.resize ().
cv2.resize(données d'image, (Largeur après redimensionnement,Hauteur après redimensionnement))
import numpy as np
import cv2
import matplotlib.pyplot as plt
#Charger l'image
# cv2.imread lit l'image avec le type ndarray de NumPy
img = cv2.imread("./4050_data_cleansing_data/sample.jpg ")
#Les données d'image lues sont (hauteur x largeur x nombre de couleurs))Triple tableau de
size = img.shape #Taille(1000, 667, 3)
#Extraire en spécifiant une plage (une valeur fixe ou une tranche est possible pour la spécification de plage)
#Lorsque vous voulez diviser en n parties égales, prenez le quotient de taille, mais tronquez après la virgule décimale
my_img = img[: size[0] // 2, : size[1] // 3]
#Lors de la spécification d'une nouvelle taille(largeur,la taille)Sera de l'ordre de
#En doublant la largeur et la hauteur tout en conservant l'agrandissement d'origine
my_img = cv2.resize(my_img, (my_img.shape[1] * 2, my_img.shape[0] * 2))
#afficher
#Affichage à l'aide de Matplotlib, qui affiche l'échelle pour une compréhension facile de la plage spécifiée par rognage et redimensionnement.
my_img = cv2.cvtColor(my_img, cv2.COLOR_BGR2RGB)
plt.imshow(my_img)
plt.show()
# cv2.Lors de l'affichage avec imshow
# cv2.imshow("sample", my_img)
En tant qu'application de redimensionnement, si vous réduisez l'image pour réduire le nombre de pixels puis revenez à sa taille d'origine Vous pouvez appliquer une mosaïque à l'image.
Pour faire pivoter l'image
cv2.warpAffine()Utilisez une fonction.
Cette fonction effectue une transformation géométrique appelée transformation affine. La transformation d'affine est exprimée par une combinaison de mouvement parallèle et de transformation linéaire (agrandissement / réduction, cisaillement (biais), rotation).
cv2.warpAffine(Données d'image d'origine,Matrice de transformation,Taille de l'image de sortie)
Les paramètres sont les suivants.
Premier argument: rotation des données d'image d'origine (tableau NumPy ndarray)
Deuxième argument: matrice de conversion (tableau NumPy ndarray)
Troisième argument: taille de l'image de sortie (taple)
La matrice de conversion spécifiée dans le deuxième argument est
cv2.getRotationMatrix2D()Obtenez-le avec une fonction.
cv2.getRotationMatrix2D(Coordonnées du centre de l'image,L'angle que vous souhaitez faire pivoter,Rapport d'échelle)
Les paramètres sont les suivants.
Premier argument: Coordonnées du centre de l'image (taple)
Deuxième argument: Angle que vous souhaitez faire pivoter (pas Radian)
Troisième argument: grossissement de l'agrandissement / réduction (1x vaut 1).0)
import numpy as np
import cv2
img = cv2.imread("./4050_data_cleansing_data/sample.jpg ") #Taille(1000, 667, 3)
# warpAffine()Le deuxième argument de la fonction`Matrice de transformation`Obtenir
mat = cv2.getRotationMatrix2D(tuple(np.array([img.shape[1], img.shape[0]]) / 2), 180, 2.0)
#Pivote de 180 degrés à un grossissement 2x
my_img = cv2.warpAffine(img, mat, img.shape[::-1][1:3])
cv2.imshow("sample", my_img)
L'inversion est
cv2.flip()Utilisez une fonction.
cv2.flip(données d'image,axe)
Les paramètres sont les suivants.
Premier argument: données d'image d'origine à inverser
Deuxième argument: axe cible
Lorsque l'axe cible est 0, il est centré sur l'axe x (à l'envers), et lorsqu'il est positif, il est centré sur l'axe y (inversion gauche-droite).
Lorsqu'il est négatif, il retourne autour des deux axes.
import numpy as np
import cv2
img = cv2.imread("./4050_data_cleansing_data/sample.jpg ")
#axe x axe y Inverse autour des deux axes
my_img = cv2.flip(img, -1)
cv2.imshow("sample", my_img)
Convertissez l'image en un autre espace colorimétrique. OpenCV prend en charge divers espaces colorimétriques et peut être converti les uns aux autres à l'aide de la fonction cv2.cvtColor ().
cv2.cvtColor(données d'image,Code à convertir dans un autre espace colorimétrique)
Par exemple, convertissez une image dans l'espace colorimétrique BGR en espace colorimétrique Lab. L'espace colorimétrique de laboratoire est un système de couleurs excellent en ce qu'il est conçu pour ressembler à la vision humaine.
import numpy as np
import cv2
img = cv2.imread("./4050_data_cleansing_data/sample.jpg ")
#Convertir BGR en espace colorimétrique Lab
my_img = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)
cv2.imshow("BGR to LAB", my_img)
cv2.imread lit les images dans l'espace colorimétrique BGR par défaut Par exemple, Matplotlib et SciPy utilisent par défaut RVB.
Vous pouvez utiliser COLOR_BGR2GRAY pour convertir en échelle de gris. Pour les autres codes de conversion, consultez le site officiel d'OpenCV.
L'inversion de la couleur d'une image est appelée inversion négative / positive. Une inversion noir et blanc est effectuée pour les images monochromes et une inversion de couleur complémentaire est effectuée pour les images en couleur.
La valeur RVB étant comprise entre 0 et 255, vous pouvez inverser la couleur en remplaçant une certaine valeur de pixel x par 255-x. Les valeurs de pixels lues par OpenCV sont un tableau numpy en trois dimensions. Réécrivez le tableau pixel par pixel de x à 255-x pour chaque canal RVB.
#Coordonnées de chaque pixel(i, j)Et canaux RVB(k)Pour obtenir la valeur du pixel avant la conversion en spécifiant
img[i][j][k] = x
Acquérir les coordonnées avec l'instruction for et len (img [i]), accéder à chaque pixel dans l'ordre et convertir la valeur de pixel pour chaque canal RVB.
import numpy as np
import cv2
img = cv2.imread("./4050_data_cleansing_data/sample.jpg ")
# img.la forme est(1000, 667, 3)
#Chaque je, j,Est la valeur de k
#Coordonnées des pixels(i, j)Avoir
for i in range(len(img)):
for j in range(len(img[i])):
#Canal RVB(k:0-2)Avoir
for k in range(len(img[i][j])):
#Coordonner(i, j)Canal RVB(k:0-2)Convertir la valeur de pixel pour chacun
img[i][j][k] = 255 - img[i][j][k]
cv2.imshow("sample", img)
#Cv2 dans OpenCV.bitwise_not()Inverser à l'aide d'une fonction.
img = cv2.bitwise_not(données d'image)
# cv2.bitwise()La fonction peut manipuler le bit de chaque pixel représenté par 8 bits.
#Inversez chaque bit avec not.
Plus lumineux qu'une certaine quantité pour réduire la taille de l'image Ou rendre toutes les couleurs plus foncées qu'une certaine valeur de la même valeur En bref, le processus de binarisation en blanc et noir
C'est ce qu'on appelle le traitement de seuil.
Le traitement du seuil est cv2.threshold()Utilisez une fonction.
cv2.threshold(données d'image,Seuil,Valeur maximale maxValue,Seuil処理の種類)
Les paramètres sont les suivants.
Premier argument: nom du fichier image d'origine à binariser
Deuxième argument: nombre de pixels pour être le seuil
Troisième argument: valeur de concentration maximale pour le seuil
Quatrième argument: type de traitement de seuil OpenCV (THRESH)_BINARY, THRESH_BINARY_INV, THRESH_TRUNC, THRESH_TOZERO, THRESH_TOZERO_N'importe lequel de INV)
Les types de traitement de seuil pour le quatrième argument sont les suivants.
THRESH_BINAIRE: Les pixels qui dépassent le seuil seront maxValue, et les autres pixels seront 0.
THRESH_BINARY_INV: 0 pour les pixels au-dessus du seuil, maxValue pour tous les autres pixels
THRESH_TRUNC: les pixels qui dépassent le seuil sont définis sur le seuil et les autres pixels ne sont pas modifiés.
THRESH_TOZERO: les pixels qui dépassent le seuil ne sont pas modifiés et les autres pixels sont à 0.
THRESH_TOZERO_INV: les pixels au-dessus du seuil sont définis sur 0, les autres pixels restent inchangés
Différents traitements de seuil peuvent être effectués en fonction du type de traitement de seuil.
import numpy as np
import cv2
#Lire l'image couleur en échelle de gris (cv2.IMREAD_GRAYSCALE ou 0)
img = cv2.imread("./4050_data_cleansing_data/sample.jpg ", 0)
# THRESH_Utilisez TOZERO pour régler le seuil sur 150 et le maximum sur 255
#Le seuil est également renvoyé, alors recevez-le avec retval
retval, my_img = cv2.threshold(img, 150, 255, cv2.THRESH_TOZERO)
cv2.imshow("original", img)
cv2.imshow("sample", my_img)
print(retval)
Affiche une partie de l'image d'origine comme si elle était évidée dans la zone dessinée en blanc d'une autre image. Pour le processus de masquage, préparez une image pour le masquage avec un canal noir et blanc. Masquez l'image d'origine avec la partie noire de l'image de masque Seule la partie blanche est affichée. Le processus de masquage utilise la fonction cv2.bitwise_and ().
cv2.bitwise_and(Données d'image d'origine 1,Données d'image d'origine 2(Données d'image d'origine 1と同じで可), mask=Image pour masque)
import numpy as np
import cv2
#Chargez l'image d'origine
img = cv2.imread("./4050_data_cleansing_data/sample.jpg ")
#Convertissez l'image de masque en une image avec 1 canal (image en échelle de gris) en spécifiant 0 pour le deuxième argument et chargez-la.
mask = cv2.imread("./4050_cleansing_data/mask.png ", 0)
#Redimensionner l'image du masque à la même taille que l'image d'origine
mask = cv2.resize(mask, (img.shape[1], img.shape[0]))
#Spécifiez l'image de masque dans le troisième argument et masque
my_img = cv2.bitwise_and(img, img, mask = mask)
cv2.imshow("sample", my_img)
Il existe plusieurs façons de rendre l'image floue Parmi eux, n✕n pixels autour d'un certain pixel (pixel) sont moyennés et flous. Floutez l'image entière avec un filtre gaussien. Le traitement du flou utilise la fonction cv2.GaussianBlur ().
cv2.GaussianBlur(données d'image,Taille du noyau(n, n), 0)
Les paramètres sont les suivants.
Premier argument: nom du fichier image d'origine à flouter
Deuxième argument: taille du noyau (n ✕ n valeur (n est impair))
Troisième argument: écart-type de direction x du noyau gaussien (généralement 0)
Plus la taille du noyau et les valeurs d'écart type sont élevées, plus le flou est prononcé.
import numpy as np
import cv2
img = cv2.imread("./4050_data_cleansing_data/sample.jpg ")
my_img = cv2.GaussianBlur(img, (51, 51), 0)
cv2.imshow("sample", my_img)
Pour supprimer le bruit dans les images couleur Utilisation de la fonction cv2.fastNlMeansDenoisingColored () Pour la suppression du bruit des images en niveaux de gris Utilisez la fonction cv2.fastNlMeansDenoising ().
#Image couleur
cv2.fastNlMeansDenoisingColored(données d'image)
#Image en échelle de gris
cv2.fastNlMeansDenoising(données d'image)
import numpy as np
import cv2
img = cv2.imread("./4050_data_cleansing_data/sample.jpg ")
my_img = cv2.fastNlMeansDenoisingColored(img)
cv2.imshow("sample", my_img)
Filtre par des moyens non locaux J'ai supprimé le bruit des images couleur et des images en niveaux de gris. Le bruit peut également être éliminé par un traitement d'expansion / contraction.
L'expansion et la contraction sont des méthodes souvent utilisées principalement dans les images binaires. L'expansion est centrée sur un pixel et la valeur maximale (= blanc) dans le filtre est la valeur centrale.
Au contraire, la valeur minimale (= noir) est la valeur centrale de la contraction. Le filtre est une méthode qui utilise quatre pixels en haut, en bas, à gauche et à droite du pixel central Il existe deux méthodes principales qui utilisent huit autour de vous.
L'expansion utilise la fonction cv2.dilate () La contraction utilise la fonction cv2.erode ().
#expansion
cv2.dilate(données d'image,filtre)
#Rétrécir
cv2.erode(données d'image,filtre)
Les paramètres sont les suivants.
Premier argument: nom du fichier image d'origine
Deuxième argument: Filtre (taille du noyau)
Le filtre peut être spécifié soit par un tableau de type numpy ndarray, soit par un taple.
#Lire en échelle de gris
img = cv2.imread("./4050_data_cleansing_data/sample.jpg ", 0)
#Convertir en image binaire
retval, img = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY)
#Définition du filtre
filt = np.array([[0, 1, 0],
[1, 0, 1],
[0, 1, 0]], np.uint8)
# filt = np.ones((3, 3), np.uint8)Mais d'accord
#expansion
my_img = cv2.dilate(img, filt)
cv2.imshow("sample", my_img)
np.uint8 représente le type de données, qui est un type entier non signé représenté par 8 bits.