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

[Zelda la Rouge]

C'est formidable... ça fait plus de 3 ans depuis notre dernière discussion, et je dois dire que la retraite vous réussi. Vous êtes toujours aussi agréable et pédagogue.
Je ne comprends pas la question, est-ce que vous pourriez essayez de m'expliquer, plutôt que me dire de la relire ?

[The1511point13]

Bonjour tous le monde,

Sans vouloir vexer wiztricks, cette réponse n'a aucun intérêt :

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

La personne vous dit qu'elle n'a pas compris votre demande et vous n'apportez aucun élément supplémentaire.
De plus, il suffit de regarder son profil 5 secondes pour s'apercevoir que c'est un étudiant.
Manifestement, il n'a pas tous les codes et toutes les conventions, mais il est en recherche de réponse.
Je trouve votre comportement abject envers les jeunes, la prochaine fois ne répondez si c'est pour formuler ce genre de réponses.


En ce qui concerne la demande initiale de Zelda la Rouge, je n'ai pas réussi à obtenir le même résultat que celui que vous présentez.
Je suis un peu rouillé en Python, c'est peut-être dû à cela.
En revanche, je ne suis pas sûr que votre fonction donnant les voisins d'un pixel soit correcte.
Généralement, dans ce genre de cas, on utilise une convention utilisée pour générer des "chain code".
Je ne sais pas si c'est ce que vous cherchiez à faire ici, je vous mets donc un article parlant de ce sujet :
https://www.geeksforgeeks.org/chain-code-for-2d-line/

Pour mes tests, j'ai également refait la fonction concernée, je vous la dépose donc aussi :

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
def nb_neighbor(x, y, img, height=100, width=100) :
 
    #Meme initialisation que votre fonction
    result = [0, x, y] 
 
    #Il y a 8 pixels voisins (dans un cas 8-connexe) + votre pixel central, donc "9 directions" possibles
    for i in range(0, 9, 1):
 
        #Ma fonction next_point calcul les coordonnées des pixels voisins en fonction de la direction donnée
        x_prov, y_prov = next_point(x, y, i)
 
        #Toujours vérifier que le pixel est contenue dans l'image
        if 0 <= x_prov < height and 0 <= y_prov < width :
 
            #Ici j'ai repris votre code
            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
 
    #Meme retour que votre fonction
    return result

Voici, par ailleurs, la fonction donnant les coordonnées du point suivant :

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
def next_point(x, y, d) :
        if d == 0: 
            return x + 1, y
        elif d == 1: 
            return x + 1, y + 1
        elif d == 2: 
            return x, y + 1
        elif d == 3: 
            return x - 1, y + 1
        elif d == 4: 
            return x - 1, y
        elif d == 5: 
            return x - 1, y - 1
        elif d == 6: 
            return x, y - 1
        elif d == 7: 
            return x + 1, y - 1
        #Par défault, on retourne le pixel central
        else:
            return x, y

En espérant que, contrairement aux réponses précédentes, la mienne ait pu vous éclairer sur certains points.

[The1511point13]

C'est formidable... ça fait plus de 3 ans depuis notre dernière discussion, et je dois dire que la retraite vous réussi. Vous êtes toujours aussi agréable et pédagogue.
Je ne comprends pas la question, est-ce que vous pourriez essayez de m'expliquer, plutôt que me dire de la relire ?

Je n'avais vu cette réponse, mais il semble que mon avis soit partagé.

[wiztricks]

C'est formidable... ça fait plus de 3 ans depuis notre dernière discussion, et je dois dire que la retraite vous réussi. Vous êtes toujours aussi agréable et pédagogue.
Je ne comprends pas la question, est-ce que vous pourriez essayez de m'expliquer, plutôt que me dire de la relire ?

Décrire en bon français ce que vous cherchez à faire et vérifier que le code Python traduit cette intention là. Si c'est trop compliqué, peut être que d'autres auront des idées plus adaptées/appropriées a votre niveau/besoin/attente.

Manifestement, il n'a pas tous les codes et toutes les conventions, mais il est en recherche de réponse.
Je trouve votre comportement abject envers les jeunes, la prochaine fois ne répondez si c'est pour formuler ce genre de réponses.

