Discussion :

[Ziranium]

Bonjour à tous,

Je suis sur un petit projet assez complexe par rapport à mes maigres connaissances en géométrie. Je dessine une Map interactive (PyGTK) d'un réseau informatique WAN+LAN.
Pour faire ceci, j'utilise le format xdot (graphviz).
Je dessine donc des "Node" pour représenter les différents réseaux et routeurs, liés les uns aux autres par des "Edge", lien LAN et WAN.
J'ai ajouté le fait de pouvoir faire du Drag'n'Drop sur mes objets graphiques afin de pouvoir modifier la disposition puis de l'enregistrer. Tout ceci fonctionne correctement.
Les liens entre les "Node" sont retracés. Ces liens sont des courbes de beziers.

Mon problème est qu'au bout d'un moment, ma formule de recalcule des coordonnées pour chaque points des courbes devient plutôt problématique. Pour faire simple, au début j'ai des jolies courbes, ensuite en déplacant plusieurs fois, je finis par avoir des "bosses" dans mes courbes (pas cool ca !).

Je me demande du coup si je recalcule correctement les coordonnées. Pourriez vous me dire ce que vous pensez de ma façon de faire ? Où puis-je l'améliorer afin de retracer mes points de façon intelligente, et comment calculer le nombre de points nécessaires ?

Voici mon code sur cette fonction :

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
 
# dx => décalage de la tête de mon lien en X
# dy => décalage de la tête de mon lien en Y
# xs, ys => x, y du premier point (celui qui ne bougera pas)
# xe, ye => x, y du dernier point (celui qui est décalé de dx et dy)
 
    def move_head(self, dx, dy):
        newPoints = []
        xs, ys = self.points[0]
        xe, ye = self.points[-1]
        if xe == xs:
            px = xs + dx
        else:
            px = xe -xs
        kx = float(dx) / px
        if ye == ys:
            py = ys + dy
        else:
            py = ye - ys
        ky = float(dy) / py
        for i in range(len(self.points)):
            x = self.points[i][0]
            y = self.points[i][1]
            if x == xs:
                decx = (x + dx) * ((((i+1)*100)/len(self.points))/100)
            else:
                decx = x - xs
            if y == ys:
                decy = (y + dy) * ((((i+1)*100)/len(self.points))/100)
            else:
                decy = y - ys
            nx = int(kx * decx) + x
            ny = int(ky * decy) + y
            newPoints.append((nx, ny))
        self.points = newPoints

[ToTo13]

Bonjour,
lorsque l'on souhaite tracer une Bézier, on utilise d'algorithme de De Casteljau et non pas les polynômes de Bézier car on ne peut calculer au dela de 35 le triangle de Pascal.

[foudezic63]

Entre autre je dirais aussi qu'une bézier sera de toute manière totalement affectée par le mouvement d'un seul des points. Si tu veux un truc plus stable essaye d'utiliser des Bsplines, les modifs deviendront alors locales aux points