Arrondis dans un script de calcul

**fraid49** · 28/08/2009, 09h45

Bonjour à tous,

Je viens de finir un petit programme de calcul qui lit un fichier STL (STL = nuage de points 3d représentant un objet - dans mon exemple joint, seulement un trièdre), le prog reconnait le trièdre par la longueur des axes (X=100, Y=200, Z=300), isole les coordonnées de l'origine (le seul point extrémité commun aux 3 axes) et de chaque 2eme extrémité des axes puis calcule la base de passage du repère général au repère du trièdre (et inversement)... j'espère être clair!!!

Mon problème : le programme fonctionne mais arrondi les valeurs à la deuxième décimale, ce qui ne me convient pas, le mieux serait un arrondi autour de la 7ème décimale (besoin de précision élevé).

Je tiens à préciser que je suis débutant et que mon code est surement 10 fois trop long et pas terrible...

A noter, le fichier STL comporte ici une extension txt car je n'arrivai pas à l'insérer avec l'extension stl (la correction est faite dans le programme, normalement, tout doit marcher en collant le fichier sur le bureau et en changeant uniquement le chemin de votre bureau).

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
234
235
236
237
238
239
240
 
import os
import math
#--------------------------------------------------------------------------
# Ouverture des fichiers
#--------------------------------------------------------------------------
source = 'C:/Documents and Settings/Lot/Bureau/TRIEDRE_XYZ.txt'
o = 'C:/Documents and Settings/Lot/Bureau/fichier_iges_en_cours.txt'
# On ouvre le fichier part1corrigee.igs
f = open(source,'r+')
 
#--------------------------------------------------------------------------
# Définition de la fonction de calcul des distances
#--------------------------------------------------------------------------
def distance_2_points(point1, point2):
    return math.sqrt((point2[0]-point1[0])*(point2[0]-point1[0]) + (point2[1]-point1[1])*(point2[1]-point1[1]) + (point2[2]-point1[2])*(point2[2]-point1[2]))
 
