Discussion :

[icornato]

Bonjour à tous

J'ai développé un programme d'environ 10 000 lignes en VB pour effectuer du calcul d'éléments poutre (calcul matriciel pour étude de déformations et contraintes dans une structure).
J'aimerais désormais développer un logiciel encore plus complet, avec en plus par rapport à mon programme VB, une interface graphique complete. C'est justement le point où j'ai de grosses lacunes, je dirai meme que je n'y connais rien. Je sais juste développer des algorithmes.

L'interface graphique consiste, pour faire simple en la chose suivante :
1. L'utilisateur définit des noeuds (coordonnées spatiales X,Y,Z)
2. Il définit des barres, qui sont des éléments reliant 2 noeuds. Ces barres peuvent etre rectangulaires, circulaires, en H, en I, en L etc... Leurs caractéristiques (dimensions, inerties, etc...) dépendent du choix de l'utilisateur qui sélectionne les barres dans une base de données.
3. Il définit des conditions limite (blocage complet ou partiel de noeuds)
4. Il définit des chargements (efforts et moments sur des noeuds)
Puis lancement du calcul.

J'aimerai que l'interface graphique affiche toutes les barres, que l'utilisateur puisse faire des zoom, faire pivoter le repère etc...
Voilà à quoi ça peut ressembler : http://www.icab.fr/ic_cm.htm

Toute la partie calculatoire (solveur), je sais faire, mais l'aspect graphique... On m'a orienté vers Python.
Avant de me lancer dans un projet d'une telle ampleur, est ce que cette orientation est la bonne ?
Quelles bibliotheques dois je utiliser pour ce projet ?

Merci d'avance aux éventuelles personnes qui me répondraient

Bonne soirée

IC

[alexdevl]

Oui effectivement Python semble adapté pour ton application

1] Il y a plusieurs lib graphiques 3d
voir içi
http://python.developpez.com/outils/...es/?page=IMG3D

dessiner un cylindre et une flèche dans l'espace avec VPYTHON se représente comme ceci :

Code :

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

1
2
3
 
rod = cylinder(pos=(0,2,1), axis=(50,0,0), radius=1)
pointer = arrow(pos=(0,2,1), axis=(5,0,0), shaftwidth=1)

cela donne l'image d'une barre que l'on peux voir et faire tourner avec la souris
La doc :
http://guigui.developpez.com/Tutorie...l/cylinder.php
voir le tuto vpython içi :
http://vpython.org/VPython_Intro.pdf

2] Il pourrais aussi être possible de passer par une lib 2D type wx
Ceci obligeant à programmer une représentation isométrique des composants mais permettant d'avoir plus de liberté au niveau soft.

3] Au passage, le calcul matriciel existe aussi sous forme de lib
http://python.developpez.com/outils/...page=IMG#NumPy

Par contre il faudra, avant, passer par la maitrise du langage par des tutoriaux comme celui ci
http://python.developpez.com/cours/

[DelphiManiac]

Il y a assez longtemps (+ de 20 ans), j'avais développé un projet ressemblant à celui que tu décris : calcul de dalle de béton en précontraint. La parti calcul avais été faite en C (pas par moi, suis pas matheux) et pour l'interface nous nous étions appuyé sur AutoCad.

Je ne sais pas si ton projet est un projet commercial, mais si c'est le cas, il faudrait peut être regarder quel est le logiciel de dessin 3D majoritairement utilisé par le parc que vous visez.

Une autre piste serait de regarder autour des logiciel libre de dessin 3D et de voir s'il n'y a pas moyen d'utiliser ce logiciel pour faire saisir les éléments et au travers d'un export, récupérer les élements pour effectuer le calcul.

Développez une interface 3D n'est tout de même pas une mince affaire.

Après j'aurais tendance à dire que la plupart des langages peuvent répondre à ta demande, python étant l'un d'eux. Mais si tu maitrises déjà VB pourquoi ne pas rester sous VB ? Je ne suis pas certain qu'il y ai un interet d'aprendre et de maitriser python dans ce cas.

[icornato]

