Problème en segmentation Images

Version imprimable

3 pièce(s) jointe(s)

Bonjour à tous.
je travail sur un modèle d'apprentissage automatique, et j"essaye de segmenter les images d'abord;

mais j'obtiens pas de bon résultat:

Pièce jointe 519514

Pièce jointe 519518

le code :

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
 
fixed_size = tuple((32, 32))
img = cv2.imread("00000_00000_00000.png")
img = cv2.resize(img, fixed_size,interpolation = cv2.INTER_AREA)
org=img.copy()
 
gray_im = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
 
# Contrast adjusting with gamma correction y = 1.2
 
gray_correct = np.array(255 * (gray_im / 255) ** 0.3 , dtype='uint8')
# Contrast adjusting with histogramm equalization
gray_equ = cv2.equalizeHist(gray_correct)
 
 
edges = feature.canny(gray_equ, sigma=0.03, low_threshold=15, high_threshold=55)
 
 
hough_radii = np.arange(5, 55, 1)
hough_res = hough_circle(edges, hough_radii)
 
# Select the most prominent 3 circles
accums, cx, cy, radii = hough_circle_peaks(hough_res, hough_radii,
                                           total_num_peaks=3)
index = list(radii).index(max(radii))
circy, circx = circle_perimeter(cy[index], cx[index], radii[index], shape=img.shape)
H, W = img.shape[:2]
x, y = np.meshgrid(np.arange(W), np.arange(H))
x, y = np.meshgrid(np.arange(W), np.arange(H))
# squared distance from the center of the circle
d2 = (x - cx[index])**2 + (y - cy[index])**2
# mask is True inside of the circle
mask = d2 > radii[index]**2
img[mask] = (0,0,0)
 
#img[circy, circx] = (220, 20, 20)
 
fig=plt.figure()
fig.add_subplot(1, 2, 1)
plt.imshow(org)
plt.axis('off')
plt.title("Originale")
fig.add_subplot(1, 2, 2)
plt.title("Segmentée")
plt.imshow(img)
plt.axis('off')
plt.show()

merci d'avance.

25/11/2019, 20h11
fideel

quelques idées sur la segmentation?? y a t-il d'autre façons pour segmenter le panneau de l’arrière plan svp?
25/11/2019, 22h50
marco056

Citation:

Envoyé par fideel

quelques idées sur la segmentation?? y a t-il d'autre façons pour segmenter le panneau de l’arrière plan svp?

Il y a plusieurs façons de segmenter. Perso, je traite le fichier avec PIL.
25/11/2019, 23h29
fideel

Merci de votre réponse, tu peux me donner une piste stp.
25/11/2019, 23h44
marco056

En fait, il faudrait savoir ce que tu veux faire de ta segmentation.
https://www.lama.univ-savoie.fr/medi...tage_des_eaux"
Des exemples d'utilisation de PIL ici (dernier document) :
http://obelix56.free.fr/spip.php?article55
26/11/2019, 15h41
fideel

j'ai essayé d'appliquer le code existe sur le premier lien sur une image, mais ça marche pas.
en fait comment pouvais-je l'utiliser ?
je suis débutant en ce domaine, et j'ai un projet sur la reconnaissance des panneau routières (german trafic sign), donc j'essaye de segmenter les panneaux de l'arrière plan afin d'extraire les caractéristiques (features) à utiliser pour la classification.
(je dois pas utiliser le deep learning)
et merci une autre fois.

Quelques idées :

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
# -*- coding: utf-8 -*-
 
from PIL import Image
 
ext= '.png'
 
img = "panneau.jpg"
mon_image1 = Image.open(img)
 
 
def seuil2(x):
    if x<100:
        return 0
    elif x>150:
        return 255
    else:
        return x
 
# seuillage à 2 seuils d'une image en niveaux de gris 
mon_image = Image.open(img).convert('L')
pixel = mon_image.load()
for colonne in range(mon_image.size[0]):
    for ligne in range(mon_image.size[1]):
        pixel[colonne,ligne] = seuil2(pixel[colonne,ligne]) 
 
mon_image.save('panneau_seuil2.png')
mon_image.show()
 
