Discussion :

[ysahel]

Salut,

J'ai une image qui contient deux petites images séparées par un espace (voir pièce jointe).

Comment je pourrai déterminer l'espace entre les deux images et la couper en deux images séparées ?

Je suis débutant en traitement d'image et j'ai besoin de vos aides.

Merci beaucoup d'avance.

[VinsS]

Salut,

Connais-tu les dimensions des images, la séparation est-elle toujours au milieu des images ou est-ce à chaque fois différent ?

Dans le premier cas avec PIL tu pourras extraire chacune des images très simplement, dans le second cas, il te faudra une interface graphique qui implemente une sélection rectangulaire te permettant de récupérer les géométries des images séparées.

Note que avec ta simple visionneuse d'image par défaut de ton OS, tu devrais déjà avoir une idée des tailles des sous-images.

[PauseKawa]

Bonjour,

Vous pouvez utiliser le module PIL pour analyser l'image.
Par exemple le code suivant mets la valeur de la couleur des pixels dans un tableau colonne/ligne:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
from PIL import Image
 
 
im = Image.open("image.GIF")
x, y = im.size
lng = []
imdata = []
for value in list(im.getdata()):
    lng.append(value)
    if len(lng) == x:
        imdata.append(lng)
        lng = []
print(imdata)

Le souci que vous allez avoir c'est que ce n'est pas du blanc (valeur 255):

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
from PIL import Image
 
 
im = Image.open("image.GIF")
x, y = im.size
# Blank = im.getpixel((0, 0))
Blank = range(249, 256) # Blank = 255
lng = []
imdata = []
for value in list(im.getdata()):
    lng.append(value)
    if len(lng) == x:
        imdata.append(lng)
        lng = []
for index in range(y):
    print(index, all([l[index] in Blank for l in imdata]))

Vous allez donc devoir, et cela me gêne, utiliser des valeurs arbitraires. Par exemple un range(200, 256):

Code :

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

1
2
3
4
for index in range(y):
    booleen = all([l[index] in Blank for l in imdata])
    if booleen:
        print(index, booleen)

Sortie

(0, True)
(1, True)
(2, True)
(3, True)
(4, True)
(5, True)
(200, True)
(201, True)
(202, True)
(203, True)
(204, True)
(205, True)
(206, True)
(207, True)
(208, True)
(209, True)
(210, True)
(211, True)
(212, True)
(213, True)
(214, True)
(215, True)
(216, True)
(217, True)
(218, True)
(219, True)
(220, True)

