Diviser une image en deux images.

Version imprimable

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

16/03/2013, 22h53
ysahel

1 pièce(s) jointe(s)

Diviser une image en deux images.

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.
17/03/2013, 10h30
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.

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:

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:

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:

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

Citation:

(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:

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 ;)

@+

Oups !

Code:

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)...

Petit coup de pouce pour effacer l'erreur

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
#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)

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:

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.

Citation:
Envoyé par ysahel
Code:

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.

Un exemple complet pour voir ce que cela donne ?

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
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)

@+

1 pièce(s) jointe(s)

Petite question :

Citation:

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:

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:

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.

@+

1 pièce(s) jointe(s)

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:

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:

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:

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)

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

Il suffit donc de passer par:

Code:

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:

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 :roll:

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

@+

17/03/2013, 18h57
PauseKawa
Citation:

Envoyé par PauseKawa

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

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

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...

Citation:

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

Citation:

Je n'interviens pas sur le fond

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

@+

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

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
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) ??

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:

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:
http://joel-murielle.perso.sfr.fr/imagetestmask.jpg
résultat:
http://joel-murielle.perso.sfr.fr/im...skresultat.jpg

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:

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):

http://plx.free.fr/dvp_images/avgrow.png

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 ...

17/03/2013, 20h05
PauseKawa

Un exemple sur l'image donnée josmiley ?
17/03/2013, 20h14
plxpy

Citation:

Envoyé par PauseKawa

Un exemple sur l'image donnée josmiley ?

Une ligne moyenne sur l'image résultat ?
17/03/2013, 20h24
PauseKawa

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

en filtrant le résultat via la variable aire_mini, j'ai de bons résultats avec cette image:
http://www.observatoiredelafranchise...eurs-minis.jpg

aire_mini est la surface minimum de chaque image extraite.
Code:

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.
http://joel-murielle.perso.sfr.fr/Ca...2020:50:00.png

17/03/2013, 21h01
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 :

http://plx.free.fr/dvp_images/jos_orig_res.png

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

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