Ceci est une suite de l'article suivant (je veux faire quelque chose car il n'y a que des articles d'entrée ...)
https://qiita.com/tom_S/items/b85aee14f34dcc856e54
Il est possible d'exprimer la distribution des valeurs de pixels comme s'il y a beaucoup de rouge ou beaucoup de bleu dans l'image.
Le programme qui affiche un histogramme des valeurs RVB sous forme de graphique est illustré ci-dessous.
import cv2
import matplotlib.pyplot as plt #Bibliothèque de tracés d'images
%matplotlib inline #Bibliothèque de tracés d'images
img = cv2.imread("Chemin du fichier image ici")
color_list = ["blue", "green","red"]
for i,j in enumerate(color_list):
hist = cv2.calcHist([img],[i],None,[256],[0,256]) # blue, green,Calculer dans l'ordre du rouge
plt.plot(hist,color= j)
En outre, en uniformisant l'histogramme, la partie claire peut être rendue plus claire et la partie sombre peut être rendue plus sombre. Uniformisez l'histogramme en appelant la fonction equalizeHist comme suit:
import cv2
img = cv2.imread("Chemin du fichier image ici")
img_eq = cv2.equalizeHist(img) # img_Une image avec un histogramme en uniforme est incluse dans l'eq
En gros, la méthode de modification de la luminosité d'une image est appelée conversion gamma. La conversion est effectuée à l'aide d'une table gamma (table de consultation) telle que la formule suivante. Lorsque la valeur de r est supérieure à 1, elle devient plus claire et lorsqu'elle est inférieure à 1, elle devient plus sombre.
y = 255* (x/255)^(1/r)
Le code source est indiqué ci-dessous. (L'explication de la table de recherche est omise)
import cv2
import numpy as np
gamma = 1.5 #R dans l'équation ci-dessus
img = cv2.imread("Chemin du fichier image ici")
gamma_cvt = np.zeros((256,1), dtype= np.uint8)
for i in range(256):
gamma_cvt[i][0] = 255 * (float(i)/255) ** (1.0/gamma)
img_gamma = cv2.LUT(img, gamma_cvt) #img_L'image après la conversion gamma est entrée en gamma
Je pense qu'il est difficile de comprendre quel genre d'effet cela a, alors je vais mettre un lien vers un site qui semble être utile ci-dessous. http://peaceandhilightandpython.hatenablog.com/entry/2016/02/05/004445
La transformation d'affination est une combinaison de mouvement parallèle et de rotation qui déplace une image et de transformation qui transforme un rectangle en quadrilatère parallèle (déformation par cisaillement). La conversion d'affination est effectuée en effectuant un calcul matriciel.
Puisqu'il est nécessaire de faire la somme des matrices pour un mouvement parallèle, ajoutez des coordonnées homogènes à la matrice afin de réduire la transformation linéaire et créez une matrice de transformation pour faire une expression entre des termes singuliers. Affiche le code source pour le mouvement parallèle et la rotation
import cv2
import numpy as np
img = cv2.imread("Chemin du fichier image ici")
h,w = img.shape[:2]
dx,dy = 30,30
afn_mat = np.float32([[1,0,dx],[0,1,dy]]) #Seul mouvement parallèle. Décaler de 30 verticalement et horizontalement
img_afn = cv2.warpAffine(img, afn_mat,(w,h)) # img_L'image après un mouvement parallèle est entrée dans afn
import cv2
import numpy as np
img = cv2.imread("Chemin du fichier image ici")
h,w = img.shape[:2]
rot_mat = cv2.getRotationMatrix2D((w/2,h/2),40,1) # (Coordonnées du centre de rotation,angle de rotation,Échelle de l'image(1 est la même taille))donner
img_afn2 = cv2.warpAffine(img, rot_mat,(w,h)) # img_L'image après rotation est incluse dans afn
La mise à jour de votre propre valeur de pixel en utilisant les informations environnantes est appelée convolution.
Préparez un filtre
Effectuez "(valeur du pixel) x (filtre)" autour du pixel d'intérêt et ajoutez (cela s'appelle le pliage)
Placez sur tous les pixels et pliez
La valeur de pixel est calculée à partir des informations environnantes et le bruit est supprimé. Le code source est affiché ci-dessous
import cv2
import numpy as np
kernel = np.ones((3,3)) /9.0 #Filtre utilisé pour le pliage
img = cv2.imread("Chemin du fichier image ici", 0)
img_kel = cv2.filter2D(img, -1, kernel) #Argument "-1 "est l'image d'origine(img)Moyens de revenir.Effectuer le pliage (lissage)
Les bords verticaux peuvent être détectés par différenciation. Un exemple de code source est présenté ci-dessous.
import cv2
import numpy as np
kernel2 = np.zeros((3,3))
kernel2[0,0] = 1
kernel2[1,0] = 2
kernel2[2,0] = 1
kernel2[0,2] = -1
kernel2[1,2] = -2
kernel2[2,2] = -1
img = cv2.imread("Chemin du fichier image ici", 0)
img_ke2 = cv2.filter2D(img, -1,kernel2) #filtre Sobel
Un filtre qui lisse et estompe uniformément toute la surface. Le code source est indiqué ci-dessous.
import cv2
img = cv2.imread("Chemin du fichier image ici")
img_blur = cv2.blur(img, (3,3)) #Filtre lissant
img_ga = cv2.GaussianBlur(img,(9,9), 2) #2 est la valeur de distribution. Plus cette valeur est élevée, plus floue(Gaushan)
img_me = cv2.medianBlur(img, 5) #Réécrire avec la valeur la plus fréquente(Flou)Filtre médian
Il existe un filtre bilatéral pour la conversion non linéaire. Il s'agit de laisser la partie où le changement de luminosité est drastique et de lisser la partie où le changement de luminosité est progressif. Le code source est indiqué ci-dessous.
import cv2
img = cv2.imread("Chemin du fichier image ici")
img_bi = cv2.bilateralFilter(img,20,30,30)
Une opération d'expansion et de contraction Elle permet de séparer les images en se contractant et de les intégrer en agrandissant. De plus, le bruit peut être éliminé par contraction et expansion. Le code source est indiqué ci-dessous.
import cv2
img = cv2.imread("Chemin du fichier image ici")
ret, img_th = cv2.threshold(img, 110, 255, cv2.THRESH_BINARY) #Binarisation
kernel = np.ones((3,3),dtype = np.uint8) #S'il y a du blanc aux alentours de 8, ce sera blanc, s'il y a beaucoup de noir, ce sera noir
img_d = cv2.dilate(img_th, kernel)
img_e = cv2.erode(img_th,kernel)
img_c = cv2.morphologyEx(img_th,cv2.MORPH_CLOSE, kernel) # img_L'image après le calcul est entrée dans c
# MORPH_CLOSE:Effectue un processus de contractualisation après l'expansion
# (MORPH_En spécifiant OPEN, il est également possible de se dilater après la contraction.)
――Les caractéristiques sont des parties contenant beaucoup d'informations. Il existe les trois fonctionnalités suivantes. Pour l'extraction de caractéristiques, vous trouverez un vecteur propre avec une grande valeur propre dans l'image.
--Flat: Il n'y a pas de direction dans l'image. Le vecteur propre n'est pas biaisé et la valeur propre est petite (moins de caractéristiques)
--Bord: il y a un vecteur propre avec une valeur propre plus grande dans l'image (plus caractéristique que plat)
--Coin: Il y a deux vecteurs propres avec de grandes valeurs propres dans l'image (nombreuses fonctionnalités)
| Extracteur | La description |
|---|---|
| Harris | Si l'échelle change, la précision diminuera. Les caractéristiques sont extraites par des valeurs propres et des vecteurs propres |
| SIFT | Le nombre de fonctionnalités est de 128 dimensions. Non disponible pour un usage commercial en raison de l'acquisition de brevets |
| SURF | Accélérez SIFT. Non disponible pour un usage commercial en raison de l'acquisition de brevets |
| ORB | Quantité de fonctionnalités binarisées. Facile et recommandé |
| KAZE | Utilise un filtre non linéaire. Facile et recommandé |
| AKAZE | Une version plus rapide de KAZE. Facile et recommandé |
Comment afficher le code source de chaque extracteur.
import cv2
import numpy as np
import copy
img = cv2.imread("Chemin du fichier image ici")
img_g = cv2.imread("Chemin du fichier image ici",0)
# Harris
img_harris = copy.deepcopy(img)
img_dst = cv2.cornerHarris(img_g, 2,3,0.04)
#2 est la taille du bloc. Quelle distance doit être détectée? Si vous faites grand, la quantité d'extraction augmentera
# KAZE
img_kaze = copy.deepcopy(img)
kaze = cv2.KAZE_create() #Créer un extracteur de fonctionnalités(KAZE)
kp1 = kaze.detect(img,None)
img_kaze = cv2.drawKeypoints(img_kaze, kp1, None) #L'image marquée dans la partie caractéristique est img_Entrez kaze
# AKAZE
img_kaze = copy.deepcopy(img)
kaze = cv2.AKAZE_create() #Créer un extracteur de fonctionnalités(AKAZE)
kp1 = kaze.detect(img,None)
img_kaze = cv2.drawKeypoints(img_kaze, kp1, None) #L'image marquée dans la partie caractéristique est img_Entrez kaze
# ORB
img_orb = copy.deepcopy(img)
orb = cv2.ORB_create() #Créer un extracteur de fonctionnalités(ORB)
kp2 = orb.detect(img_orb)
img_orb = cv2.drawKeypoints(img_orb, kp2, None) #L'image marquée dans la partie caractéristique est img_Entrez orb
Recommended Posts