traitement d'image: segmentation avec opencv dans python

Version imprimable

Voir 40 message(s) de cette discussion en une page

28/03/2014, 17h05
Bimboucha

traitement d'image: segmentation avec opencv dans python

Bonjour,
j'ai un probleme :( les experts de opencv en python :)
je sais pas comment faire ceci: - segmentation (squelletisation) d'image.
- Exporter les coordonnées (pixels dans les contours) sous format de fichier .txt
si vous avez des bous de programmes en python qui le font!!!! je vous serai reconnaissante :D
Merci!
30/03/2014, 13h05
deusyss

Salut,

Alors pourrais tu etre plus precis dans ce que tu desire faire? Par squelettisation, entendrais-tu contour?

En attendant tes reponses, je t'invite à lire ce chapitre sur le site. J'y ai traité de façon assez poussé opencv avec Python.

EDIT: bienvenue sur le Forum. Je constate que tu es nouveau. Tu verras, beaucoup d'entraide, tu vas adorer
30/03/2014, 20h59
Bimboucha

Bonsoir et merci pour votre réponse

je traite une image (texturée), détection de contours, puis segmentation pour extraire les coordonnées
de cette images(les pixels des contours) en fichier .txt

je suis bloquée 8O
30/03/2014, 21h02
deusyss

Une fois que tu as tes contours, il faudrait, si ce n'est pas fait, passer en mode noir et blanc (avec un thresold), et à partir de là, utiliser PIL avec un .load(). Tu recupere alors une liste (de memoire) sur laquelle tu peux récuperer pour chaque pixel sa composante.

Cela correspond t il bien à ce que tu souhaites?
30/03/2014, 21h07
Bimboucha

oui presque :), mais pour la segmentation! est ce qu'il existe une fonction
qui le fait?

et puis l'extraction du nombre de pixels si j'ai compris, c'est .load().....?
30/03/2014, 21h09
deusyss

Oui, il y a une fonction dans PIL qui s'appelle load, et qui te permet de recuperer sous forme de liste (de memoire) la composante de chaque pixel à partir de ses coordonnées. A utiliser à la place de get. Get te permet de lire pixel par pixel, mais si tu veux lire toute l'image, load sera beaucoup plus rapide.

Côté segmentation, il ya cela dans la doc officielle
31/03/2014, 10h04
Bimboucha

Bonjour,

En faite, l'objectif est de récupérer les dimensions hauteur et largeur en pixel d'une image (ex: carré), puis les stocker
dans un fichier .txt :calim2:
31/03/2014, 12h37
deusyss

Salut,

Alors j'avoue que ce que tu souhaites faire au final m'apparait un peu flou, raison pour laquelle on semble tourner un peu :mouarf:.

Quand tu parles de carré, tu parles dans l'image ou de l'image elle même? Ce n'est pas clair. En ce qui concerne les dimensions de l'image même, tu a la fonction size de PIL.

Si c'est dans l'image, il te suffit de rechercher les extrême. Ainsi pour une image binarisée, tu cherche le pixel ayant le plus petit X, puis le plus grand, idem en Y. Tu as ainsi par différence la dimension de ton carré en pixel.

Concernant le stockage dans un fichier texte, tout est expliqué ICI.

