Discussion :

[Bimboucha]

Bonjour, je reviens vers vous car vos réponses m'ont bcp aidaient!

je fais du traitement d'image (détection de contours et extraction), sous python 2.7
le problème que je rencontre est: les contours de l'image sont pas fermés et je ne trouve pas
la méthode ou le code qui permet de faire "le fermeture des contours"

- une autre question, je souhaite extraire les coordonnées des objet (en pixels) et les sauver dans ds fichier .txt
comment faire pour extraire les coordonnées des contours de chaque objet et les sauvegarder dans plusieurs fichier
(ex:dans mon cas je travaille sur une façade d'un bâtiment, je souhaite extraire les contours des fenêtres (une fois trouvés et complétés) et chaque contours
dans un seul fichier .txt à part.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
import matplotlib.pyplot as plt
import numpy as np
from PIL import Image
import cv2
 
'''
                  Importation de l'image
'''
 
img = cv2.imread('bat.jpg')
 
'''
 
'''
                      detection de contours avec Canny
                      '''
 
edges = cv2.Canny(median_blur,250,200)
plt.subplot(121),plt.imshow(median_blur,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(0)
cv2.destroyAllWindows()
 
'''
         pixel list pour un seul objet
         '''
 
#print skel[:]
#print len (skel)
 
fichier = open("data.txt", 'w')
fichier.write("coordonnees des contours de l'image analysees: \n")
for x in range(len(skel)): #parcourir les lignes
    for y in range(len(skel[x])): #parcours des colonnes pour chaques lignes
        if skel[x][y] == 255:    #tout les point des pixels == 255 'en blanc'
            fichier.write("\n" +repr((x ,y)))
 
 
 
fichier.close()

merci bien!

[deusyss]

Salut,

Avant tout, sache que la detection de contour, s'il elle est simple sur des elements basiques, est tres complexes sur les batiments, entre autre. Ne t'etonne donc pas d'avoir des soucis.

Concernant ta question, je ne sais comment clore tes contours, mais cela ne vas pas etre simple. Il va falloir analyser totalement l'image pour y parvenir. Je ne pourrais t'aider à ce niveau, mais je te conseillerai, si cela n'a pas encore été fait, de faire un EqualizeHist histoire d'optimiser les resultats de detection de contours.

Concernant le reste de ta demande, si je comprend bien, par exemple si tu detecte 4 fenetres, tu souhaite enregistrer les coordonnees de chaque fenetre dans un fichier a part c'est cela? Si oui, la aussi cela ne va pas etre simple malheureusement.

En cherchant dans la doc officielle, je suis tombé sur cette page, qui peut contenir des choses interessantes: http://docs.opencv.org/trunk/modules...sContourConvex

[Bimboucha]

Merci bien,

en effet, c'est très compliqué tout ça :/ pour moi, étant débutante
et pour l'extraction, oui oui c'est ça!!

[Bimboucha]

Salut,

En cherchant sur net, j'ai trouvé cette méthode __douglas peucker___ que je mette en PJ #
Si tu pourras m'aider à le coder en python2.7

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
function DouglasPeucker(PointList[], epsilon)
  // Trouve le point le plus éloigné du segment
  dmax = 0
  index = 0
  for i = 2 to (length(PointList) - 1)
    d = DistancePointSegment(PointList[i], Segment(PointList[1], PointList[end])) 
    if d > dmax
      index = i
      dmax = d
    end
  end
 
  // Si la distance dmax est supérieure au seuil, on simplifie
  if dmax >= epsilon
    // Appel récursif de la fonction
    recResults1[] = DouglasPeucker(PointList[1…index], epsilon)
    recResults2[] = DouglasPeucker(PointList[index…end], epsilon)
 
    // Construit la liste des résultats à partir des résultats partiels
    ResultList[] = {recResults1[1…end-1] recResults2[1…end]}
 
  else
    // Tous les points sont proches → renvoie un segment avec les extrémités
    ResultList[] = {PointList[1], PointList[end]}
  end
 
  // Renvoie le nouveau résultat
  return ResultList[]
end

[plxpy]

Bonjour

L’algorithme de Ramer-Douglas-Peucker sert à simplifier un polygone ou une polyligne par la suppression de nœud. Il est beaucoup utilisé en compression de données vectorielles et en généralisation cartographique.

Il ne faut pas fondre sur le premier truc trouvé sur internet qui semble avoir un vague rapport avec ton problème.

Tu pourras, peut-être, trouver un intérêt à cet algo pour généraliser les contours, déterminés automatiquement et éventuellement trop bruités, mais, après. Personnellement, je l'utilise quand j'ai à traiter des polygones, calculés automatiquement, sur de la végétation (bois et forêts), avec plein de "zigouigouis" qui ne sont pas pertinents.

Mais, la première étape est bien la détection de ces contours.

EDIT : le pseudo code que tu as posté est celui de wikipedia ! Je m'en rends compte à l'instant. Dommage d'avoir râté le début de la page ! Et sinon, il faut s'y reprendre à 2 fois pour voir que ce pseudo-code n'est pas du python : oublier "function", lui préférer "def", enlever les "end" et indenter convenablement, ... : le travail est mâché !

[deusyss]

Salut,

Je rejoint plxpy sur le fait que tu ne dois pas te jeter sur le premier code venu. Trouver un code et t'en servir tel quel sans chercher un minimum a comprendre est la pire chose que tu dois faire en Python, et le mieux est de pas le faire du tout .

Après si tu l'analyses, là tu peux y aller.

Par contre, ce que tu fais depasse mes competence mathematique Le traiteement d'image c'est pas mon fort.

Je ne vais malheureusement pas pouvoir t'aider plus (ceci dit en relisant mes posts, je suis pas sur de t'avoir déjà aidé sur ce sujet).

Même si elle est lourde a lire, lis bien la doc à fond d'Open Cv car il y a deja plein de chose d'implementé, et ce serais dommage de reinventer la roue.

J'espère que tu t'en sortira.

[Al_th]

Bonjour Bimboucha,

A la vue de ton problème, il me vient deux idées à l'esprit pour réaliser ce que tu souhaites.

La première : Lorsque tu extrait tes contours, tu obtiendras des contours de toute les formes. Une idée serait de détecter les contours rectilignes (Transformée de Hough par exemple). Cela peut réduire les faux positifs. Si tu as récupéré les contours rectilignes que tu souhaites sous forme de droite, tu pourrais calculer les intersections de ces lignes, et en chercher 4 qui ont la tête d'une fenêtre.

La seconde idée : Il existe de nombreux algorithmes de détection de coins (Harris corner detector par exemple), à voir ce que cela peut t'apporter.

Bon courage,

Al_th

[Bimboucha]

Bonjour et Merci Al__th!

En effet, j'ai pensé aussi à utiliser la transformée de hough!! j'ai des difficultés en programmation informatique notamment sous Python
t'auras pas une idée de comment programmer l'algorithme de hough??

Bien cordialement!!

[Al_th]

Bonjour Bimboucha,

Si tu utilises OpenCV, ne te fatigues pas à recoder la transformée de Hough (http://opencv-python-tutroals.readth...oughlines.html)

Dans le cas ou tu n'utilises pas OpenCV, pourrais-tu préciser ce que tu ne comprends pas et/ou ce que tu n'arrives pas à coder pour que l'on puisse t'apporter une aide plus poussée sur un problème spécifique ?

Al_th