# Si le fichier fait plus de 200 lignes, alors le temps de calcul sera trop long, le trièdre est surement mal créé
if len(f.readlines()) < 200:
    f.seek(0)
    tableau_des_points = []
    ligne = str(f.readline())
    while ligne[:8] != 'endsolid':
        ligne_decoupee = ligne.split(' ')
        try:
            if ligne_decoupee[6]=='vertex':
                ligne_decoupee_sans_espace = [x for x in ligne_decoupee if x!='']
                tableau_des_points.append([float("%.11f" %float(ligne_decoupee_sans_espace[1])), float("%.11f" %float(ligne_decoupee_sans_espace[2])), float("%.11f" %float(ligne_decoupee_sans_espace[3].rstrip('\n')))])
        except:
            p=1
        ligne = str(f.readline())
    # Fin de la lecture du fichier et fermeture des fichiers
    f.close
 
    tableau_des_points_sans_doublon = []
    for k in tableau_des_points:
        if k not in tableau_des_points_sans_doublon:
            tableau_des_points_sans_doublon.append(k)
    #--------------------------------------------------------------------------
    # Création des listes de points possibles pour chaque axe en fonction des distances 
    #--------------------------------------------------------------------------
    liste_X = []
    liste_Y = []
    liste_Z = []
    for i in range(len(tableau_des_points_sans_doublon)-1):
        for j in range(i+1,len(tableau_des_points_sans_doublon)):
            d = distance_2_points(tableau_des_points_sans_doublon[i],tableau_des_points_sans_doublon[j])
            if d > 99.999 and d < 100.001:
                liste_X.append([tableau_des_points_sans_doublon[i],tableau_des_points_sans_doublon[j]])
            if d > 199.999 and d < 200.001:
                liste_Y.append([tableau_des_points_sans_doublon[i],tableau_des_points_sans_doublon[j]])
            if d > 299.999 and d < 300.001:
                liste_Z.append([tableau_des_points_sans_doublon[i],tableau_des_points_sans_doublon[j]])              
    #-----------------------------------------------------------
    # Retrait des doublons dans les listes de points possibles
    #-----------------------------------------------------------
    # pour X
    liste_X_sans_doublon = []
    for k in liste_X:
        if k not in liste_X_sans_doublon:
            liste_X_sans_doublon.append(k)
    print 'liste_x', liste_X_sans_doublon
    # pour Y
    liste_Y_sans_doublon = []
    for k in liste_Y:
        if k not in liste_Y_sans_doublon:
            liste_Y_sans_doublon.append(k)
    print 'liste_y', liste_Y_sans_doublon
    # pour Z
    liste_Z_sans_doublon = []
    for k in liste_Z:
        if k not in liste_Z_sans_doublon:
            liste_Z_sans_doublon.append(k)
    print 'liste_z', liste_Z_sans_doublon
 
    #-----------------------------------------------------------
    # Identification de l'origine
    #-----------------------------------------------------------
    liste_origine_xy = []
    for a in liste_X_sans_doublon:
        for b in liste_Y_sans_doublon:
            if (a[0] == b[0] or a[0] == b[1]):
                liste_origine_xy.append(a[0])
            if (a[1] == b[0] or a[1] == b[1]):
                liste_origine_xy.append(a[1])
 
    for a in liste_origine_xy:
        for b in liste_Z_sans_doublon:
            for c in b:
                if a == c:
                    Origine = a
                    break
    print 'Origine', Origine
 
    #-----------------------------------------------------------
    # Suppression des binomes ne comportant pas l'origine dans chacune des listes sans doublon
    #-----------------------------------------------------------
    liste_elements_a_enlever=[]
    for a in liste_X_sans_doublon:
        if Origine not in a:
            liste_elements_a_enlever.append(a)
    for b in liste_elements_a_enlever:
        liste_X_sans_doublon.remove(b)
 
    liste_elements_a_enlever=[]
    for a in liste_Y_sans_doublon:
        if Origine not in a:
            liste_elements_a_enlever.append(a)
    for b in liste_elements_a_enlever:
        liste_Y_sans_doublon.remove(b)
 
    liste_elements_a_enlever=[]
    for a in liste_Z_sans_doublon:
        if Origine not in a:
            liste_elements_a_enlever.append(a)
    for b in liste_elements_a_enlever:
        liste_Z_sans_doublon.remove(b)
 
    #-----------------------------------------------------------
    # Identification du point X
    #-----------------------------------------------------------
    for c in liste_X_sans_doublon:
        print 'c', c
        c.remove(Origine)
    ptX = (liste_X_sans_doublon[0])[0]
    print 'X : ', ptX
 
    #-----------------------------------------------------------
    # Identification du point y
    #-----------------------------------------------------------
    for c in liste_Y_sans_doublon:
        print 'c', c
        c.remove(Origine)
    ptY = (liste_Y_sans_doublon[0])[0]  
    print 'Y : ', ptY
 
    #-----------------------------------------------------------
    # Identification du point Z
    #-----------------------------------------------------------
    for c in liste_Z_sans_doublon:
        print 'c', c
        c.remove(Origine)
    ptZ = (liste_Z_sans_doublon[0])[0]  
    print 'Z : ', ptZ
 
    #-----------------------------------------------------------------------
    #***********************************************************************
    #-----------------------------------------------------------------------
    # On exprime les coordonnï¿½s des vecteurs de 2 dans la base 1
    vecXnorme = [(ptX[0]-Origine[0])/100.0, (ptX[1]-Origine[1])/100.0, (ptX[2]-Origine[2])/100.0]
    vecYnorme = [(ptY[0]-Origine[0])/200.0, (ptY[1]-Origine[1])/200.0, (ptY[2]-Origine[2])/200.0]
    vecZnorme = [(ptZ[0]-Origine[0])/300.0, (ptZ[1]-Origine[1])/300.0, (ptZ[2]-Origine[2])/300.0]
 
    iXd1 = vecXnorme[0]
    jXd1 = vecYnorme[0]
    kXd1 = vecZnorme[0]
 
    iYd1 = vecXnorme[1]
    jYd1 = vecYnorme[1]
    kYd1 = vecZnorme[1]
 
    iZd1 = vecXnorme[2]
    jZd1 = vecYnorme[2]
    kZd1 = vecZnorme[2]
 
    #-----------------------------------------------------------------------
    # On exprime les coordonnï¿½s des vecteurs de 1 dans la base 2 (~transposée...)
    vecXnorme2 = [(ptX[0]-Origine[0])/100.0, (ptY[0]-Origine[0])/200.0,(ptZ[0]-Origine[0])/300.0]
    vecYnorme2 = [(ptX[1]-Origine[1])/100.0, (ptY[1]-Origine[1])/200.0,(ptZ[1]-Origine[1])/300.0]
    vecZnorme2 = [(ptX[2]-Origine[2])/100.0, (ptY[2]-Origine[2])/200.0,(ptZ[2]-Origine[2])/300.0]
 
    #-----------------------------------------------------------------------
    # Calcul des coordonnï¿½s des vecteurs de 1 dans 2
    iXd2 = vecXnorme2[0]
    jXd2 = vecYnorme2[0]
    kXd2 = vecZnorme2[0]
 
    iYd2 = vecXnorme2[1]
    jYd2 = vecYnorme2[1]
    kYd2 = vecZnorme2[1]
 
    iZd2 = vecXnorme2[2]
    jZd2 = vecYnorme2[2]
    kZd2 = vecZnorme2[2]
 
    #-----------------------------------------------------------------------
    # Calcul des coordonnées des points de 1 dans 2
    xO = -(Origine[0] * iXd2 + Origine[1] * jXd2 + Origine[2] * kXd2)
    yO = -(Origine[0] * iYd2 + Origine[1] * jYd2 + Origine[2] * kYd2)
    zO = -(Origine[0] * iZd2 + Origine[1] * jZd2 + Origine[2] * kZd2)
 
    xX = xO + iXd1
    yX = yO + jXd1
    zX = zO + kXd1
 
    xY = xO + iYd1
    yY = yO + jYd1
    zY = zO + kYd1
 
    xZ = xO + iZd1
    yZ = yO + jZd1
    zZ = zO + kZd1
 
    print 'XOri', xO, 'YOri', yO, 'ZOri', zO
    print 'XX', xX, 'YX', yX, 'ZX', zX
    print 'XY', xY, 'YY', yY, 'ZY', zY
    print 'XZ', xZ, 'YZ', yZ, 'ZZ', zZ
 
    iges = open(o,'w+')
    # Ecriture des coordonnees de 1 dans 2 dans le fichier
    iges.write(str(xO) + '\n')
    iges.write(str(yO) + '\n')
    iges.write(str(zO) + '\n')
    iges.write(str(xX) + '\n')
    iges.write(str(yX) + '\n')
    iges.write(str(zX) + '\n')
    iges.write(str(xY) + '\n')
    iges.write(str(yY) + '\n')
    iges.write(str(zY) + '\n')
    iges.write(str(xZ) + '\n')
    iges.write(str(yZ) + '\n')
    iges.write(str(zZ) + '\n')
    # Ecriture des coordonnees de 2 dans 1 dans le fichier
    iges.write(str(Origine[0]) + '\n')
    iges.write(str(Origine[1]) + '\n')
    iges.write(str(Origine[2]) + '\n')
    iges.write(str(ptX[0]) + '\n')
    iges.write(str(ptX[1]) + '\n')
    iges.write(str(ptX[2]) + '\n')
    iges.write(str(ptY[0]) + '\n')
    iges.write(str(ptY[1]) + '\n')
    iges.write(str(ptY[2]) + '\n')
    iges.write(str(ptZ[0]) + '\n')
    iges.write(str(ptZ[1]) + '\n')
    iges.write(str(ptZ[2]) + '\n')
    iges.write('en_position_outil')
    iges.close()
 
else:
    print "le fichier censé contenir uniquement le trièdre est trop long, ttes vous sûr qu'il ne contient que le trièdre?"

J'espère que tout est clair et que je n'oublie rien... Merci d'avance à ceux et celles qui voudront bien y jeter un œil et bonne journée aux autres.

Fred

Arrondis dans un script de calcul

Python

Mode arborescent

Discussions similaires

Partager

Partager