C'est pour cela que je propose une démarche. Maintenant, il est clair que l'attente semble être côté résultats plutôt que dans la démarche pour l'obtenir... Ce qui pour moi n'a aucun intérêt, mais ça peut intéresser d'autres (comme je l'ai mentionné).

En revanche, je ne suis pas sûr que votre fonction donnant les voisins d'un pixel soit correcte.
Généralement, dans ce genre de cas, on utilise une convention utilisée pour générer des "chain code".
Je ne sais pas si c'est ce que vous cherchiez à faire ici

Vous constatez aussi que le code posté ne reproduit pas grand chose et qu'on ne comprend pas trop le sens de ce qui a été écrit...
Vous vous raccrochez aux branches de ce que vous connaissez: vous proposez une solution en admettant ne pas savoir le problème à résoudre.

Je préfère attendre que le PO dise ce qu'il veut et mentionne ou détaille l'algo. utilisé... voire puisqu'on est dans un forum Python décrive son soucis à traduire son algo en python.

- W

[Zelda la Rouge]

Alors, tout d'abord merci The1511point13. Je ne suis pas forcément beaucoup plus avancée mais votre code me permettra au moins de vérifier ma fonction de recherche. J'ai regardé pour le chain code, c'est effectivement l'idée alors je vais me pencher un peu plus là dessus ^^ Pour ce qui est du résultat que vous n'avez pas réussi à obtenir, après vérification du code posté en ligne, c'est la lecture de l'image qui est mauvaise. J'utilise normalement des tableaux numpy binaire, mais puisque les fichiers en .npy ne passe pas ici j'ai dû les convertir en jpeg.

Maintenant, pour répondre à wiztricks :

C'est pour cela que je propose une démarche. Maintenant, il est clair que l'attente semble être côté résultats plutôt que dans la démarche pour l'obtenir... Ce qui pour moi n'a aucun intérêt, mais ça peut intéresser d'autres (comme je l'ai mentionné).

