Discussion :

[Zelda la Rouge]

Bonjour tout le monde,

Alors, je vais vous épargner les détails de mon programme MAIS : pour atteindre mon but, j'ai besoin d'extraire des suites de "pixels" d'un tableau numpy. Rien de très difficile me direz vous, là où ça se complique, c'est que chacun de ces pixels ne doit avoir au maximum que 2 voisins. Je m'explique : à chaque croisement(chaque fois que le nombre de voisins est supérieur à 2), je voudrais stopper l'extraction et commencer une nouvelle suite de pixel.

Dans mon cas, j'ai décidé de représenté chaque suite de pixel détecté d'une couleur différente. Exemple ci-dessous :


Comme vous pouvez le voir, mes fonctions marchent sur une image de 10x10 pixels. Malheureusement, le résultat n'est pas aussi grandiose sur du 100x100 :

Ici l'image en input :



Alors voilà, malgré mes efforts, je n'ai pas réussi à trouver l'erreur à l'origine de ce résultat certes très joli mais très peu utile.

Code :

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

1
2
3
import PILE import image
import numpy as np
from itertools import product

Code :

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

1
2
3
4
5
def scan (x, y, img, height=100, width=100) : #scan mon image de x, y jusqu'au prochain pixel rencontré
    for i, j in product(range(height), range(width)):
        if img[i][j] == 1 : 
            return i,j
    return height-1, width-1

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
def nb_neighbor(x, y, img, height=100, width=100) : #check toutes les cases autour d'un pixel et vérifie la présence de voisins
    result = [0, x, y] 
 
    for i in range(9) :  
        x_prov = x 
        y_prov = y
 
        if i%3 == 0 :
            if x == 0 : continue
            else : x_prov = x-1
        elif i%3 == 2 :
            if x == height-1 : continue
            else : x_prov = x+1
 
        if int(i/3) == 0 :
            if y == 0 : continue 
            else : y_prov = y-1
        elif int(i/3) == 2 : 
            if y == width-1 : continue
            else : y_prov = y+1
 
        if img[x_prov][y_prov] >= 0.5 :
            result[0] += 1
            if result[0] > 1 : 
                result[1] = x
                result[2] = y
                break
            result[1] = x_prov
            result[2] = y_prov
 
    return result

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
def almost_working(img, height=100, width=100) : 
    scan_x = 0
    scan_y = 0
    color = 50
 
    nimg =  np.zeros((height, width), dtype = np.uint8)
 
    while scan_x != height-1 or scan_y != width-1 : 
 
        scan_x, scan_y = scan(scan_x, scan_y, img, height, width)
 
        find_x = scan_x
        find_y = scan_y
 
        while img[find_x][find_y] >= 0.5 :
            img[find_x][find_y] = 0
            nimg[find_x][find_y] = color
 
            next = nb_neighbor(find_x, find_y, img, height, width)
 
            if next[0] !=  1 : 
                color += 1
 
            find_x = next[1]
            find_y = next[2]
 
    return nimg

Code :

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

1
2
3
4
5
img = np.array(Image.open('data/one_bw_data.jpg').convert('L'))
result = almost_working(img)
 
plt.imshow(result.T, cmap='tab20', origin='lower')
plt.show()

Voilà pour le code, si une âme charitable réussi à trouver la source du problème, je lui en serait infiniment reconnaissante.
Pleins de bisous,
Zelda

PS : une image à mettre en input, si jamais :

[wiztricks]

Voilà pour le code, si une âme charitable réussi à trouver la source du problème, je lui en serait infiniment reconnaissante.

Le code doit traduire un algorithme que vous avez omis de mentionner. Bien sûr, on peut lire le code et imaginer à partir de là quel algorithme vous avez cherché à traduire. Mais, c'est du boulot pour le lecteur alors que c'est à vous de bosser (mieux).

- W

[Zelda la Rouge]

Je ne suis pas bien sûre de ce qu'il vous manquait, mais dans le doute j'ai rajouté les import et une façon d'ouvrir une image en numpy array depuis un .jpeg.
J'espère que cela pourra vous aider. A part ça, je n'ai pas vraiment essayé de transcrire un algorithme, c'est plutôt un genre d'invention de ma part. On pourrait dire que c'est inspiré de Hough Transform, si vous préférez.

Bien à vous,
Zelda

[wiztricks]

J'espère que cela pourra vous aider. A part ça, je n'ai pas vraiment essayé de transcrire un algorithme, c'est plutôt un genre d'invention de ma part.

Qu'il soit de votre cru ou la resucée d'un algo connu, si on ne sait pas comment on va résoudre le problème, pas la peine de coder: le code doit traduire cet algo... que l'on doit retrouver en lisant le code.
Et si vous avez inventé quelque chose d'indescriptible, ben, vous savez où est le problème et par quoi commencer.

- W

[Zelda la Rouge]

Ce n'est pas tant que l'algorithme soit soit indescriptible, plutôt que je ne sais pas ce que vous cherchez qui ne soit pas dans le code...
Vous voulez que je vous donne le pseudo-code ? Ou peut-être que mon code manque de commentaire, ce que je conçois aisément ? Sinon, je vois difficilement comment vous donner l'algorithme d'un code que j'ai écrit sans vous donner, effectivement... l'algorithme du code que j'ai déjà écrit X)

Vous trouverez ci-joint mon pseudo-code, certainement très mal écrit et pas du tout au norme, puisque je n'ai jamais écrit de pseudo-code pour personne d'autre que moi avant. Si ce n'est pas ce que vous voulez, alors je suis à court d'idées et j'ai peur qu'il faille donner des instructions un peu plus clair, malheureusement.

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
int scan x, scan y 
img[height][width]
nimg [height][width]
color = 1
while  scan x, scan y != height, width : #s'assure que toute l'image a été scanné de 0-0 à height, width
    for i, j < height, width, i++, j++  #scan l'image, de la rangée scan x où nous nous étions arrêté jusqu'au prochain pixel trouvé ou la fin de l'image sinon
        si trouve i, j = 1 #1 = pixel valide
            retourne scan x = i, scan y = j
            break   
 
find x, find y = scan x, scan y #on ajoute la variable find x, find y puisqu'il faut garder le compte de la ligne où le scanner s'était arrêté
 
    while img[find x][find y] ==  1 : #parcoure tous les pixels de la même ligne jusqu'à ce qu'il n'y ai plus de pixels disponibles
        img[find x][find y] = 0 #supprime le pixel présent de l'image
        nimg[height][width] = color #ajoute le pixel de la couleur de la suite à notre nouvelle image 
 
        nb_voisin = 0
        nx, ny = find x, find y
        while (#check chaque case autour de find x, find y à l'aide de mod 3, /3)
            si case == 1 :
                nb voisin +1
                nx, ny = coordonnée de la case
 
        if nb voisin != 1 : 
            break #dans le cas où il existe plus d'un voisin, ou pas de voisin du tout = bout de ligne, on sort de la boucle
 
        find x, find y = nx, ny #find x et find y prennent les coordonnées d'une nouvelle case non null et repasse donc dans la boucle

- Zelda

[wiztricks]

Ce n'est pas tant que l'algorithme soit soit indescriptible, plutôt que je ne sais pas ce que vous cherchez qui ne soit pas dans le code...

Relisez ma première réponse.
Ceci dit, peut être que ça va en amuser certain de décoder votre prose: il vous suffit d'attendre qu'ils se manifestent.

- W