Discussion :

[fraid49]

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]

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]

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]

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]

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]

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/