Comme vous le voyez cela donne aussi les bordures (c'est le piège) et votre ligne centrale est comprise entre les lignes 200 et 220. Il vous suffit donc de couper l'image à la ligne 200 + ((220-200)/2).

Pour créer les deux images vous pouvez utiliser im.paste(image, box)
Soit :
im1 = im.paste(, (x1, y1, x2, y2))
Un exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
from PIL import Image
 
 
im = Image.open("image.GIF")
x, y = im.size
l = 210
# a vous de trouver l
im1 = Image.new("RGB", (l, y), "white") # Partie gauche
im1.paste(im, (0, 0, x, y))
im1.save("test1.jpg", "JPEG")

Vous comprendrez que je vous laisse trouver comment trouver le milieu

@+

[PauseKawa]

Oups !

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from PIL import Image
 
 
im = Image.open("image.GIF")
x, y = im.size
lng = []
imdata = []
for value in list(im.getdata()):
    lng.append(value)
    if len(lng) == x:
        imdata.append(lng)
        lng = []
for index in range(x):
    print(index, all([l[index] in range(200, 256) for l in imdata]))

Et pas range(y)...

[PauseKawa]

Petit coup de pouce pour effacer l'erreur

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
#istrue = []
#for index in range(x):
#    istrue.append((index, all([l[index] in range(200, 256) for l in imdata])))
istrue = [(index, all([l[index] in Blank for l in imdata])) for index in range(x)]
flag = False
Start = None
End = None
for idx, item in istrue:
    if not item:
        if End:
            break
        flag = True
    if all((item, flag)):
        if Start:
            End = idx
    else:
        Start = idx
print(Start + (End-Start)/2)
 
values = [all([l[index] in Blank for l in imdata]) for index in range(x)]
flag = False
Start = None
End = None
for idx, item in enumerate(values):
    if not item:
        if End:
            break
        flag = True
    if all((item, flag)):
        if Start:
            End = idx
    else:
        Start = idx
print(Start + (End-Start)/2)

@+

[ysahel]

Merci beaucoup pour vos réponses!!

Alors l'image peut contenir n'importe quoi le nécessaires c'est qu'il y a deux petites images et je ne connais pas leurs dimension (l'affichage de cet image est aléatoire).

Moi j'ai penser à:

Code :

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

1
2
3
4
5
Boucle pour balayer l'axe des xs;
    Boucle pour balayer l'axe des ys; 
        Si je trouve un pixel de couleur différent au blanc je rompe la boucle et je passe à l’abscisse suivant.
 
ainsi de suite jusqu'à ce que je trouve l'espace blanc.

C'est ça en bref mais comme j'avais dit je suis débutant (nul quoi) en traitement d'image et j'ai besoin de vos aides.

[PauseKawa]

Code :

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

1
2
3
4
5
Boucle pour balayer l'axe des xs;
    Boucle pour balayer l'axe des ys; 
        Si je trouve un pixel de couleur différent au blanc je rompe la boucle et je passe à l’abscisse suivant.
 
ainsi de suite jusqu'à ce que je trouve l'espace blanc.

Ainsi vous allez avoir toutes les valeurs 'blanches', pas la séparation entre les images.
Il faut vérifier que tout l'axe y comporte les valeurs voulues.

[PauseKawa]

Un exemple complet pour voir ce que cela donne ?

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
45
46
47
48
49
50
51
52
from PIL import Image
 
 
im = Image.open("image.GIF")
 
x, y = im.size
lng = []
imdata = []
mask = range(200, 256) # Pas de valeur 255 dans votre image.
# On rempli le tableau avec les valeurs.
for value in list(im.getdata()):
    lng.append(value)
    if len(lng) == x:
        imdata.append(lng)
        lng = []
# Pour chaque ligne on verifie si les valeurs sont dans mask ce qui donne True, sinon False.
# On stocke dans une liste sous la forme ((index, booleen),)
istrue = [(index, all([l[index] in mask for l in imdata])) for index in range(x)]
# Pas terrible : a revoir.
flag = False
Start = None
End = None
for idx, item in istrue: # Notre liste d'index/valeur donc
    if not item: # item = False
        # Si End != None nous avons Start et End donc notre separation
        if End:
            # Fin
            break
        # Si End == None c'est que c'etait la bordure de gauche
        flag = True
    if all((item, flag)): # Si flag == True et que item == True (une ligne qui remplie les conditions mask)
        # Si nous avons le depart Start
        if Start:
            # End deviens idx. En fin de boucle cela serat la derniere valeur idx valide.
            End = idx
    else:
        # Sinon c'est la premiere ligne valide donc Start
        Start = idx
# On calcule le milieu de la 'bande'
tocut = Start + (End-Start)/2
# On 'coupe' deux parties de l'image suivant l'axe tocut
crop1 = im.crop((0, 0, tocut, y))
crop2 = im.crop((tocut, 0, x, y))
# On cree des images vides aux dimensions
im1 = Image.new("RGB", (tocut, y), "white")
im2 = Image.new("RGB", (x-tocut, y), "white")
# On colle dans les images les parties coupees
im1.paste(crop1, (0, 0, tocut, y))
im2.paste(crop2, (0, 0, x-tocut, y))
# Et on enregistre.
im1.save("test1.jpg", "JPEG")
im2.save("test2.jpg", "JPEG")

L'exemple reste cantonné à la question (séparation en deux images) et à l'image donnée (mask) mais rien n’empêche d'en faire une fonction du style def verticalcut(im, mask=(255,), nbimage=False)

@+

[PauseKawa]

Petite question :

Alors l'image peut contenir n'importe quoi le nécessaires c'est qu'il y a deux petites images et je ne connais pas leurs dimension (l'affichage de cet image est aléatoire).

Le format de l'image est il toujours le même ? (GIF) Si ce n'est pas au même format im.getdata() risque de retourner un tuple de couleur RGB.
La palette de couleur est elle toujours la même ? De cela vas dépendre mask.

Voici le code pour découper le fichier joint.

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
45
46
from PIL import Image, ImageColor
 
 
im = Image.open("exemple.jpg")
 
x, y = im.size
mask = (75, 79, 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, 122,
        123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
        136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 147, 148, 149,
        152, 218, 219, 220, 221, 222, 223, 224)
lng = []
imdata = []
for value in list(im.getdata()):
    if isinstance(value, tuple):
        value = (value[0]*299 + value[1]*587 + value[2]*114)/1000
    lng.append(value)
    if len(lng) == x:
        imdata.append(lng)
        lng = []
istrue = [(index, all([l[index] in mask for l in imdata])) for index in range(x)]
# Pas terrible : a revoir.
flag = False
Start = None
End = None
for idx, item in istrue:
    if not item:
        if End:
            break
        flag = True
    if all((item, flag)):
        if Start:
            End = idx
    else:
        Start = idx
 
tocut = Start + (End-Start)/2
crop1 = im.crop((0, 0, tocut, y))
crop2 = im.crop((tocut, 0, x, y))
im1 = Image.new("RGB", (tocut, y), "white")
im2 = Image.new("RGB", (x-tocut, y), "white")
im1.paste(crop1, (0, 0, tocut, y))
im2.paste(crop2, (0, 0, x-tocut, y))
im1.save("test1.jpg", "JPEG")
im2.save("test2.jpg", "JPEG")

Vous remarquerez premièrement

Code :

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

1
2
     if isinstance(value, tuple):
        value = (value[0]*299 + value[1]*587 + value[2]*114)/1000

Que vous pouvez rajouter dans votre code.
Deuxièmement mask... Ne demandez pas comment car c'est complètement 'arbitraire'.

Maintenant il y a sans doute d'autres méthodes : Je ne suis pas habitué a manipuler les images.

@+

[plxpy]

Bonjour,

Je n'ai regardé les codes proposés qu'en diagonale. Je n'interviens pas sur le fond mais il y a, néanmoins, un petit problème concernant le "mask" et les pixels "blancs".

Le format GIF s'appuye sur une table de couleurs et quand, via la méthode getdata ou encore getpixel, on récupère 251 , il s'agit de l'index dans cette table, sans corrélation directe avec une quelconque couleur.

Ici (voir les spécifications GIF), la table de couleur se présente sous la forme de 256 triplets (R,G,B) à partir de l'offset 13, avec 1 octet non signé par couleur (c'est alambiqué mais c'est la spec, je n'y suis pour rien) :

Code :

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

1
2
3
4
5
6
7
8
9
>>> img = open('image.GIF')
>>> img.seek(13)
>>> color_table = list()
>>> for i in range(256):
...     color_table.append(unpack('3B',img.read(3)))
... 
>>> 
>>> color_table[251]
(255, 255, 255)

La valeur 251 retournée via getdata ou getpixel correspond ici et seulement ici à (r,g,b) = (255,255,255), mais ça pourrait ne pas être le cas.


Par exemple, je crée une nouvelle image en modifiant l'ordre des triplets (R,G,B) de la table (je mets les couleurs les plus claires en premier) :

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
>>> old = open('image.GIF')
>>> new = open('new_image.GIF','wb')
>>> 
>>> # recopie des octets avant la table de couleurs
... new.write(old.read(13))
>>> 
>>> from struct import unpack
>>> 
>>> # je charge la table des couleurs actuelle
... color_table = [ unpack('3B',old.read(3))  for i in range(256) ]
>>> 
>>> # je la trie avec les couleurs claires en premier
... color_table.sort(key = lambda rgb: sum(rgb), reverse=True)
>>>
>>> # maintenant un 251 correspond au (r,g,b)
... print color_table[251]
(0, 0, 0)
>>>
>>> # j'écris la nouvelle table de couleur
... for rgb in color_table:
...     new.write(pack('3B',*rgb))
... 
>>> # j'écris le reste du fichier et ferme
... new.write(old.read())
>>> new.close()

L'image résultat est très différente, n'est-elle pas ? Cependant, on obtient toujours un 251 en guise de premier pixel :

Code :

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

1
2
3
4
5
>>> new = Image.open('new_image.GIF')
>>> list(new.getdata())[0]
251
>>> new.getpixel((0,0))
251

Pour travailler avec des couleurs "naturelles", la première chose à faire après l'ouverture de l'image (Image.open) est de la convertir (convert) en RGB - et travailler sur des triplets - ou en mode L (panchromatique)

[PauseKawa]

Merci pour les infos plxpy (et dire que j'ai étudier les spécifications du format gif il n'y a pas longtemps... )

Il suffit donc de passer par:

Code :

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

1
2
3
im = Image.open("image.GIF")
if im.mode != 'RGB':
    im = im.convert('RGB')

Ce qui coller au code (qui est a revoir mais pas le temps) donne:

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
from PIL import Image
 
 
im = Image.open("image.GIF")
if im.mode != 'RGB':
    im = im.convert('RGB')
 
x, y = im.size
mask = range(200, 256)
lng = []
imdata = []
for value in list(im.getdata()):
    if isinstance(value, tuple):
        value = (value[0]*299 + value[1]*587 + value[2]*114)/1000
    lng.append(value)
    if len(lng) == x:
        imdata.append(lng)
        lng = []
istrue = [(index, all([l[index] in mask for l in imdata])) for index in range(x)]
# Pas terrible : a revoir.
flag = False
Start = None
End = None
for idx, item in istrue:
    if not item:
        if End:
            break
        flag = True
    if all((item, flag)):
        if Start:
            End = idx
    else:
        Start = idx
 
tocut = Start + (End-Start)/2
crop1 = im.crop((0, 0, tocut, y))
crop2 = im.crop((tocut, 0, x, y))
im1 = Image.new("RGB", (tocut, y), "white")
im2 = Image.new("RGB", (x-tocut, y), "white")
im1.paste(crop1, (0, 0, tocut, y))
im2.paste(crop2, (0, 0, x-tocut, y))
im1.save("test1.jpg", "JPEG")
im2.save("test2.jpg", "JPEG")

Par chance la table des couleurs est dans l'ordre

Une idée pour ce qui est de trouver la 'séparation' ?

@+

[PauseKawa]

Une idée pour ce qui est de trouver la 'séparation' ?

A ben oui... im.convert('1')

Code :

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

1
2
3
4
5
6
from PIL import Image
 
 
im = Image.open("image.GIF")
im = im.convert('1')
im.save("test1.jpg", "JPEG")

Il suffit de localiser la bande blanche, qui l'est pour le coup...

Maintenant il y a sans doute d'autres méthodes : Je ne suis pas habitué a manipuler les images.

Je n'interviens pas sur le fond

N'hésite surtout pas ! C'est un domaine ou je ne suis pas à l'aise.

@+

[ysahel]

Merci Beaucoup pour vos réponse. J'ai réussi à séparer les deux images avec le code de pausekawa

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
45
46
47
48
49
50
51
52
from PIL import Image
 
 
im = Image.open("image.GIF")
 
x, y = im.size
lng = []
imdata = []
mask = range(200, 256) # Pas de valeur 255 dans votre image.
# On rempli le tableau avec les valeurs.
for value in list(im.getdata()):
    lng.append(value)
    if len(lng) == x:
        imdata.append(lng)
        lng = []
# Pour chaque ligne on verifie si les valeurs sont dans mask ce qui donne True, sinon False.
# On stocke dans une liste sous la forme ((index, booleen),)
istrue = [(index, all([l[index] in mask for l in imdata])) for index in range(x)]
# Pas terrible : a revoir.
flag = False
Start = None
End = None
for idx, item in istrue: # Notre liste d'index/valeur donc
    if not item: # item = False
        # Si End != None nous avons Start et End donc notre separation
        if End:
            # Fin
            break
        # Si End == None c'est que c'etait la bordure de gauche
        flag = True
    if all((item, flag)): # Si flag == True et que item == True (une ligne qui remplie les conditions mask)
        # Si nous avons le depart Start
        if Start:
            # End deviens idx. En fin de boucle cela serat la derniere valeur idx valide.
            End = idx
    else:
        # Sinon c'est la premiere ligne valide donc Start
        Start = idx
# On calcule le milieu de la 'bande'
tocut = Start + (End-Start)/2
# On 'coupe' deux parties de l'image suivant l'axe tocut
crop1 = im.crop((0, 0, tocut, y))
crop2 = im.crop((tocut, 0, x, y))
# On cree des images vides aux dimensions
im1 = Image.new("RGB", (tocut, y), "white")
im2 = Image.new("RGB", (x-tocut, y), "white")
# On colle dans les images les parties coupees
im1.paste(crop1, (0, 0, tocut, y))
im2.paste(crop2, (0, 0, x-tocut, y))
# Et on enregistre.
im1.save("test1.jpg", "JPEG")
im2.save("test2.jpg", "JPEG")

J'ai un petit problème. Comme chaque image peut prendre une forme aléatoire, pas nécessairement carré. Il y a beaucoup d'espaces blancs soit en haut, en bas ou aux cotés de chaque image.

Comment je pourrai centrer chaque image au milieu et supprimer tout ceux que j'en n'ai pas besoin (laisser que le nécessaire) ??

[josmiley]

avec une image dont les bordures sont d'une couleurs unie(image retouchée ici) avec une marge de 10 par canal, en se basant la couleur du 1er pixel(0,0).

ce code dessine un cadre rouge selon le résultat qu'il trouve ... chez moi ça fonctionne.

Code :

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

1
2
3
4
5
6
7
8
9
10
from pygame import *
img = image.load('imagetestmask.jpg')
scr = display.set_mode(img.get_size())
scr.blit(img,(0,0))
msk = mask.from_threshold(img,img.get_at((0,0)),(10,10,10,255))
msk.invert()
for r in msk.get_bounding_rects():
    draw.rect(scr,Color('red'),r,2)
display.flip()
while event.wait().type != QUIT: pass

l'image de test:

résultat:

[plxpy]

j'avais préparé une réponse sans voir les deux dernières interventions. Je la poste quand même

Pour déterminer la colonne où l'on effectue le découpage, et si :

• les deux images d'origine n'ont pas pivoté quand l'image globale est créée (images "en crabe"), avec, donc, une séparation bien verticale
• les marges/le fond sont bien différents des images (ici marges claires et images sombres)

on peut travailler sur l'image convertie en mode 'L' (niveaux de gris) et passer en dimension 1 en calculant la ligne moyenne de l'image :

Code :

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

1
2
3
4
5
6
>>> img = Image.open('image.GIF').convert('L')
>>> ncols, nrows = img.size
>>> pixels = list(img.getdata())
>>> rows = [ pixels[r*ncols:(r+1)*ncols] for r in range(nrows) ]
>>> cols = zip(*rows)
>>> avgrow = map(lambda c: float(sum(c))/float(nrows), cols)

visuellement, la ligne moyenne a la tête suivante (valeurs de avgrow en fonction de l'index 0 --> nbcols-1):



Dur de rater les images origine ...

Ensuite, éliminer les bords droit et gauche et ne s'occuper que de la partie centrale pour déterminer une colonne pas trop sotte à utiliser (à coup de filtres simplistes, de max ou alors de pentes).


@ysahel : ce serait bien de ne pas distiller au compte-gouttes tes conditions d'obtention des images. On n'apprend qu'à la fin qu'elles ne sont pas forcément rectangulaires, etc... autant donner ces infos dès le début non ? Grrrh ...

[PauseKawa]

Un exemple sur l'image donnée josmiley ?

[plxpy]

Un exemple sur l'image donnée josmiley ?

Une ligne moyenne sur l'image résultat ?

[PauseKawa]

Oui : Je ne pratique pas pygame mais je suis intéressé de voir du code permettant de trouver la ligne moyenne.

[josmiley]

en filtrant le résultat via la variable aire_mini, j'ai de bons résultats avec cette image:


aire_mini est la surface minimum de chaque image extraite.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
aire_mini = 100
marge = 10
 
from pygame import *
img = image.load('fleurs-minis.jpg')
scr = display.set_mode(img.get_size())
scr.blit(img,(0,0))
msk = mask.from_threshold(img,img.get_at((0,0)),(marge,marge,marge,255))
msk.invert()
for r in msk.get_bounding_rects():
    if r.w*r.h >= aire_mini: draw.rect(scr,Color('red'),r,2)
display.flip()
while event.wait().type != QUIT: pass

je rappelle que les cadres rouges ne servent qu'à visualiser les parties de l'image retenues pas le code.

[plxpy]

Le code pour calculer la ligne moyenne est donné dans le post#15. Ni plus, ni moins.

Les lignes moyennes calculées sur les images en entrée et en sortie du code de Josmiley :



Après, une fois connues les conditions de départ (re-Grrrh), c'est sur qu'il faut aborder le problème différemment !