def filtre_contour(image1,seuil):
    largeur,hauteur = image1.size
    image2 = Image.new('L',(largeur,hauteur))
    image1 = image1.convert('L')
    pixels1 = image1.load()
    pixels2 = image2.load()
    for ligne in range(hauteur-1):
        for colonne in range(largeur-1):
            if abs(pixels1[colonne,ligne]-pixels1[colonne,ligne+1])\
                  > seuil or\
                  abs(pixels1[colonne,ligne]-pixels1[colonne+1,ligne]) > seuil:
                pixels2[colonne,ligne] = 0
            else:
                pixels2[colonne,ligne] = 255
    return image2
 
res1 = filtre_contour(mon_image1,20)
res1.save('panneau_cont1'+ext)
res1.show()
 
noyau1 =\
[-1,-1,-1,\
-1 , 8,-1,\
-1 ,-1,-1]
 
def filtre_contour1(image1,noyau):
    largeur,hauteur = image1.size
 
    # conversion en niveaux de gris, mode RGB
    image1 = image1.convert("L")
    image2 = Image.new("L",(largeur,hauteur))
    # filtrage de l'image en niveaux de gris
    for y in range(1,hauteur-1):
        for x in range(1,largeur-1):
            liste_pix=[]
            liste_pix.append(image1.getpixel((x-1,y-1)))
            liste_pix.append(image1.getpixel((x,y-1)))
            liste_pix.append(image1.getpixel((x+1,y-1)))
            liste_pix.append(image1.getpixel((x-1,y)))
            liste_pix.append(image1.getpixel((x,y)))
            liste_pix.append(image1.getpixel((x+1,y)))
            liste_pix.append(image1.getpixel((x-1,y+1)))
            liste_pix.append(image1.getpixel((x,y+1)))
            liste_pix.append(image1.getpixel((x+1,y+1)))
            pixel=0
            for i in range(9):
                pixel=int(pixel+noyau[i]*liste_pix[i])
 
            pixel = pixel + 128
            image2.putpixel((x,y),pixel)
    return image2
 
filtre1 = filtre_contour1(mon_image1,noyau1)
filtre1.save("panneau_cont2"+ext)
filtre1.show()
 
def filtre_contour2(image1,noyau):
    largeur,hauteur = image1.size
 
    # conversion en niveaux de gris, mode RGB
    image1 = image1.convert("L")
    image2 = Image.new("L",(largeur,hauteur))
    # filtrage de l'image en niveaux de gris
    for y in range(1,hauteur-1):
        for x in range(1,largeur-1):
            liste_pix=[]
            liste_pix.append(image1.getpixel((x-1,y-1)))
            liste_pix.append(image1.getpixel((x,y-1)))
            liste_pix.append(image1.getpixel((x+1,y-1)))
            liste_pix.append(image1.getpixel((x-1,y)))
            liste_pix.append(image1.getpixel((x,y)))
            liste_pix.append(image1.getpixel((x+1,y)))
            liste_pix.append(image1.getpixel((x-1,y+1)))
            liste_pix.append(image1.getpixel((x,y+1)))
            liste_pix.append(image1.getpixel((x+1,y+1)))
            pixel=0
            for i in range(9):
                pixel=int(pixel+noyau[i]*liste_pix[i])
 
            if pixel < 0:
                pixel =0
            if pixel > 255:
                pixel = 255
            pixel = pixel + 128
            image2.putpixel((x,y),pixel)
    return image2
 
 
filtre2 = filtre_contour2(mon_image1,noyau1)
filtre2.save("panneau_cont3"+ext)
filtre2.show()

30/11/2019, 11h49
fideel

2 pièce(s) jointe(s)

Bonjour.
Merci de ton aide, j'ai testé le code avec des différentes images, ça marche bien sur les images claires de grande taille, mais le problème persiste avec les images sombres, un éclairage élevé ou de petite taille. comme celles-ci:

Pièce jointe 520853

Pièce jointe 520856
01/12/2019, 11h47
marco056

Pour les images de petite taille, il y a moins à traiter donc c'est normal à mon avis que ce soit plus difficile. Pour les autres, il faut éventuellement trouver d'autres noyaux. Je te laisse chercher.