Je suis quasiment sur que ce que tu cherche à faire au final est entièrement expliqué dans le lien que je t'ai donné. Mais vu que ton but m'est un peu flou, j'ai du mal à te guider plus precisement. Je reprend donc ce que j'ai compris, et corrige moi:
1-Capture d'une image avec OpenCV ou ouverture d'une image existante
2-Segmentation (j'ai l'impression que tu veux parler en fait d'une detection de contour avec binarisation => image en noir et blanc, ex: fond noir avec les contours en pixel blancs)
3-Determination du carré dans lequel s'inscrit les contours
4-Export des caractéristique du carré dans un fichier texte.

Corrige moi, et on affinera tes besoins :ccool:
31/03/2014, 13h07
Bimboucha

En effet, c'est ce que je souhaite faire!! fin presque 8O jusqu'à 3.
pour l'exportation: c'est juste les pixels dans les contours (pas sur toute l'image)

ce que j'appel carré: est juste un exemple d'objet dans une image

Merci beaucoup pour vos réponses.
31/03/2014, 13h29
deusyss

OK,

alors on avance. La detection de countours est traité dans le livre que je t'ai indiqué sur le site:
1-Je te renvois vers la doc d'OpenCV dédiée
2-Detection de contours, binarisation
3-Là, il faut utiliser PIL
4-Gerer un fichier texte
31/03/2014, 13h31
Bimboucha

Merci bcp.
31/03/2014, 18h15
deusyss

De rien.

N'hesite pas a revenir si jamais tu as d'autre question sur le sujet. SInon tu peux passer la discussion à résolu
01/04/2014, 11h40
Bimboucha

Re bonjour,

j'ai encore un question! à propos d'exportation dans un fichier .txt
voici le petit programme que j'ai fais:

fichier = open("data.txt", 'w')
fichier.write('bords'+ repr(bords))
fichier.close()

Mais Ops :? problème!!
en-faite le code il ne stocke pas les pixels "des contours" mais il imprime directement une matrice!!!

bordsarray([[255, 255, 255, ..., 255, 255, 255],
[255, 255, 255, ..., 255, 255, 255],
[255, 255, 255, ..., 255, 255, 255],
...,
[255, 255, 255, ..., 255, 255, 255],
[255, 255, 255, ..., 255, 255, 255],
[255, 255, 255, ..., 255, 255, 255]], dtype=uint8)
Comment faire pour avoir simplement deux colonnes (x,y) tels que les x,y sont les coordonnées des pixels!!!
01/04/2014, 12h19
deusyss
Salut,

Alors avant tout, quand tu desire poster du code, utilise le bouton "#". Le code est ainsi mis en forme ce qui facilite la lecture pour tout le monde. Cela est d'autant plus important, que la tabulation étant primordiale pour Python, on peut rapidement se tromper de bloc dans la comprehension.

Sinon, idéalement, il faut poster l'ensemble de ton code afin que nous puissions avoir une vision complète de ce que fait le programme. Là par exemple, je suppose que bords signifie bordure, mais sans en être sur.

Voilà, cet aparté étant fait, regardons ton code. Je pense que la solution serait quelque chose du genre
Code:

1 2 3 4 for i in range(len(bords)): ma_ligne = str(bords[i][0]) + " " + str(bords[i][1]) fichier.write(ma_ligne)
ou [0] et [1] correspondent aux bonnes coordonnée de ce que tu souhaite. Mais une fois encore, sans le reste du code, difficile d'etre plus precis. Je ne suis pas sur que ce code soir correct.

Python

Je travaille sur une image.png
l'objectif de mon, travail est de détecter les contours de l'objet (Essai avec un carré noir sur fond blanc), pour enfin extraire
les coordonnées de ces contours (soit: en largeur et hauteur) et les exporter en un fichier .txt

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
import cv2
import numpy as np
from matplotlib import pyplot as plt
 
 
##Importation de l'image:
img = cv2.imread('fenetre.jpg')
imgray = cv2.cvtColor (img,cv2.COLOR_BGR2GRAY) #niveau de gris
#....................................................................
#detection de contours:
ret,thresh = cv2.threshold(imgray,127,255,0)
contours, hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
len(contours)#Comptage du nombre de contours fermés
cv2.drawContours(img,contours,-1,(0,255,0),3)
#.....................................................................
# Affichage:
cv2.imshow('Contours',img)
plt.show()
cv2.waitKey(0)
cv2.destroyAllWindows()
 
#....................................................................
# seuillage de image en niveaux de gris
def seuil(x):
    if x<120:
        return 50
    else:
        return 220
 
from PIL import Image
image1 = Image.open('fenetre.jpg').convert('L')
data = image1.getdata()
data = [seuil(data[x]) for x in range(len(data))]
image1.putdata(data)
impix = image1.load()
for i in range(image1.size[0]):       # en noir
    for j in range(image1.size[1]):   # mettre en gris
        impix[i,j] = seuil(impix[i,j]) 
 
image1.show ()
 
#.......................................................................
 
#Segmentation avec 'Canny'
image = cv2.imread('fenetre.jpg',0)
bords = cv2.Canny(image,250,250)# réduction des fausses detection de contours  
plt.subplot(121),plt.imshow(image,cmap = 'gray')
plt.title('Original Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(bords,cmap = 'gray') ##localisation précise des contours
plt.title('Edge Image'), plt.xticks([]), plt.yticks([])
plt.show() #discontinuité des contours?
cv2.waitKey(30)
cv2.destroyAllWindows()
 
#..................................PIXEL LIST..............................#
fichier = open("data.txt", 'w')

02/04/2014, 20h29
deusyss

Salut,

Desole de ne pas etre repasse plus tot. Emploi du temps tres chargé. Bref...

Tu parles d'image png, mais dans ton code tu utilise du jpg??? Bref cela n'empechera pas ton code de fonctionner.

Si tu lis plus attentivement la documentation, tu t'apercevra que cv2.canny te retourne une image. En analysant ce que fait ton code, j'ai fait un simple print bord[0] suivit d'un print len(bords[0) et enfin un print len(bords). Tu t'aperçois alors de 3 choses.
1-bords est une matrice
2-la taille de chaque ligne de la matrice correspond à la largeur de ton image
3-le nombre de lignes de t amatrice correspond à la hauteur de ton image

A partir de là, en analysant ta matrice, tu verra qu'en realité chaque entree (bords[x][y]) correspond à la valeur d'un pixel: 0 pour noir et 255 pour blanc.

Il te faut donc rechercher chaque entree a 255, ou dans ton cas different de 0 puisque tu a une image binaire.

En lisant la doc de numpy, tu trouve ceci

Code:

print np.transpose(np.nonzero(bords))[x]

avec x correspond à chaque pixel different de 0, donc 255.

A partir de là tu as toutes les billes pour te debrouiiller

Bonjour

Merci bcp bcp pour les réponses, ça m'a permet de bien avancer 'sachant que je débute dans le traitement d'image sous python'.

==> juste une derniere 'peut :oops: etre' et je passe à résolu :D
Mon programme maintenant fonctionne 'j'ai fais plusieurs amélioration' et je souhaite detecter les point extreme de mon objet: sauf que il me sort une erreur
que je comprend pas :calim2:
Voici le code:
Code:

1 2 3 4 5 6 #......................... points extremes..................... #coordonnées 'x' de tous les points dans cnt _____cnt = lent (contours)______ x = cnt[:, :, 0] x_min_loc = x.argmin() point = cnt[x_min_loc] leftmost = tuple(point[0])
et voici l'ERROR:
Code:

1 2 3 4 5 6 7 8 9 #ERROR:==> #>>> ================================ RESTART ================================ #Traceback (most recent call last): #File "C:\Python27\Programme Essais\SEUILLAGE\Programme_Principale.py", line 53, in <module> #x = cnt[:, :, 0] #TypeError: 'int' object has no attribute '__getitem__' #>>> ================================ RESTART ================================
Merci encore!!

03/04/2014, 12h35
deusyss

Salut,

Au risque de me repeter, il faut poster à chaque fois l'integralité de ton code. Ce n(est pas pour t'mebeter ok?

Tu ne poste que des bribes, alors que les sources des problèmes peuvent se situer ailleurs. De même, tu peux avoir modifier du code en amont (d'ailleurs tu le dis toi même). Enfin, le message d'erreur indique des références telles que des lignes. Enfin, en absence de code complet, il est légitime que certains refuse d'intervenir sur le post.

Pour toutes ces raisons, il est important que tu postes toujours l’intégralité du code.

En l’occurrence, ici, je ne voit pas à quoi correspond cnt.

Il faut donc que tu postes ton code en entier afin que je puisse t'aider.

Bonjour et merci pour la réponse;

voici mon code, qui fait la detection des contours avec Canny. Je suis toujours bloqué sur comment
extraire la liste des pixels (des contours uniquement) et l’enregistrer sous format .txt

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
import cv2
import numpy as np
from matplotlib import pyplot as plt
 
#.............................#Segmentation avec 'Canny'..........................................
img = cv2.imread('image.jpg',0)
edges = cv2.Canny(img,250,200)# réduction des fausses detection de contours
 
plt.subplot(121),plt.imshow(img,cmap = 'gray')
plt.title('Original Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(edges,cmap = 'gray') ##localisation précise des contours
plt.title('Edge Image'), plt.xticks([]), plt.yticks([])
 
plt.show() #discontinuité des contours?
cv2.waitKey(30)
cv2.destroyAllWindows()
 
##.................Squelettisation ..........
size = np.size(edges)
skel = np.zeros(edges.shape,np.uint8)
 
ret,edges = cv2.threshold(edges,127,255,0)
element = cv2.getStructuringElement(cv2.MORPH_CROSS,(3,3))
done = False
 
while( not done):
    eroded = cv2.erode(edges,element)
    temp = cv2.dilate(eroded,element)
    temp = cv2.subtract(edges,temp)
    skel = cv2.bitwise_or(skel,temp)
    edges = eroded.copy()
 
    zeros = size - cv2.countNonZero(edges)
    if zeros==size:
        done = True
cv2.imshow("skel",skel)
cv2.waitKey(0)
cv2.destroyAllWindows()
 
#................................Pixel list...........................................
 
         ##edges est une matrice           
print edges([0])   ##la taille de chaque ligne de la matrice
                          #correspond à la largeur de image
print len (edges)       #le nombre de lignes de la matrice
                           #correspond à la hauteur de l'image
 
#donc chaque entrée edges[x][y] correspond à la valeur d'un pixel
# 0 pour le noir et 255 pour blanc
#avec x correspond à chaque pixel différent de 0, donc 255
# puisque j'ai une image binaire

Merci d'avance.

Rien de bien sorcier.

Je me permets juste de re-souligner l'importance de toujours poster ton code en entier, dans la mesure ou ton code a bien evoluer depuis ton dernier post complet.

J'ai retoucher un peu ton code de façon à plus respecter les PEP, tout en restant le proche de ce que tu avait fait pour que tu t'y retrouves. Avec l'experience, tu apprendra les bonnes regles de codage en Python (PEP8 et PEP 20).

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
 
 
 
import cv2
import numpy as np
from matplotlib import pyplot as plt
 
 
 
 
 
def segmentation(img, debug=False):
	"""
                Segmentation d'une image avec filtre canny
        """
	try:
		img = cv2.imread(img,0)
		edges = cv2.Canny(img,250,200)# réduction des fausses detection de contours
	except:
		print("probleme d'ouverture d'image")
		edges=[]
 
	if debug == True:
		print np.transpose(np.nonzero(edges))[0] 
 
	return edges, img
 
 
 
 
def display(img, edges, DEBUG):
	"""
                Fonction d'affichage au format matplotlib
        """
	plt.subplot(121),plt.imshow(img,cmap = 'gray')
	plt.title('Original Image'), plt.xticks([]), plt.yticks([])
	plt.subplot(122),plt.imshow(edges,cmap = 'gray') ##localisation précise des contours
	plt.title('Edge Image'), plt.xticks([]), plt.yticks([])
 
	plt.show() #discontinuité des contours?
	cv2.waitKey(30)
	cv2.destroyAllWindows()
 
 
 
 
def squeletisation(edges, debug):
	"""
                Fonction de squeletisation
        """
	size = np.size(edges)
	skel = np.zeros(edges.shape,np.uint8)
 
	ret,edges = cv2.threshold(edges,127,255,0)
	element = cv2.getStructuringElement(cv2.MORPH_CROSS,(3,3))
	done = False
 
	while( not done):
		eroded = cv2.erode(edges,element)
		temp = cv2.dilate(eroded,element)
		temp = cv2.subtract(edges,temp)
		skel = cv2.bitwise_or(skel,temp)
		edges = eroded.copy()
 
		zeros = size - cv2.countNonZero(edges)
		if zeros==size:
			done = True
	cv2.imshow("skel",skel)
	cv2.waitKey(0)
	cv2.destroyAllWindows()
 
 
 
 
def pixel_list(img, edges, DEBUG):
	"""
                Fonction gerant l'enregistrement des contours
                
                Edges est une matrice
                La taille de chaque ligne de la matrice correspond à la largeur
                de image. Le nombre de ligne de la matrice correspond à la hauteur
                de l'image.
                
                donc chaque entrée edges[x][y] correspond à la valeur d'un pixel,
                0 pour le noir et 255 pour blanc, avec x correspond à chaque pixel 
                différent de 0, donc 255 puisque j'ai une image binaire
                
        """      
	if debug == True:
		print edges[200]    #Affiche la ligne 200 de l'image
		print len (edges)    #affiche le nombre de ligne
 
	#Ouverture du fichier
	fichier = open("data.txt", 'w')
	#Ecriture de l'entete
	fichier.write("coordonnees des contours de l'image analysees: \n\n")
 
	#Parcours des lignes
	for i in range(len(edges)):
		#parcours des colonnes pour chaque ligne
		for j in range(len(edges[i])):
			if edges[i][j] == 255:
				#Si detection d'un pixel blanc, on enregistre ses coordonnees
				fichier.write("[%s,%s]\n"%(i,j))
 
 
 
 
if __name__ == "__main__":
	"""
        Fonction principale
        """
	DEBUG = True
 
	rtr_canny, rtr_img = segmentation('fenetre.jpg', DEBUG)
	display(rtr_img, rtr_canny, DEBUG)
	squeletisation(rtr_canny, DEBUG)
	pixel_list(rtr_img, rtr_canny, DEBUG)

J'ai testé ce code chez moi sans aucun soucis.

Je reste à dispo si tu as des questions

Voir 40 message(s) de cette discussion en une page