Je me fiche complètement d'avoir un résultat ici, je finirais de toute façon par trouver la source de mon problème. J'ai posté sur ce site avec l'idée, certes fantasque, que quelqu'un détecterais peut-être un problème de mon code qui puisse aider à la résolution de mon bug (sans grand espoir, mais je me consolais en me disant que j'aurais au moins une discussion constructive avec des gens sympathiques - erreur de débutant, je vous le concède).

Vous constatez aussi que le code posté ne reproduit pas grand chose et qu'on ne comprend pas trop le sens de ce qui a été écrit...
Vous vous raccrochez aux branches de ce que vous connaissez: vous proposez une solution en admettant ne pas savoir le problème à résoudre.

Et je veux bien entendre que mon code est pourri et illisible, malheureusement, quand j'essaie de répondre à vos questions, vous me renvoyez dans les ronces en me disant que ça ne répond pas à ce que vous avez demandé, plutôt que m'expliquer plus en détails ce que vous voulez savoir.

Mais puisque je suis décidément quelqu'un de persistant et de bonne volonté, malgré la mauvaise foi ambiante :

J'essaie de colorier chaque chaine de pixels d'une image d'une couleur différente. Chaque chaine de pixel s'arrête si : 1. Elle est complète 2. Elle croise une autre chaine de pixel
Dans ce but, mon algorithme effectue les actions suivantes :
1. Récupérer l'image
2. Scanner l'image de la valeur 0, 0 jusqu'au premier pixel X
3. Noter X en couleur C sur notre image de résultat et l'effacer de l'image prise en entrée
4. Vérifier le nombre de voisin de ce pixel : si 1 seul voisin, passer à ce voisin et retourner au 3. sinon, augmenter C de 1 et retourner au 2., en ne partant plus de 0,0 mais de X

On trouve donc dans l'ordre 2. qui équivaut à ma fonction scan, et 4. à ma fonction nb_neighboor.

voire puisqu'on est dans un forum Python décrive son soucis à traduire son algo en python

Je n'ai pas de soucis particulier à traduire l'algorithme, c'est bien le problème.
Malgré ce code qui me semble juste (et qui visiblement ne l'est pas), par endroit l'algorithme se met à divaguer totalement. Et j'ai beau chercher, je ne comprend pas pourquoi.

Est-ce que vous me demandiez ? Je n'avais juste pas compris que vous vouliez que j'exprime l'algorithme en mot plutôt qu'en code.

[josmiley]

C'est pas plus clair , je n'arrive même pas a extraire une logique en observant les images du 1er post.

[wiztricks]

Si vous commencez par écrire:

Alors, tout d'abord merci The1511point13. Je ne suis pas forcément beaucoup plus avancée mais votre code me permettra au moins de vérifier ma fonction de recherche. J'ai regardé pour le chain code, c'est effectivement l'idée alors je vais me pencher un peu plus là dessus

Vous constatez (sans le dire) que les informations données sont insuffisantes.

Est-ce que vous me demandiez ? Je n'avais juste pas compris que vous vouliez que j'exprime l'algorithme en mot plutôt qu'en code.

Raconter ce que vous cherchez à faire de façon intelligible? C'est (par exemple) pouvoir partir d'un tableau 10x10 de booléens (i.e. 2 couleurs pour simplifier) savoir ce qu'on en sort et la méthode pour y arriver. Pensez vous que ce que vous avez raconté jusque là permet de faire ça?
note: c'est dans le code mais ce code ne marche pas (sinon vous ne demanderiez pas de l'aide).

Je pars du principe que quand on ne sait pas ce qu'on veut, inutile de coder ou de relire/partir d'un code qui ne marche pas pour découvrir ce que vous aviez en tête... après vous faites un peu ce que vous voulez: d'autres The1511point13 tenteront peut être leur chance.

- W

[Zelda la Rouge]

Je pars d'une image en noir et blanc de 100x100, que j'exporte sous la forme d'un tableau numpy binaire, comme dit plus haut. Je veux comme résultat exactement la même chose, mais en couleur, séparé par suite de pixel. Je ne vois pas comment l'expliquer plus clairement, moi ça me semble simple mais je travaille sur cette fonction depuis 3 jours et je bosse sur le sujet depuis 1 mois et demi alors je suis peut-être biaisée, j'en sais rien.

Peu importe, j'ai trouvé une autre solution en travaillant sur l'angle de mes droites, merci The1511point13 pour l'idée de la chaine. J'ai repris votre fonction de détection des voisins, pour informations, alors je ne la reposte pas.

Le problème tenait au fait que lorsque le scanner rencontrais un pixel, il ne se souciait pas de savoir si ce pixel représentait un début de ligne ou non. En plus de ça, en cas de croisement en forme de t, la fonction de détection du pixel suivant prenait un virage à 90, ce qui était assez contreproductif, d'où l'usage d'un algorithme qui détermine le sens de ma suite de pixel au préalable. J'imagine bien qu'on va encore me dire que c'est incompréhensible, mais dans le doute...

Voilà le code pour ceux que ça intéresse :

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
def scan (x, y, img, height=100, width=100) : 
    if x == 0 and y == 0 : 
        y = -1
 
    if y != width - 1 : 
        for j in range(y + 1, width) : 
            if img[x][j] == 1 : 
                return x,j
 
    if x != height - 1 :
        for i, j in product(range(x + 1, 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
def get_number_of_neighbors(board, x, y, width=100, height=100) :
    nb_neighbors = 0
    for i in range(0, 8):
        tx, ty = get_next_point(x, y, i)
        if board[tx][ty] == 1 :
            nb_neighbors += 1
 
    return int(nb_neighbors)

Code :

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

1
2
3
4
5
6
7
8
def get_available_direction(board, x, y,  width=100, height=100) :
    neighbors = np.array([])
    for i in range(0, 8):
        tx, ty = get_next_point(x, y, i)
        if board[tx][ty] == 1 :
            neighbors = np.append(neighbors, i)
 
    return neighbors.astype(int)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def get_waiting_value(dirs):
    j = 0
    vals = [-1, -1]
    coeff = 0
 
    waiting_value = 0
    for i in range(8):
        if dirs[i] != 0 :
            waiting_value += i * dirs[i]
            vals[j] = i
            j += 1
            coeff += dirs[i]
 
    return waiting_value / coeff, vals

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
def get_waiting_dirs(dirs) :
    if np.count_nonzero(dirs) == 2 :
 
        waiting_value, vals = get_waiting_value(dirs)
 
        dd1 = max(waiting_value, vals[0]) - min(waiting_value, vals[0])
        dd2 = max(waiting_value, vals[1]) - min(waiting_value, vals[1])
 
        if dd1 <= dd2:
            return [int(vals[0]), int(vals[1])]
        else : 
            return [int(vals[1]), int(vals[0])]
 
    else : 
 
        d = -1
        for i in range(8):
            if dirs[i] != 0 :
                d = i
                break
 
        return [int((d-1) % 8), int(d), int((d + 1) % 8)]

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
def identify_line_loop(board, x, y, pd, dirs, ads, swd, wds, width=100, height=100) :
 
    #Initialisation
    x_list = []
    y_list = []
 
    #La boucle s'arrête quand elle rencontre la fin d'une droite
    while np.size(ads) > 0 :
 
        #On ajoute la position aux listes
        x_list = np.append(x_list, x)
        y_list = np.append(y_list, y)
 
        #On récupère les position qui ont un intéret
        wads = np.empty(0, dtype=int)
        for d in wds :
            if np.isin(d, ads) :
                wads = np.append(wads, d)
        sz_wads = np.size(wads)
 
        #S'il n'y a pas de position d'interet, on s'arrête là
        if sz_wads == 0 :
 
            return dirs, x_list, y_list
 
        #S'il y a une position d'interet, on l'ajoute et on prépare la suivante
        elif sz_wads == 1 :
            pd = wads[0]
            x, y = get_next_point(x, y, pd)
            dirs[int(pd)] += 1
            ads = get_available_direction(board, x, y, width=width, height=height)
            wds = get_waiting_dirs(dirs)
 
        #S'il y a plus d'une position d'interet on vérifie, récursivement, laquelle est la plus adaptée
        else :
            break
 
    #On ajoute notre droite à la fin
    x_list = np.append(x_list, x)
    y_list = np.append(y_list, y)
 
    return dirs, x_list, y_list

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
def lines_separator(board, width=100, height=100) :
 
    res_board = np.zeros((width, height), dtype=int)
    color = 1
    scan_x = 0
    scan_y = 0
 
    while scan_x != height-1 or scan_y != width-1 :
        scan_x, scan_y = scan(scan_x, scan_y, board, height, width)
 
        x = scan_x
        y = scan_y
 
        if res_board[x][y] == 0 :
            x_list, y_list = identify_line(board, x, y, width=width, height=height)
 
            xlen = np.size(x_list)
            for i in range(0, xlen):
                tx, ty = x_list[i], y_list[i]
                board[int(tx)][int(ty)] = 0
                res_board[int(tx)][int(ty)] = color
 
            color += 1
 
    return res_board.astype(int)

Et l'on obtiens à partir de cette splendide image :



Ceci :



Voilà, j'espère que ça pourra servir à quelqu'un un jour.
Merci à ceux qui ont aidé, bon courage aux autres.

Une bonne journée à tous,
Pleins de bisous,

Zelda

[wiztricks]

je bosse sur le sujet depuis 1 mois et demi alors je suis peut-être biaisée, j'en sais rien.

Je ne peux que constater que malgré ce mois passé, vous n'arrivez pas à raconter simplement ce que vous cherchez à faire.
note: et ce n'est pas parce que votre code est tombé en marche qu'il traduit correctement un algorithme qui n'a pas été énoncé.

De plus, sauf à vivre dans sa bulle, on peut penser que ce que vous cherchez à faire n'a de bien original: d'autres ont déjà bossé sur des problèmes similaires (ça aide pour les algos). Par exemple, lorsque Google balader ses engins (mais pas que) pour photographier rues et chemins, on collecte une suite de positions GPS (les rues/routes représentés par des segments) dont on cherchera à détecter les intersections (définis comme plus de 2 segments connectés).

Il y a certainement d'autres algos pour s'inspirer...

- W

[Zelda la Rouge]

Sincèrement, si vous voulez m'expliquer ce que vous entendez par algorithme, je serais ravie de discuter avec vous en dm ou même ici, peu importe. Mais dans le cas contraire, je vais juste fermer la discussion ^^

D'autre part, il aurait peut-être été plus pertinent de suggérer ces algorithmes quand j'en avait encore besoin... Mais merci quand même, j'y jetterais un coup d'œil.

Je vous souhaite une bonne journée,
Zelda