MAGiC  V5.0
Mailleurs Automatiques de Géometries intégrés à la Cao
stspherical.cpp
Aller à la documentation de ce fichier.
1 //####//------------------------------------------------------------
2 //####//------------------------------------------------------------
3 //####// MAGiC
4 //####// Jean Christophe Cuilliere et Vincent FRANCOIS
5 //####// Departement de Genie Mecanique - UQTR
6 //####//------------------------------------------------------------
7 //####// MAGIC est un projet de recherche de l equipe ERICCA
8 //####// du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
9 //####// http://www.uqtr.ca/ericca
10 //####// http://www.uqtr.ca/
11 //####//------------------------------------------------------------
12 //####//------------------------------------------------------------
13 //####//
14 //####// stspherical.cpp
15 //####//
16 //####//------------------------------------------------------------
17 //####//------------------------------------------------------------
18 //####// COPYRIGHT 2000-2024
19 //####// jeu 13 jun 2024 11:53:59 EDT
20 //####//------------------------------------------------------------
21 //####//------------------------------------------------------------
22 
23 
24 
25 #include "stspherical.h"
26 #include "st_gestionnaire.h"
27 #include "constantegeo.h"
28 
29 #include <math.h>
30 
31 
32 
33 
34 ST_SPHERICAL::ST_SPHERICAL(long LigneCourante,std::string idori,long axis2,double ray):ST_SURFACE(LigneCourante,idori),id_axis2_placement_3d(axis2),rayon(ray)
35 {
36 }
37 
38 ST_SPHERICAL::ST_SPHERICAL(double *xyz,double *dirz,double *dirx,double ray):ST_SURFACE(),rayon(ray)
39 {
40  initialiser(xyz,dirz,dirx);
41 }
42 
43 
44 long ST_SPHERICAL::get_id_axis2_placement_3d(void)
45 {
46  return id_axis2_placement_3d;
47 }
48 
49 double ST_SPHERICAL::get_rayon(void)
50 {
51  return rayon;
52 }
53 void ST_SPHERICAL::evaluer(double *uv,double *xyz)
54 {
55  OT_VECTEUR_3D local(rayon*cos(uv[1])*cos(uv[0]),rayon*cos(uv[1])*sin(uv[0]),rayon*sin(uv[1]));
56  OT_VECTEUR_3D global=origine+repere*local;
57  xyz[0]=global.get_x();
58  xyz[1]=global.get_y();
59  xyz[2]=global.get_z();
60 }
61 void ST_SPHERICAL::deriver(double *uv,double *xyzdu, double *xyzdv)
62 {
63  OT_VECTEUR_3D localu(-rayon*sin(uv[0])*cos(uv[1]),rayon*cos(uv[0])*cos(uv[1]),0.);
64  OT_VECTEUR_3D localv(-rayon*sin(uv[1])*cos(uv[0]),-rayon*sin(uv[1])*sin(uv[0]),rayon*cos(uv[1]));
65  OT_VECTEUR_3D globalu=repere*localu;
66  OT_VECTEUR_3D globalv=repere*localv;
67  xyzdu[0]=globalu.get_x();
68  xyzdu[1]=globalu.get_y();
69  xyzdu[2]=globalu.get_z();
70  xyzdv[0]=globalv.get_x();
71  xyzdv[1]=globalv.get_y();
72  xyzdv[2]=globalv.get_z();
73 }
74 void ST_SPHERICAL::deriver_seconde(double *uv,double* xyzduu,double* xyzduv,double* xyzdvv,double *xyz , double *xyzdu , double *xyzdv )
75 {
76  OT_VECTEUR_3D localuu(-rayon*cos(uv[1])*cos(uv[0]),-rayon*cos(uv[1])*sin(uv[0]),0.);
77  OT_VECTEUR_3D localuv(rayon*sin(uv[0])*sin(uv[1]),-rayon*cos(uv[0])*sin(uv[1]),0.);
78  OT_VECTEUR_3D localvv(-rayon*cos(uv[1])*cos(uv[0]),-rayon*cos(uv[1])*sin(uv[0]),-rayon*sin(uv[1]));
79  OT_VECTEUR_3D globaluu=repere*localuu;
80  OT_VECTEUR_3D globaluv=repere*localuv;
81  OT_VECTEUR_3D globalvv=repere*localvv;
82  xyzduu[0]=globaluu.get_x();
83  xyzduu[1]=globaluu.get_y();
84  xyzduu[2]=globaluu.get_z();
85  xyzduv[0]=globaluv.get_x();
86  xyzduv[1]=globaluv.get_y();
87  xyzduv[2]=globaluv.get_z();
88  xyzdvv[0]=globalvv.get_x();
89  xyzdvv[1]=globalvv.get_y();
90  xyzdvv[2]=globalvv.get_z();
91  if ((xyzdu!=NULL) && (xyzdv!=NULL ) ) deriver(uv,xyzdu,xyzdv);
92  if (xyz!=NULL) evaluer(uv,xyz);
93 }
94 void ST_SPHERICAL::inverser(double *uv,double *xyz,double precision)
95 {
96  double sign;
97  OT_VECTEUR_3D global(xyz[0],xyz[1],xyz[2]);
98  OT_MATRICE_3D transpose_repere;
99  repere.transpose(transpose_repere);
100  OT_VECTEUR_3D vecteur=transpose_repere*(global-origine);
101  double valeur1;
102  valeur1=vecteur.get_z()/rayon;
103  if (valeur1>1) valeur1=1;
104  if (valeur1<-1) valeur1=-1;
105  uv[1]=asin(valeur1);
106  double valeur2;
107  valeur2=vecteur.get_x()/(rayon*cos(uv[1]));
108  if (valeur2>1) valeur2=1;
109  if (valeur2<-1) valeur2=-1;
110  uv[0]=acos(valeur2);
111  sign=vecteur.get_y()/(rayon*cos(uv[1]));
112  if (sign<-0.000001) uv[0]= 2.*M_PI-uv[0];
113 }
114 int ST_SPHERICAL::est_periodique_u(void)
115 {
116  return 1;
117 }
118 int ST_SPHERICAL::est_periodique_v(void)
119 {
120  return 0;
121 }
122 double ST_SPHERICAL::get_periode_u(void)
123 {
124  return 2.*M_PI;
125 }
126 double ST_SPHERICAL::get_periode_v(void)
127 {
128  return 0;
129 }
130 double ST_SPHERICAL::get_umin(void)
131 {
132  return 0.;
133 }
134 double ST_SPHERICAL::get_umax(void)
135 {
136  return 2.*M_PI;
137 }
138 double ST_SPHERICAL::get_vmin(void)
139 {
140  return -M_PI/2.;
141 }
142 double ST_SPHERICAL::get_vmax(void)
143 {
144  return M_PI/2.;
145 }
146 
147 void ST_SPHERICAL::initialiser(ST_GESTIONNAIRE *gest)
148 {
149  ST_AXIS2_PLACEMENT_3D* axe=gest->lst_axis2_placement_3d.getid(id_axis2_placement_3d);
150  ST_DIRECTION* dirz=gest->lst_direction.getid(axe->get_id_direction1());
151  ST_DIRECTION* dirx=gest->lst_direction.getid(axe->get_id_direction2());
152  ST_POINT* point=gest->lst_point.getid(axe->get_id_point());
153  double xyz[3];
154  point->evaluer(xyz);
155  double *directz=dirz->get_direction();
156  double *directx=dirx->get_direction();
157  initialiser(xyz,directz,directx);
158 }
159 
160 
161 void ST_SPHERICAL::initialiser(double *xyz,double *dirz, double *dirx)
162 {
163  origine.change_x(xyz[0]);
164  origine.change_y(xyz[1]);
165  origine.change_z(xyz[2]);
166  double axez[3]={0.,0.,1.};
167  double axex[3]={1.,0.,0.};
168  if (dirz==NULL)
169  {
170  dirz=axez;
171  dirx=axex;
172  }
173  OT_VECTEUR_3D z(dirz[0],dirz[1],dirz[2]);
174  z.norme();
175  OT_VECTEUR_3D x(dirx[0],dirx[1],dirx[2]);
176  x.norme();
177  OT_VECTEUR_3D y=z&x;
178  repere.change_vecteur1(x);
179  repere.change_vecteur2(y);
180  repere.change_vecteur3(z);
181 }
182 
183 
184 int ST_SPHERICAL::get_type_geometrique(TPL_LISTE_ENTITE<double> &param)
185 {
186  param.ajouter(origine.get_x());
187  param.ajouter(origine.get_y());
188  param.ajouter(origine.get_z());
189  param.ajouter(rayon);
190  return GEOMETRIE::CONST::Co_SPHERE;
191 }
192 
193 
194 void ST_SPHERICAL::est_util(ST_GESTIONNAIRE* gest)
195 {
196  util=true;
197  gest->lst_axis2_placement_3d.getid(id_axis2_placement_3d)->est_util(gest);
198 }
199 
200 
201 
202 void ST_SPHERICAL:: get_param_NURBS(int& indx_premier_ptctr,TPL_LISTE_ENTITE<double> &param)
203 {
204 
205  param.ajouter(2);
206 
207 
208  param.ajouter(4);
209  param.ajouter(4);
210 
211 
212  param.ajouter(4);
213  param.ajouter(7);
214 
215  param.ajouter(0);
216  param.ajouter(0);
217  param.ajouter(0);
218  param.ajouter(0.5);
219  param.ajouter(1);
220  param.ajouter(1);
221  param.ajouter(1);
222 
223 
224  param.ajouter(0);
225  param.ajouter(0);
226  param.ajouter(0);
227  param.ajouter(0.25);
228  param.ajouter(0.5);
229  param.ajouter(0.5);
230  param.ajouter(0.75);
231  param.ajouter(1);
232  param.ajouter(1);
233  param.ajouter(1);
234 
235 
236 
237 
238  double xyz[3];
239  double w;
240  double rx=0.;
241  double ry=0.;
242  double rz=rayon;
243  OT_VECTEUR_3D loc(0,0,rz);
244  OT_VECTEUR_3D glob=origine+repere*loc;
245 
246  double pole1_x=glob.get_x();
247  double pole1_y=glob.get_y();
248  double pole1_z=glob.get_z();
249  loc.change_z(-rz);
250  glob=origine+repere*loc;
251 
252  double pole2_x=glob.get_x();
253  double pole2_y=glob.get_y();
254  double pole2_z=glob.get_z();
255 
256  for (int v=0;v<7;v++)
257  {
258 
259  switch (v) {
260  case 0: {
261  rx=rayon;
262  ry=0;
263  w=1;
264  break;
265  }
266  case 1: {
267  rx=rayon;
268  ry=rayon;
269  w=0.5;
270  break;
271  }
272  case 2: {
273  rx=-rayon;
274  ry=rayon;
275  w=0.5;
276  break;
277  }
278  case 3: {
279  rx=-rayon;
280  ry=0;
281  w=1;
282  break;
283  }
284  case 4: {
285  rx=-rayon;
286  ry=-rayon;
287  w=0.5;
288  break;
289  }
290  case 5: {
291  rx=rayon;
292  ry=-rayon;
293  w=0.5;
294  break;
295  }
296  case 6: {
297  rx=rayon;
298  ry=0;
299  w=1;
300  break;
301  }
302  }
303  param.ajouter(pole1_x);
304  param.ajouter(pole1_y);
305  param.ajouter(pole1_z);
306  param.ajouter(1*w);
307 
308 
309  loc.change_x(rx);
310  loc.change_y(ry);
311  loc.change_z(pole1_z);
312 
313  glob=origine+repere*loc;
314 
315  xyz[0]=glob.get_x();
316  xyz[1]=glob.get_y();
317  xyz[2]=glob.get_z();
318 
319  param.ajouter(xyz[0]);
320  param.ajouter(xyz[1]);
321  param.ajouter(xyz[2]);
322  param.ajouter(0.5*w);
323 
324 
325  loc.change_z(pole2_z);
326 
327  glob=origine+repere*loc;
328 
329  xyz[0]=glob.get_x();
330  xyz[1]=glob.get_y();
331  xyz[2]=glob.get_z();
332 
333  param.ajouter(xyz[0]);
334  param.ajouter(xyz[1]);
335  param.ajouter(xyz[2]);
336  param.ajouter(0.5*w);
337 
338 
339 
340  param.ajouter(pole2_x);
341  param.ajouter(pole2_y);
342  param.ajouter(pole2_z);
343  param.ajouter(1*w);
344 
345 
346  }
347 
348  indx_premier_ptctr=22;
349 
350 }
ST_AXIS2_PLACEMENT_3D::get_id_direction2
virtual long get_id_direction2(void)
Definition: staxis2place3d.cpp:47
ST_GESTIONNAIRE
Definition: st_gestionnaire.h:55
OT_VECTEUR_3D::change_z
virtual void change_z(double z)
Definition: ot_mathematique.cpp:444
ST_SPHERICAL::get_type_geometrique
virtual int get_type_geometrique(TPL_LISTE_ENTITE< double > &param)
Definition: stspherical.cpp:184
ST_SPHERICAL::get_periode_u
virtual double get_periode_u(void)
Definition: stspherical.cpp:122
ST_AXIS2_PLACEMENT_3D
Definition: staxis2place3d.h:32
ST_SPHERICAL::est_periodique_u
virtual int est_periodique_u(void)
Definition: stspherical.cpp:114
OT_MATRICE_3D::change_vecteur3
void change_vecteur3(OT_VECTEUR_3D v)
Definition: ot_mathematique.cpp:810
stspherical.h
ST_GESTIONNAIRE::lst_direction
TPL_MAP_ENTITE< class ST_DIRECTION * > lst_direction
Definition: st_gestionnaire.h:90
ST_SPHERICAL::get_umax
virtual double get_umax(void)
Definition: stspherical.cpp:134
ST_SPHERICAL::deriver
virtual void deriver(double *uv, double *xyzdu, double *xyzdv)
Definition: stspherical.cpp:61
st_gestionnaire.h
ST_SPHERICAL::get_param_NURBS
virtual void get_param_NURBS(int &indx_premier_ptctr, TPL_LISTE_ENTITE< double > &param)
Definition: stspherical.cpp:202
ST_SPHERICAL::get_umin
virtual double get_umin(void)
Definition: stspherical.cpp:130
ST_POINT::evaluer
virtual void evaluer(double *xyz)
Definition: st_point.cpp:50
OT_VECTEUR_3D::change_y
virtual void change_y(double y)
Definition: ot_mathematique.cpp:439
ST_AXIS2_PLACEMENT_3D::est_util
virtual void est_util(class ST_GESTIONNAIRE *gest)
Definition: staxis2place3d.cpp:53
ST_SPHERICAL::id_axis2_placement_3d
long id_axis2_placement_3d
Definition: stspherical.h:63
ST_SPHERICAL::get_periode_v
virtual double get_periode_v(void)
Definition: stspherical.cpp:126
OT_VECTEUR_3D::get_x
virtual double get_x(void) const
Definition: ot_mathematique.cpp:417
OT_MATRICE_3D::transpose
void transpose(OT_MATRICE_3D &res) const
Definition: ot_mathematique.cpp:750
ST_SPHERICAL::origine
OT_VECTEUR_3D origine
Definition: stspherical.h:66
ST_GESTIONNAIRE::lst_point
TPL_MAP_ENTITE< class ST_POINT * > lst_point
Definition: st_gestionnaire.h:91
ST_DIRECTION
Definition: stdirection.h:32
ST_SPHERICAL::est_periodique_v
virtual int est_periodique_v(void)
Definition: stspherical.cpp:118
ST_POINT
Definition: st_point.h:30
ST_SPHERICAL::get_vmax
virtual double get_vmax(void)
Definition: stspherical.cpp:142
ST_SPHERICAL::ST_SPHERICAL
ST_SPHERICAL(long LigneCourante, std::string idori, long axis2d, double ray)
Definition: stspherical.cpp:34
ST_SPHERICAL::initialiser
virtual void initialiser(class ST_GESTIONNAIRE *gest)
Definition: stspherical.cpp:147
ST_SPHERICAL::get_vmin
virtual double get_vmin(void)
Definition: stspherical.cpp:138
OT_MATRICE_3D
Definition: ot_mathematique.h:160
ST_SPHERICAL::inverser
virtual void inverser(double *uv, double *xyz, double precision=1e-6)
Definition: stspherical.cpp:94
constantegeo.h
TPL_LISTE_ENTITE::ajouter
virtual void ajouter(X x)
Definition: tpl_liste_entite.h:38
ST_AXIS2_PLACEMENT_3D::get_id_point
virtual long get_id_point(void)
Definition: staxis2place3d.cpp:37
OT_MATRICE_3D::change_vecteur2
void change_vecteur2(OT_VECTEUR_3D v)
Definition: ot_mathematique.cpp:806
OT_VECTEUR_3D::norme
virtual void norme(void)
Definition: ot_mathematique.cpp:494
asin
double2 asin(double2 &val)
Definition: ot_doubleprecision.cpp:294
ST_GESTIONNAIRE::lst_axis2_placement_3d
TPL_MAP_ENTITE< class ST_AXIS2_PLACEMENT_3D * > lst_axis2_placement_3d
Definition: st_gestionnaire.h:81
ST_SURFACE
Definition: st_surface.h:29
ST_SPHERICAL::repere
OT_MATRICE_3D repere
Definition: stspherical.h:65
ST_AXIS2_PLACEMENT_3D::get_id_direction1
virtual long get_id_direction1(void)
Definition: staxis2place3d.cpp:42
OT_VECTEUR_3D::get_y
virtual double get_y(void) const
Definition: ot_mathematique.cpp:423
acos
double2 acos(double2 &val)
Definition: ot_doubleprecision.cpp:224
OT_VECTEUR_3D
Definition: ot_mathematique.h:94
ST_DIRECTION::get_direction
virtual double * get_direction(void)
Definition: stdirection.cpp:42
TPL_MAP_ENTITE::getid
virtual X getid(unsigned long num)
Definition: tpl_map_entite.h:96
ST_SPHERICAL::rayon
double rayon
Definition: stspherical.h:64
ST_SPHERICAL::get_id_axis2_placement_3d
virtual long get_id_axis2_placement_3d(void)
Definition: stspherical.cpp:44
ST_SPHERICAL::est_util
virtual void est_util(class ST_GESTIONNAIRE *gest)
Definition: stspherical.cpp:194
OT_VECTEUR_3D::get_z
virtual double get_z(void) const
Definition: ot_mathematique.cpp:429
ST_SPHERICAL::deriver_seconde
virtual void deriver_seconde(double *uv, double *xyzduu, double *xyzduv, double *xyzdvv, double *xyz=NULL, double *xyzdu=NULL, double *xyzdv=NULL)
Definition: stspherical.cpp:74
GEOMETRIE::CONST::Co_SPHERE
@ Co_SPHERE
Definition: constantegeo.h:32
TPL_LISTE_ENTITE< double >
ST_IDENTIFICATEUR::util
bool util
Definition: st_ident.h:46
cos
double2 cos(double2 &val)
Definition: ot_doubleprecision.cpp:206
ST_SPHERICAL::get_rayon
virtual double get_rayon(void)
Definition: stspherical.cpp:49
OT_MATRICE_3D::change_vecteur1
void change_vecteur1(OT_VECTEUR_3D v)
Definition: ot_mathematique.cpp:802
OT_VECTEUR_3D::change_x
virtual void change_x(double x)
Definition: ot_mathematique.cpp:434
sin
double2 sin(double2 &val)
Definition: ot_doubleprecision.cpp:250
ST_SPHERICAL::evaluer
virtual void evaluer(double *uv, double *xyz)
Definition: stspherical.cpp:53