Merci pour vos réponses.
J'ai regardé VPython, ça m'a l'air intéressant. Mais j'ai l'impression que les possibilités sont restreintes (c'est une 1ère impression après lecture de la documentation, je me trompe peut etre completement).
Si je pense à transférer tout le code de VB à Python, c'est sur conseil de certaines personnes après discussion autour de l'interface graphique 3D.
Mais en fait peut etre est-elle programmable également en VB... Je ne sais pas vraiment, je suis un peu perdu.
En fait ma 1ère programmation en VB est restreinte : j'ai développé un logiciel de calculs à partir de structures géométriques prédéfinies. Ainsi, l'utilisateur ne rentre qu'un nombre très limité d'informations (une bonne dizaine), et pas besoin de visualisation 3D.
Maintenant, problématique toute autre : l'utilisateur définit une géométrie de son choix. Il faut donc que je solutionne plusieurs points :
1) comment saisir les informations très nombreuses fixées par l'utilisateur (à commencer par la liste de noeuds avec leurs coordonnées X,Y,Z. Il peut y avoir à l'extreme plusieurs centaines de noeuds). Je ne sais pas comment faire. Faire rentrer toutes ses infos dans une feuille Excel ? Je ne trouve pas ça élégant, j'aimerai une fenetre de saisie incorporée au logiciel.
2) la fameuse visualisation 3D de la structure définie par l'utilisateur. VPython pourquoi pas, en plus ça a l'air relativement simple... Avec VB.net, c'est directX ?

Ma hantise, c'est de faire le mauvais choix initial de programmation. Une fois sur les rails, je trouverai toujours moyen de me dépatouiller, mais je ne veux pas faire d'erreur stratégique.

