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

**tyrtamos** · 29/08/2009, 10h42

Bonjour,

A priori, les principes sont les suivants:

- les calculs en flottant sont faits par défaut en pleine précision (double précision du C)

- on peut obtenir à l'affichage des arrondis avec 7 chiffres après la virgule avec round(x,7) ou avec "%.7f" % (x)

Je ne sais pas comment tu as découvert que la précision du résultat était insuffisante, mais je vois deux problèmes possibles:

- Si tu utilises Python 2.6 ou antérieur, les divisions entre 2 entiers donnent un entier.

- Dans certains cas, c'est l'organisation des calculs qui fait perdre anormalement de la précision (pb d'algorithme)

Si ces éléments ne te suffisent pas, pose des questions plus précises (ou attend qu'une personne courageuse épluche tes 239 lignes de code...

)

Tyrtamos

**Tyrus** · 29/08/2009, 20h26

j'ai vite fais regardé ton programme on peux le rendre un peu plus jolie ..
mais pour répondre rapidement voila le résultat que j'obtens avec python 2.6 sur Ubuntu

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
liste_x [[[1939.1099999999999, 485.3623, 1224.7090000000001], [1938.884, 388.62580000000003, 1250.047]]]
liste_y [[[1939.1099999999999, 485.3623, 1224.7090000000001], [2139.098, 485.4699, 1226.8979999999999]]]
liste_z [[[1939.1099999999999, 485.3623, 1224.7090000000001], [1942.327, 409.3458, 934.51739999999995]]]
Origine [1939.1099999999999, 485.3623, 1224.7090000000001]
c [[1939.1099999999999, 485.3623, 1224.7090000000001], [1938.884, 388.62580000000003, 1250.047]]
X :  [1938.884, 388.62580000000003, 1250.047]
c [[1939.1099999999999, 485.3623, 1224.7090000000001], [2139.098, 485.4699, 1226.8979999999999]]
Y :  [2139.098, 485.4699, 1226.8979999999999]
c [[1939.1099999999999, 485.3623, 1224.7090000000001], [1942.327, 409.3458, 934.51739999999995]]
Z :  [1942.327, 409.3458, 934.51739999999995]
XOri 163.588123519 YOri -1952.65921832 ZOri 1286.85896884
XX 163.585863519 YX -1951.65927832 ZX 1286.86969217
XY 162.620758519 YY -1952.65868032 ZY 1286.60558051
XZ 163.841503519 YZ -1952.64827332 ZZ 1285.89166351

j'ai pas de prb de décimal peut étre que ça vient de la version 2.6

**Tyrus** · 30/08/2009, 13h08

j'ai fais quelque modif dans ton script je pense que j'ai rien cassé

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
# -*- coding: UTF-8 -*-
import os
import math
#--------------------------------------------------------------------------
# Ouverture des fichiers
#--------------------------------------------------------------------------
source = '/home/tyrus/DEV/TRIEDRE_XYZ.txt'
o = '/home/tyrus/DEV/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 sum(1 for _ in f) < 200:
    f.seek(0)
    print "Plus"
    tableau_des_points = []
    for ligne in f.readlines():
        print "icie"
        ligne = ligne.strip()
        if ligne.startswith('endsolid'):
                break
        if ligne.startswith('vertex'):
                print "vertex"
                try:
                        ligne_decoupee = ligne.split('  ')
                        tableau_des_points.append((float("%.11f" %float(ligne_decoupee[1])),float("%.11f" %float(ligne_decoupee[2])), float("%.11f" %float(ligne_decoupee[3]))))
                except Exception,e:
                        #print e
                        p=1
    # Fin de la lecture du fichier et fermeture des fichiers
    f.close
 
 
    tableau_des_points_sans_doublon = list(set(tableau_des_points))
    #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,value_i in enumerate(tableau_des_points_sans_doublon):
        for value_j in tableau_des_points_sans_doublon[i+1:]:
            d = distance_2_points(value_i,value_j)
            if d > 99.999 and d < 100.001:
                liste_X.append((value_i,value_j))
            if d > 199.999 and d < 200.001:
                liste_Y.append((value_i,value_j))
            if d > 299.999 and d < 300.001:
                liste_Z.append((value_i,value_j))
    #-----------------------------------------------------------
    # Retrait des doublons dans les listes de points possibles
    #-----------------------------------------------------------
    # pour X
    liste_X_sans_doublon = list(set(liste_X))
    # pour Y
    liste_Y_sans_doublon = list(set(liste_Y))
    # pour Z
    liste_Z_sans_doublon = list(set(liste_Z))
    print liste_X_sans_doublon
    print liste_Y_sans_doublon
    print 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=[]
    liste_X_sans_doublon= [list(a) for  a in liste_X_sans_doublon if Origine  in a]
 
    liste_Y_sans_doublon =[list(a) for a in liste_Y_sans_doublon if Origine  in a ]
 
    liste_Z_sans_doublon =[list(a) for a in liste_Z_sans_doublon if Origine in a ]
 
    #-----------------------------------------------------------
    # Identification du point X
    #-----------------------------------------------------------
    for c in liste_X_sans_doublon:
        print 'c', c
        c.remove(Origine)
    try:
        ptX = (liste_X_sans_doublon[0])[0]
    except:
        ptX = "Erreur"
    print 'X : ', ptX
 
    #-----------------------------------------------------------
    # Identification du point y
    #-----------------------------------------------------------
    for c in liste_Y_sans_doublon:
        print 'c', c
        c.remove(Origine)
    try:
        ptY = (liste_Y_sans_doublon[0])[0]
    except:
        ptY = "Erreur"
    print 'Y : ', ptY
 
    #-----------------------------------------------------------
    # Identification du point Z
    #-----------------------------------------------------------
    for c in liste_Z_sans_doublon:
        print 'c', c
        c.remove(Origine)
    try:
        ptZ = (liste_Z_sans_doublon[0])[0]
    except:
        ptZ = "Erreur"
    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?"

**fraid49** · 30/08/2009, 18h34

Merci à vous deux pour ces réponses.
Tyrtamos : J'ai découvert l'imprécision du calcul en réalisant mon changement de repère dans CATIA V5 et en éditant les positions des points extrémités des trièdres et des différences apparaissent dès le 0.01mm. Pourtant, je crois faire tous mes calculs en float et donc en pleine précision (je penche donc pour le pb d'algorithme?).
Tyrus : Merci d'avoir été le courageux qui a étudié mes 239 lignes de code

. Je vais prendre le temps de bien éplucher tes modifs (il y a certaines commandes que je ne connais pas encore...) avant de te faire mon retour (demain je pense). Merci beaucoup en tout cas!
A noter : je développe sous 2.5 mais le code devra tourner sur une version 2.3...
Bonne fin de week-end,

Fred

**Tyrus** · 30/08/2009, 20h16

Tu a présque de la chance (on peux pas dire que tu a de la chance de devoir la version 2.3)
le set que j'ai utilisé dans le code doit exister dans la version 2.3
http://www.python.org/download/releases/2.3/highlights/

**fraid49** · 31/08/2009, 15h41

Tyrus,

Je viens de tester et interpréter tes corrections. Le programme fonctionne bien (il est surement plus rapide que le mien, ce qui est très bon car le nombre de points peut être beaucoup plus élevé) mais cela ne résout pas le problème de précision (ce qui est normal car l'algorithme de calcul ne change pas).
Je ne connaissais pas le "list(set(liste_dont_on_veut_enlever_les_doublons))", c'est très pratique et ça allège beaucoup le code!!!
Merci en tout cas, je pars sur ta version...

**fraid49** · 31/08/2009, 15h55

J'avance un peu...
En fait, le problème de précision arrive au moment ou le texte détecté dans le fichier stl est transformé d'une chaine de caractère vers un réel (float) par python.
Exemples contradictoires (des fois, ça marche bien, des fois, ça "merdouille") :

Code :

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

1
2
3
4
5
6
>>> 1.939110e+003 #pas OK
1939.1099999999999
>>> 4.853623e+002 # OK
485.3623
>>> 4.853622e+002 #pas OK
485.36219999999997

Il doit donc exister une solution facile... Je vais bien finir par trouver.

Fred

**eyquem** · 31/08/2009, 19h36

le problème de précision arrive au moment ou le texte détecté dans le fichier stl est transformé d'une chaine de caractère vers un réel (float) par python.

Tu veux dire dans la ligne suivante ? :

Code :

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

1
2
3
4
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')))])

Sous mon Python 2.5,

Code :

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

1
2
3
print float('1.939110e+003')
print float('4.853623e+002')
print float('4.853622e+002')

donnent

Code :

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

Je ne saisis toujours pas exactement ton problème.
Peut être est-ce simplement un problème lié à la représentation des nombres par un ordinateur
et aurais tu intérêt à utiliser le module decimal :
http://docs.python.org/3.1/tutorial/floatingpoint.html
http://docs.python.org/library/decimal.html

**Tyrus** · 31/08/2009, 19h50

Il va avoir un petit prb je pense
New in version 2.4.

**eyquem** · 31/08/2009, 20h57

Ah ! Bien vu Tyrus.

Il devrait au moins utiliser le module decimal sous 2.5 pour voir si ça change quelque chose. Si oui, on ne pourra rien faire de plus.

**fraid49** · 31/08/2009, 21h16

Et la réponse est... Module décimal!!!
Ça semble fonctionner très bien (en console avec tests sur les arrondis, reste à corriger le programme).
Par contre je risque d'être bloqué sur l'installation du module sous Python2.3 (faut que je regarde ça de plus près).
Merki pour tout,

Fred
(je poste le programme corrigé et je mets résolu)

**Tyrus** · 31/08/2009, 21h40

Cadeau
http://code.djangoproject.com/svn/dj...ls/_decimal.py
je suis tombé dessus par pur hasard ...

**fraid49** · 31/08/2009, 22h04

Là, j'ai encore besoin d'aide... Si je comprends bien, il s'agit des commandes à taper pour obtenir un module décimal maison pour python 2.3? Si c'est bien ça, c'est merveilleux...
Merci Tyrus

**Tyrus** · 31/08/2009, 22h08

C'est un module decimal pour la version 2.3 elle est utilisé dans django pour les vielles version
Tu peux la placer dans le dossier de ton projet et l'importer en faisant
from _decimal import Decimal

**fraid49** · 31/08/2009, 22h27

Bon, ben c'est merveilleux... Merci encore.
Tcho

**fraid49** · 31/08/2009, 23h06

Bon, après quelques essais avec DECIMAL sous v2.5, ça ne marchait pas mieux (valeurs identiques au 1er script). J'ai donc repris le problème depuis son début : la création de mon fichier stl qui est généré par CATIA (au passage, c'est également sur CATIA que j'ai réalisé mes vérifications des coordonnées).

L'erreur vient du couple CATIA/STL. En effet, c'est l'export en stl qui a une forte perte de précision (les erreurs de 0.001mm dans le stl sont amplifiées par les calculs et passent à 0.01mm).
J'ai cru que cela venait de mon programme notamment à cause des problèmes d'affichage (valeurs écrites avec un mauvais arrondi) qui apparaissaient lors de l'exécution de mon programme (et aussi parce qu'à mon niveau, il vaut mieux douter de son programme avant le reste).
J'ai fait de nouveaux essais sous CATIA en important le fichier stl (ce qui me permet d'avoir la précision du stl) et en vérifiant les coordonnées (habituellement, je reprenais le fichier CATIA dont j'éditai les positions et tout était donc en précision CATIA) et on tombe sur les mêmes valeurs que le script.

J'espère que je suis clair dans mes explications.
Tout cela pour dire que je suis désolé d'avoir levé un problème qui n'avait rien à voir avec python (j'ai au moins appris plein de trucs).

Merci beaucoup pour tout en tout cas.
Bonne soirée,

Fred

Arrondis dans un script de calcul

Python

Discussions similaires

Partager

Partager