Discussion :

[TiT_Flo]

Bonjour,
J'ai 2 programmes que j'aurais aimé fusionner dans le cadre d'un projet informatique. Cependant, un des soucis est que l'un des programmes utilise matplotlib et l'autre utilise tkinter.
Je me demandais alors comment transvaser le programme (en matplotlib) en tkinter (ce programme est un peu compliqué. C'est un programme qui modélise des courbes de Béziers)

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
import math
import matplotlib
import matplotlib.pyplot as plt
from matplotlib.pyplot import *
 
 
 
def combinaison_lineaire(A,B,u,v):
    return [A[0]*u+B[0]*v,A[1]*u+B[1]*v]
 
def interpolation_lineaire(A,B,t):
    return combinaison_lineaire(A,B,t,1-t)
 
def vecteur_unitaire(P1,P2):
    Ux = P2[0]-P1[0]
    Uy = P2[1]-P1[1]
    norme = math.sqrt(Ux*Ux+Uy*Uy)
    if norme!=0:
        return [Ux/norme,Uy/norme]
    else:
        return False
 
def test_alignement_4pts(points,epsilon):
    U1 = vecteur_unitaire(points[0],points[1])
    U2 = vecteur_unitaire(points[1],points[2])
    U3 = vecteur_unitaire(points[2],points[3])
    if U2:
        x = 2.0-(U1[0]*U2[0]+U1[1]*U2[1]+U2[0]*U3[0]+U2[1]*U3[1])
    else:
        x = 1.0-(U1[0]*U3[0]+U1[1]*U3[1])
    if abs(x) < epsilon:
        return True
    else:
        return False
 
def division_courbe_bezier_3(points_control):
    P01 = interpolation_lineaire(points_control[0],points_control[1],0.5)
    P12 = interpolation_lineaire(points_control[1],points_control[2],0.5)
    P23 = interpolation_lineaire(points_control[2],points_control[3],0.5)
    P01_12 = interpolation_lineaire(P01,P12,0.5)
    P12_23 = interpolation_lineaire(P12,P23,0.5)
    Q = interpolation_lineaire(P01_12,P12_23,0.5)
    return ([points_control[0],P01,P01_12,Q],[Q,P12_23,P23,points_control[3]])
 
def courbe_bezier_3_recursif(points_control,epsilon,pile_points_courbe):
    if test_alignement_4pts(points_control,epsilon):
        pile_points_courbe.append(points_control[0])
    else:
        (points_1,points_2) = division_courbe_bezier_3(points_control)
        courbe_bezier_3_recursif(points_1,epsilon,pile_points_courbe)
        courbe_bezier_3_recursif(points_2,epsilon,pile_points_courbe)
 
def courbe_bezier_3_recursif_init(points_control,epsilon):
    pile_points_courbe = []
    courbe_bezier_3_recursif(points_control,epsilon,pile_points_courbe)
    pile_points_courbe.append(points_control[-1])
    return pile_points_courbe
 
def plot_points(points_courbe,style='-'):
    x = []
    y = []
    for p in points_courbe:
        x.append(p[0])
        y.append(p[1])
    plot(x,y,style)
 
class Courbe:
    def __init__(self,P0,P1,P2,P3,epsilon):
        self.points_courbe = []
        self.epsilon = epsilon
        self.bezier_3_recursif_init([P0,P1,P2,P3])
        self.points_control = [P0,P1,P2,P3]
    def bezier_3_recursif_init(self,points_control):
        courbe_bezier_3_recursif(points_control,self.epsilon,self.points_courbe)
        self.P2 = points_control[2]
        self.P3 = points_control[3]
    def ajouter(self,P2,P3):
        P0 = self.P3
        P1 = [P0[0]+P0[0]-self.P2[0],P0[1]+P0[1]-self.P2[1]]
        self.bezier_3_recursif_init([P0,P1,P2,P3])
        self.points_control.append(P1)
        self.points_control.append(P2)
        self.points_control.append(P3)
        self.dernier_point = P3
    def liste_points(self):
        self.points_courbe.append(self.dernier_point)
        return self.points_courbe
    def liste_points_control(self):
        self.points_control.append(self.dernier_point)
        return self.points_control
 
courbe = Courbe([0,0],[0,1],[1,1],[1,0],5e-3)
courbe.ajouter([2,0],[3,0])
courbe.ajouter([3,1],[2,1.5])
courbe.ajouter([3,3],[4,2])
points = courbe.liste_points()
points_control = courbe.liste_points_control()
matplotlib.pyplot.figure()
plot_points(points,style='.')
plot_points(points,style='r-')
plot_points(points_control,'o')
axis([0,5,-4,4])
grid()
plt.show()

Merci de votre réponse!

[wiztricks]

Salut,

Pas facile de "fusionner" 2 programmes (sauf s'ils s'exécutent séquentiellement l'un après l'autre) sans avoir prévu le coup avant de les écrire.

Dans ce cas, on aura séparé la partie utilisable en définissant les fonctions à appeler au cas où on voudrait "intégrer" le code dans un autre (plutôt que l'exécuter dans son coin).

Ici, çà se simplifie un peu puisque interfacer du tkinter avec matplotlib est documenté (pas besoin d'imaginer l'interface, on peut partir de celle qui existe).

Reste à comprendre comment çà marche et modifier les programmes pour que...

- W