Merci pour vos réponses en tout cas (si vous avez d'autres conseils je suis preneur)

IC

[DelphiManiac]

Malheureusement, le mauvais choix de l'un peut être le bon de l'autre, difficile de répondre pour toi

Pou VB oui c'est DirectX, ce n'est pas la seule solution mais surement la plus facilement accessible à partir de VB.

Par contre l'avantage de python, c'est la portabilité linux, à voir si cela t'est utile.

[alexdevl]

Bonjour,
Voici un exemple, pour voir la philosophie de python , de ce que j'utiliserais si j'avais à faire une soft de ce type :

-Données stockées à partir de XML, on profite ainsi des qualités de ce language (répétabilité...)
- Affichage 3D par VPython
- Gui par wxPython

Ceci nécessite donc
python 2.5
wxpython pour python 2.5
vpython pour python 2.5

C'est forcément discutable, mais c'est le but de ce forum après tout.

J'ai, bien sûr, utilisé des morceaux de programmes que j'avais déja.

Alex

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
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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
 
#!/usr/bin/env python
# -*- coding: iso-8859-1 -*-
 
try:
    import wx
    import wx.grid
except ImportError:
    raise ImportError, "Ce programme nécessite wxpython unicode pour python 2.5"
 
try:
    from visual import *
except ImportError:
    raise ImportError, "Ce programme nécessite vpython pour python 2.5"
 
import xml.etree.ElementTree as ET
 
 
def importObjets(xml):
    """Import des objets à partir de données formatées"""
    xmlOBJET=ET.XML(xml).findall('OBJETS')[0]
    xmlbarres=xmlOBJET.findall('BARRE')
    xmlNOEUDs=xmlOBJET.findall('NOEUD')
    xmlobjets=xmlbarres+xmlNOEUDs
    print "xmlobjets",xmlobjets
    objets = []
    for xmlobjet in xmlobjets:
        print "objet",xmlobjet
        d = {}
        d["TYPE"]=xmlobjet.tag
        for xmlelement in xmlobjet:
            if xmlelement.tag in ["NOM","POS"]:
                d[xmlelement.tag]=xmlelement.text 
                if xmlelement.tag=="POS":
                    d[xmlelement.tag] =[int(c) for c in xmlelement.text.split(",")]
        print 'Ajout de',d,"\n"
        objets.append(d)
    return objets
 
 
def visu(objets):
    """Visu avec Vpython"""
    scene = display()
    arrow(pos=(0,0,0), axis=(50,0,0), shaftwidth=3,color=color.blue)
    arrow(pos=(0,0,0), axis=(0,50,0), shaftwidth=3,color=color.green)
    arrow(pos=(0,0,0), axis=(0,0,50), shaftwidth=3,color=color.yellow)
    for i,objet in enumerate(objets):
        if objet["TYPE"]=="BARRE" :
            posDep=(objet["POS"][0],objet["POS"][1],objet["POS"][2])
            axe=(
            objet["POS"][3]-objet["POS"][0],
            objet["POS"][4]-objet["POS"][1],
            objet["POS"][5]-objet["POS"][2]
            )
            objets[i]["cylinder"]=cylinder(pos=posDep, axis=axe, radius=1,color=color.red)
        if objet["TYPE"]=="NOEUD" :
            posDep=(objet["POS"][0],objet["POS"][1],objet["POS"][2])
            objets[i]["SPHERE"]=box(pos=posDep, length=10, height=10, width=10)
    return objets,scene
 
 
class fr_tableau(wx.Frame):
    """Classe affichage"""
    def __init__(self, *args, **kwds):
        kwds["style"] = wx.DEFAULT_FRAME_STYLE
        wx.Frame.__init__(self, *args, **kwds)
        self.panel_2 = wx.Panel(self, -1)
        self.bt_visu3D = wx.Button(self.panel_2, -1, "Visu3D")
        self.bt_zoomMoins = wx.Button(self.panel_2, -1, "Zoom -")
        self.bt_zoomPlus = wx.Button(self.panel_2, -1, "Zoom +")
        self.bt_quit = wx.Button(self.panel_2, -1, "Quit")
        self.grid_1 = wx.grid.Grid(self.panel_2, -1, size=(400,400))
 
        self.__do_init()
        self.__set_properties()
        self.__do_layout()
        self.__do_event()
 
    def __do_event(self):
        self.Bind(wx.EVT_BUTTON, self.on_visu3D, self.bt_visu3D)
        self.Bind(wx.EVT_BUTTON, self.on_zoomMoins, self.bt_zoomMoins)
        self.Bind(wx.EVT_BUTTON, self.on_zoomPlus, self.bt_zoomPlus)
        self.Bind(wx.EVT_BUTTON, self.on_quit, self.bt_quit)
 
 
 
    def __set_properties(self):
        self.SetTitle("Saisie")
        self.grid_1.CreateGrid(self.nlignes, self.ncols)
        self.grid_1.EnableDragRowSize(0)       
        #--- Création de la ligne entête
        for col in range(self.ncols):
            self.grid_1.SetColLabelValue(col,self.enteteCol[col])
        #--- Remplissage des cellules avec les données 
        for ligne in range(self.nlignes):
            for col in range(self.ncols):
                print "ligne",ligne,"col",col
                self.grid_1.SetCellValue(ligne,col,self.valeursGrid[ligne][col] )  
 
    def __do_layout(self):
        sizer_3 = wx.BoxSizer(wx.VERTICAL)
        grid_sizer_1 = wx.FlexGridSizer(2, 1, 0, 0)
        grid_sizer_2 = wx.FlexGridSizer(1, 4, 0, 0)
        grid_sizer_2.Add(self.bt_zoomMoins, 0, 0, 0)
        grid_sizer_2.Add(self.bt_zoomPlus, 0, 0, 0)
        grid_sizer_2.Add(self.bt_visu3D, 0, 0, 0)
        grid_sizer_2.Add(self.bt_quit, 0, 0, 0)
        grid_sizer_1.Add(grid_sizer_2, 1, wx.EXPAND, 0)
        grid_sizer_1.Add(self.grid_1, 1, wx.EXPAND, 0)
        self.panel_2.SetSizer(grid_sizer_1)
        sizer_3.Add(self.panel_2, 1, wx.EXPAND, 0)
        self.SetSizer(sizer_3)
        sizer_3.Fit(self)
        self.Layout()
 
    def on_zoomMoins(self, event): 
        self.zoom[0]+=10
        self.zoom[1]+=10
        self.zoom[2]+=10
        self.scene.center=(tuple(self.zoom))
        event.Skip()
 
    def on_zoomPlus(self, event): 
        self.zoom[0]-=10
        self.zoom[1]-=10
        self.zoom[2]-=10
        self.scene.center=(tuple(self.zoom))
        event.Skip()
 
    def on_visu3D(self,event): 
        print "visu3D"
        self.objets,self.scene=visu(self.objets)  #  'cylinder': <visual.primitives.cylinder object at 0x01D792D0>,
 
    def on_quit(self, event): 
        self.Destroy()
 
    def __do_init(self):
 
        xml = '''<?xml version="1.0" encoding="UTF-8"?>
        <pycadConfig>
        <OBJETS> 
            <BARRE>
                <NOM>BARRE1</NOM>
                <POS>0,0,0,100,0,0</POS>
            </BARRE>
            <BARRE>
                <NOM>BARRE2</NOM>
                <POS>100,0,0,100,0,100</POS>
            </BARRE>
            <BARRE>
                <NOM>BARRE3</NOM>
                <POS>100,0,100,0,0,100</POS>
            </BARRE>
            <BARRE>
                <NOM>BARRE4</NOM>
                <POS>0,0,100,0,0,0</POS>
            </BARRE>
            <BARRE>
                <NOM>BARRE5</NOM>
                <POS>0,100,0,100,100,0</POS>
            </BARRE>
            <BARRE>
                <NOM>BARRE6</NOM>
                <POS>100,100,0,100,100,100</POS>
            </BARRE>
            <BARRE>
                <NOM>BARRE7</NOM>
                <POS>100,100,100,0,100,100</POS>
            </BARRE>
            <BARRE>
                <NOM>BARRE8</NOM>
                <POS>0,100,100,0,100,0</POS>
            </BARRE>
            <BARRE>
                <NOM>BARRE9</NOM>
                <POS>0,0,0,100,0,0</POS>
            </BARRE>
            <BARRE>
                <NOM>BARRE10</NOM>
                <POS>100,0,0,100,100,0</POS>
            </BARRE>
            <BARRE>
                <NOM>BARRE11</NOM>
                <POS>100,0,100,100,100,100</POS>
            </BARRE>
            <BARRE>
                <NOM>BARRE12</NOM>
                <POS>0,0,100,0,100,100</POS>
            </BARRE>
            <BARRE>
                <NOM>BARRE12</NOM>
                <POS>0,0,0,0,100,0</POS>
            </BARRE>
            <NOEUD>
                <NOM>NOEUD1</NOM>
                <POS>100,100,100</POS>
            </NOEUD>
            <NOEUD>
                <NOM>NOEUD2</NOM>
                <POS>100,0,0</POS>
            </NOEUD>
 
        </OBJETS> 
        </pycadConfig>
        ''' 
 
        self.objets=importObjets(xml) #[{'NOM': 'BARRE1', 'TYPE': 'BARRE', 'POS': [0, 0, 0, 100, 0, 0]},
        self.nlignes=len(self.objets)
        self.ncols=len(self.objets[0].keys())
        self.enteteCol={}
        self.enteteCol[0]='NOM'
        self.enteteCol[1]='TYPE'
        self.enteteCol[2]='POS'
 
        self.valeursGrid={}
        for ligne in range(self.nlignes):
            self.valeursGrid[ligne]={}
            self.valeursGrid[ligne][0]=self.objets[ligne]['NOM']
            self.valeursGrid[ligne][1]=self.objets[ligne]['TYPE']
            self.valeursGrid[ligne][2]=str(self.objets[ligne]['POS'])
        print self.valeursGrid
        print "self.valeursGrid[0][0]" ,self.valeursGrid[0][0]
        self.zoom=[0,0,0]
 
 
if __name__ == "__main__":
 
    app = wx.PySimpleApp(0)
    wx.InitAllImageHandlers()
    frame_1 = fr_tableau(None, -1, "")
    app.SetTopWindow(frame_1)
    frame_1.Show()
    app.MainLoop()

[kedare]

Salut
Je te conseille d'aller lire ca pour écrire du code respectant les conventions de nommage de Python :
http://python.developpez.com/cours/
Bonne chance pour ton projet