Collection de traitement d'image en Python
Un mémorandum des fonctions de la bibliothèque de traitement d'image souvent utilisée en Python. Sera mis à jour de temps en temps.
On suppose que les bibliothèques suivantes sont importées Library Version opencv @3.2.0_1+contrib+python27 scikit-image @0.12.3_2 scipy @0.19.0_0+gfortran
import numpy as np
import copy
import cv2 as cv
import skimage
import skimage.io as sk
import skimage.filters as fil
import skimage.filters.rank as rank
import skimage.morphology as mor
import skimage.transform as tr
import scipy.misc as sp
import scipy.ndimage as ndi
Read Image Comparaison par bibliothèque utilisée pour charger les images
scikit-image
img = sk.imread(filename,as_grey=False,plugin=None,flatten=None)
- L'image multicanal peut être lue (ceci est pour les images multicanaux 3D)
- La conversion de l'échelle de gris est effectuée lors de la lecture d'une image RVB avec as_gray = True, mais vous devez faire attention car elle devient flottante à 64 bits et la valeur du pixel est écrasée.
OpenCV
img = cv.imread((filename[, flags])
- flags
- cv.IMREAD_COLOR (ou 1): Lire l'image RVB
- cv.IMREAD_GRAYSCALE (ou 0): Convertir en échelle de gris et lire
- cv.IMREAD_UNCHANGED (ou -1): lecture sans conversion (le canal α peut également être lu)
- Notez que le canal sera BGR lors de la lecture des images RVB.
- Peut être converti en RVB avec cv.cvtColor (image, cv2.COLOR_BGR2RGB)
SciPy
img = sp.imread(name, flatten=False, mode=None)
- Je ne l'utilise pas souvent, mais si les deux ci-dessus ne sont pas possibles, je me fierai à lui.
- mode : str, optional
- 'L': lecture de conversion d'échelle de gris (8 bits)
- 'RVB': lecture d'image RVB (3x8 bits)
- 'RGBA': lecture de 4 canaux (4x8 bits)
- 'I': lecture de conversion en niveaux de gris (entier signé 32 bits)
- 'F': lecture de conversion d'échelle de gris (virgule flottante 32 bits)
- Il y a aussi "P", "CMYK" et "YCbCr"
Binalization
Fondamentalement, seul Otsu est utilisé pour la binarisation des images, mais d'autres méthodes sont également utilisées en fonction de l'objectif, donc pour référence.
scikit-image
#Trouvez le seuil pour chaque méthode de binarisation
thrOtsu = fil.threshold_otsu(img)
thrli = fil.threshold_li(img)
thrIso = fil.threshold_isodata(img)
thrYen = fil.threshold_yen(img)
#Binarisation
thrImg = ((thrOtsu < img) * 255).astype(np.uint8)
OpenCV
Lorsque vous ne l'utilisez pas du tout, mais que vous utilisez OpenCV de manière cohérente, comme la lecture.
thr, thrImg = cv.threshold(img, 0, 255, cv.THRESH_BINARY + cv.THRESH_OTSU)
Filtering
Il est principalement utilisé pour la suppression du bruit effectuée en tant que prétraitement du traitement d'image. Pour la suppression du bruit, il est nécessaire d'utiliser différents filtres en fonction du type de bruit et des caractéristiques de l'image. Par conséquent, la configuration ici est résumée pour chaque type de filtrage afin qu'il puisse être utilisé correctement.
Gaussian Fitering Pliez avec un noyau pondéré qui suit une distribution gaussienne. Utilisé pour le lissage général de l'image.
#Distribution de distribution normale
sigma = 1
#Taille du noyau
ksize = (3, 3)
# OpenCV
gauImg = cv.GaussianBlur(img, ksize=ksize, sigmaX=sigma)
# SciPy
gauImg = ndi.gaussian_filter(img, sigma=sigma)
# scikit-image
#Si img est un type float-1~Doit être normalisé à 1
gauImg = fil.gaussian_filter(img, sigma=sigma)
Mean Filtering
Replier avec un noyau de poids moyen. Il est utilisé pour supprimer les bruits fins tels que les bruits uniformes.
#Taille du noyau
ksize = (5, 5)
#Noyau de poids avec un rayon de 20 pixels
selem = disk(20)
# OpenCV
meanImg = cv.blur(img, ksize=ksize)
# scikit-image
#Si img est un type float-1~Doit être normalisé à 1
meanImg = rank.mean(img, selem=selem)
Median Filtering
Filtrage médian. Il est utilisé pour supprimer les bruits de pointe tels que les bruits de sel de sésame.
#Taille du noyau
ksize = 3
#Noyau de poids avec un rayon de 20 pixels
selem = disk(20)
# OpenCV
medImg = cv.medianBlur(img, ksize=ksize)
# scikit-learn
#Si img est un type float-1~Doit être normalisé à 1
medImg = rank.median(img, selem=selem)
Bilateral Filtering
Etant donné que le filtrage gaussien lisse même les pixels caractéristiques tels que les bords, cela devient un problème en fonction du traitement d'image ultérieur. Par conséquent, le filtrage bilatéral peut effectuer un lissage tout en préservant les bords. La différence décisive par rapport au filtrage gaussien n'est pas seulement la distribution gaussienne concernant la différence de distance par rapport au centre du noyau, mais également le noyau pondéré selon la distribution gaussienne concernant la différence de luminosité par rapport à la valeur de luminosité centrale.
#Taille du noyau
d = 5
#Dispersion de la valeur de luminosité Distribution gaussienne
sigmaColor = 1
#Dispersion de la différence de distance Distribution gaussienne
sigmaSpace = 1
# OpenCV
biImage = cv.bilateralFilter(img, d=d, sigmaColor=sigmaColor, sigmaSpace=sigmaSpace)
Morphological Operation
Il effectue principalement des traitements qui affectent considérablement le traitement d'image ultérieur, comme la suppression des niveaux de gris et du bruit de fond des images binaires, et l'extraction des caractéristiques. Cette section résume également chaque processus arithmétique de morphologie. Personnellement, je pense qu'il serait préférable d'emprunter uniquement Dilation et Erosion à la bibliothèque et de créer des fonctions d'ouverture et de fermeture de différentes manières.
Dilation
Processus d'expansion d'un objet dans une image binaire.
#Taille du noyau
kernel = np.ones((3,3),np.uint8)
#Nombre d'essais
iterations = 2
# OpenCV
dilImg = cv.dilate(thrImg, kernel=kernel, iterations=iterations)
# scikit-image
dilImg = mor.dilation(thrImg, selem=kernel)
Erosion
Processus de réduction d'un objet image binaire.
# OpenCV
eroImg = cv.erode(thrImg, kernel=kernel, iterations=iterations)
# scikit-image
eroImg = mor.erosion(thrImg, selem=kernel)
Opening
Il est utilisé lorsque vous souhaitez supprimer les petits bruits. La dilatation est effectuée le même nombre de fois après plusieurs érosions. A ce moment, le nombre de fois de chaque traitement dépend de l'amplitude du bruit à supprimer.
# OpenCV
openImg = cv.morphologyEx(thrImg, cv.MORPH_OPEN, kernel=kernel, iterations=iterations)
# scikit-image
openImg = mor.opening(thrImg, selem=kernel)
Closing
Il est utilisé pour combler les trous qui se produisent lorsqu'un objet ne peut pas être binarisé proprement en raison de l'influence du bruit et de la nature de l'image. L'érosion est effectuée le même nombre de fois après plusieurs dilatations. A ce moment, le nombre de traitements dépend de la taille du trou à remplir.
# OpenCV
closeImg = cv.morphologyEx(thrImg, cv.MORPH_CLOSE, kernel=kernel, iterations=iterations)
# scikit-image
closeImg = mor.closing(thrImg)
White Top-Hat
Il est utilisé pour extraire de petits motifs de caractéristiques qui existaient en arrière-plan en extrayant la différence entre l'image ouverte et l'image d'origine.
# OpenCV
wthImg = cv.morphologyEx(thrImg, cv.MORPH_TOPHAT, kernel=kernel, iterations=iterations)
# scikit-image
wthImg = mor.white_tophat(thrImg)
Black Top-Hat
Il est utilisé pour extraire de petits motifs de caractéristiques qui existaient dans l'objet en calculant la différence entre l'image fermée et l'image d'origine.
# OpenCV
bthImg = cv.morphologyEx(thrImg, cv.MORPH_BLACKHAT, kernel=kernel, iterations=iterations)
# scikit-image
bthImg = mor.black_tophat(thrImg)
Labeling
binaire Un processus pour étiqueter chaque zone de segment dans une image. Il est principalement utilisé pour l'analyse quantitative après binarisation (zone de recherche, coordonnées du centre de gravité, etc.). Il ne prend en charge que les images bidimensionnelles, mais j'ai essayé de l'utiliser car il y avait une fonction pratique dans OpenCV.
#Nombre d'étiquettes(nlabel)Et étiqueter l'image(labImg)seulement
nlabel, labImg = cv.connectedComponents(img)
#Boîte englobante en plus du haut+zone(stats)Et coordonnées du centre de gravité(centroids)Aussi obtenir
nlabel, labImg, stats, centroids = cv.connectedComponentsWithStats(img)
stats: Liste [x, y, largeur, hauteur, surface] pour chaque étiquette centroïde: stocke également les coordonnées du centre de gravité [x, y] dans une liste correspondant à l'étiquette
Le résultat de son utilisation réelle pour les images suivantes est affiché.
img = sk.imread('unko.png')
gimg = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
thrOtsu = fil.threshold_otsu(gimg)
thrImg = ((thrOtsu > img) * 255).astype(np.uint8)
nlabel, labelImg, stats, centroids = cv.connectedComponentsWithStats(thrImg)
colors = []
for n in range(1, nlabel):
#Recadrer chaque merde
tmpImg = img[stats[n][1]:stats[n][1]+stats[n][3], stats[n][0]:stats[n][0]+stats[n][2]] sk.imsave('unko' + str(n) + '.png', tmpImg)
color.append(np.array([random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)]))
leny, lenx = labelImg.shape
colorImg = np.zeros((leny, lenx, 3)).astype(np.uint8)
for x in range(lenx):
for y in range(leny):
for n in range(1, nlabel):
#Coloré selon l'étiquette de chaque zone de merde
if labelImg[y][x] == n:
colorImg[y][x] = color[n-1]
sk.imsave('unko_color.png', colorImg)
Le résultat du recadrage et de l'enregistrement de chaque merde à partir des statistiques obtenues à partir de la fonction d'étiquetage
Le résultat de l'étiquetage couleur de chaque zone de merde
C'est pratique! Couvert de merde!
Rotation of Image
Résumé des fonctions qui font pivoter les images. Cette fois, je résumerai uniquement le cas de la rotation à partir du centre de l'image.
#angle de rotation(Sens antihoraire)
angle = 90
# Scipy
rotImg = ndi.interpolation.rotate(img, angle=angle)
# OpenCV
imsize = img.shape
rotMat = cv.getRotationMatrix2D(tuple(np.array(imsize)/2), angle, scale=1.0)
rotImg = cv.warpAffine(img, rotMat, imsize)
Il existe également une fonction qui retourne l'image.
flipCode = 0
# OpenCV
flipImg = cv.flip(img, flipCode=flipCode)
L'argument flipCode est un paramètre qui contrôle la direction du retournement.
- 0: inversion de l'axe x
- Positif: inversion de l'axe y
- Négatif: x, y inversion des deux axes (identique à une rotation de 180 degrés)
Interpolation
Un résumé des fonctions qui exécutent l'interpolation d'image. Il existe des méthodes d'interpolation d'image Nearest, Bilinear, Bicubic, etc., et elles sont utilisées correctement en fonction de l'image et du but.
#Taille d'interpolation
ipsize = (200, 200)
# OpneCV
#Méthode d'interpolation
cv.INTER_NEAREST # Nearest
cv.INTER_LINEAR # Bilinear
cv.INTER_CUBIC # Bicubic
ipImg = cv.resize(img, ipsize, metLinear)
# scikit-image
#Méthode d'interpolation(Biquintic etc. sont également disponibles)
order = 0 # Nearest
order = 1 # Bilinear (default)
order = 3 # Bicubic
#conserver si img est float_la plage doit être définie sur True
ipImg = tr.resize(img, ipsize, order = 3, preserve_range = True)
Extract Feature
Extrayez des fonctionnalités telles que les bords de l'image. En plus de SIFT, qui est un algorithme d'extraction de caractéristiques, l'extraction des bords à l'aide d'un filtre différentiel est également résumée dans cette section.
SIFT
SIFT (Scale-Invariant Feature Transform) est l'un des algorithmes d'extraction de caractéristiques les plus utilisés, et il extrait des caractéristiques robustes aux changements d'échelle et de position. Il est également utilisé principalement dans le domaine de la reconnaissance d'images en reconnaissance de formes et en apprentissage automatique.
Les fonctions fournies par OpenCV sont stockées dans le module contrib depuis la version 3.0, elles doivent donc être ajoutées à la variante lors de l'installation. Il existe une autre façon de le faire dans les versions jusqu'à 2.4, mais cette fois nous allons le résumer en supposant qu'il s'agit d'OpenCV 3.0 ou version ultérieure.
#Extraction de caractéristiques
det = cv.xfeatures2d.SIFT_create()
kp = det.detect(img) #img est CV_8U(uint8)
#Ajouter à l'image
siftImg = cv.drawKeypoints(img, kp, None)
SURF
SURF (Speeded-Up Robust Features) est un algorithme qui augmente la vitesse de traitement au lieu de réduire le nombre de dimensions du vecteur qui représente la quantité de caractéristiques dans l'algorithme SIFT.
#Extraction de caractéristiques
det = cv.xfeatures2d.SURF_create()
kp = det.detect(img) #img est CV_8U(uint8)
#Ajouter à l'image
surfImg = cv.drawKeypoints(img, kp, None)
Prewitt Filtering
Une technique de filtrage pour détecter le gradient de luminosité dans une image. Le concept du filtre Prewitt est que lors du calcul du gradient dans une certaine direction du noyau, le lissage est effectué dans cette direction et dans la direction horizontale, puis une différenciation est effectuée.
# SciPy
preImg = ndi.filters.prewitt(img)
Sobel Filtering
C'est presque le même filtre différentiel que le filtre Prewitt, sauf qu'il est pondéré au centre du noyau. Personnellement, le filtre Sobel a l'impression que les bords peuvent être enlevés proprement.
# SciPy
sobImg = ndi.filters.sobel(img)
Others
Downhill Filtering
L'algorithme utilisé pour la suppression d'arrière-plan (BG). Voir le papier original [1] pour le contenu.
# seed (Critères pour les valeurs considérées comme BG)Création
seed = copy.deepcopy(img)
seed[1:-1, 1:-1] = img.min()
dilatedImg = mor.reconstruction(seed, img, method='dilation')
dhImg = copy.deepcopy(img - dilated)
Résumé
Quelle que soit la bibliothèque que vous utilisez dans le traitement d'image, il est dangereux de l'utiliser sans comprendre l'algorithme, donc je pense qu'il est important de coder de manière cohérente avec une bibliothèque familière qui connaît le contenu. De plus, comme mon analyse d'image cible principalement les images en niveaux de gris, je ne suis pas doué pour le traitement d'image dans les images RVB, et je n'ai pas été en mesure de le refléter beaucoup dans ce contenu. Dans le futur, j'aimerais apprendre le traitement d'image multicanal avec un œil sur les images RVB. Le contenu sera mis à jour de temps à autre.
Les références
[1] Robinson, Kevin, and Paul F. Whelan. "Efficient morphological reconstruction: a downhill filter." Pattern Recognition Letters 25.15 (2004): 1759-1767.
Recommended Posts