MAGiC  V5.0
Mailleurs Automatiques de Géometries intégrés à la Cao
vct_outils.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 //####// vct_outils.cpp
15 //####//
16 //####//------------------------------------------------------------
17 //####//------------------------------------------------------------
18 //####// COPYRIGHT 2000-2024
19 //####// jeu 13 jun 2024 11:54:00 EDT
20 //####//------------------------------------------------------------
21 //####//------------------------------------------------------------
22 
23 #pragma hdrstop
24 
25 #include "vct_outils.h"
26 #pragma package(smart_init)
27 
28 VCT_OUTILS::VCT_OUTILS(double ord):ordre(ord)
29 {
30 
31 }
32 
33 double2 VCT_OUTILS::get_moment_dans_plan (double2 theta,std::vector<OT_VECTEUR_4DD>& ctrpts,int plan)
34 {
35 
36  int nb_pts=ctrpts.size();
37 
38 
39 
40 
41  double2 zer=0.;
42  double2 sum=0.;
43  for (int i=0;i<nb_pts;i++)
44  {
45  //thi[i]=thi[i]*PI/180;
46  //double2 nori=ctrpts[i].norme();
47  double2 x=ctrpts[i].x()^2;
48  double2 y=ctrpts[i].y()^2;
49  double2 z=ctrpts[i].z()^2;
50  double2 nori;
51 
52  // double2 nori=ctrpts[i].norme();
53  double2 cosi=0.;
54  double2 sini=0.;
55  if (plan==12)
56  {
57  nori=(x+y)^0.5;
58  if (nori!=zer) {
59  cosi=ctrpts[i].get_x()/nori;
60  sini=ctrpts[i].get_y()/nori;
61  }
62  }
63  if (plan==23)
64  {
65  nori=(y+z)^0.5;
66  if (nori!=zer) {
67  cosi=ctrpts[i].get_y()/nori;
68  sini=ctrpts[i].get_z()/nori;
69  }
70 
71  }
72  if (plan==13)
73  {
74  nori=(x+z)^0.5;
75  if (nori!=zer) {
76  cosi=ctrpts[i].get_x()/nori;
77  sini=ctrpts[i].get_z()/nori;
78  }
79  }
80  double2 costh=cos(theta);
81  double2 sinth=sin(theta);
82  double2 d_theta=sini*costh-cosi*sinth;
83  //sum=sum+ pow(li[i],4)*pow(d_theta,4);
84  double2 val1=nori^ordre;
85  double2 val2=d_theta^ordre;
86  double2 val=val1*val2;
87  sum=sum+ val;
88  }
89  return sum;
90 }
91 
92 
93 double2 VCT_OUTILS:: get_max(double2 a,double2 b)
94 {
95  return((a<b)? b : a);
96 }
97 
98 double2 VCT_OUTILS:: get_min(double2 a,double2 b)
99 {
100  return ((a>b)? b : a);
101 }
102 
103 double2 VCT_OUTILS::get_signe(double2 a,double2 b)
104 {
105  double2 zer=0.;
106  double2 c=-1.;
107  if (b>=zer)
108  return a;
109  else
110  return c*a;
111 }
112 
113 void VCT_OUTILS::get_permutation(double2& a,double2& b)
114 {
115  double2 tmp;
116  tmp = a;
117  a = b;
118  b = tmp;
119 }
120 void VCT_OUTILS::get_shift(double2&a,double2&b,double2&c,double2 d)
121 {
122  a=b;
123  b=c;
124  c=d;
125 }
126 
127 void VCT_OUTILS::get_minimum_de_Brak(double2 &ax,double2 &bx,double2 &cx,double2 &fa,double2 &fb,double2 &fc,std::vector<OT_VECTEUR_4DD>& ctrpts,int plan)
128 {
129  static const double2 GOLD=1.618034;
130  static const double2 GLIMIT=100.0;
131  static const double2 TINY=1.0e-20;
132  double2 ulim,u,r,q,fu;
133  //double2(*func)(double2,vector<OT_VECTEUR_4DD>&,int)=&moment;
134  double2 dtheta=0.0001;
135 
136  //aptimisation de la valeur de theta
137 
138  int idx_pts_depart1=-1;
139  int idx_pts_depart2=-1;
140  int nb_pts=ctrpts.size();
141  double2 min_y;
142  double2 min_x;
143  int cfait1=-1;
144  int cfait2=-1;
145  int indx1,indx2;
146  if (plan==12) {
147  indx1=0;
148  indx2=1;
149  }
150  if (plan==23) {
151  indx1=1;
152  indx2=2;
153  }
154  if (plan==13) {
155  indx1=0;
156  indx2=2;
157  }
158 
159  OT_VECTEUR_4DD bary;
160  for (int i=0;i<nb_pts;i++)
161  {
162  bary=bary+ctrpts[i];
163  }
164  bary=1./nb_pts*bary;
165  /*
166 
167  for (int i=0;i<nb_pts;i++)
168  {
169  ctrpts[i]=ctrpts[i]-bary;
170  OT_VECTEUR_4DD pt=ctrpts[i];
171  if (pt[indx1]>dtheta&&pt[indx2]>dtheta)
172  {
173  if (cfait1<0)
174  {
175  min_y=pt[indx2];
176  idx_pts_depart1=i;
177  cfait1=1;
178  }
179  if(pt[indx2]<min_y){
180  min_y=pt[indx2];
181  idx_pts_depart1=i;
182  }
183  }
184 
185  if (pt[indx1]>dtheta&&pt[indx2]>dtheta)
186  {
187  if(cfait2<0)
188  {
189  min_x=pt[indx1];
190  idx_pts_depart2=i;
191  cfait2=1;
192  }
193  if(pt[indx1]<min_x){
194  min_x=pt[indx1];
195  idx_pts_depart2=i;
196  }
197  }
198 
199  }
200  int idx_pts_depart;
201  if(idx_pts_depart1>=0) idx_pts_depart= idx_pts_depart1;
202  else idx_pts_depart= idx_pts_depart2;
203  OT_VECTEUR_4DD dept=ctrpts[idx_pts_depart];
204 
205  double2 theta_depart=atan(dept[indx2]/dept[indx1]);
206 
207  ax=theta_depart;//0.; */
208  ax=0.;
209  bx=ax+dtheta;
210  cx=bx+dtheta;
211  double2 fva=get_moment_dans_plan(ax,ctrpts,plan);//(*func)(ax,ctrpts,plan);
212  double2 fvb=get_moment_dans_plan(bx,ctrpts,plan);//(*func)(bx,ctrpts,plan);
213  double2 fvc=get_moment_dans_plan(cx,ctrpts,plan);//(*func)(cx,ctrpts,plan);
214  cx=cx+dtheta;
215  double2 fvc_plus_dth=get_moment_dans_plan(cx,ctrpts,plan);
216 
217  while (fvb> fva)
218  {
219  ax=bx;
220  bx=ax+dtheta;
221  fva=get_moment_dans_plan(ax,ctrpts,plan);//(*func)(ax,ctrpts,plan);
222  fvb=get_moment_dans_plan(bx,ctrpts,plan);//(*func)(bx,ctrpts,plan);
223  }
224 
225  if (fvb<fva)
226  {
227  cx=bx+dtheta;
228  while (fvb> fvc)
229  {
230  bx=cx;
231  cx=bx+dtheta;
232  fvb=get_moment_dans_plan(bx,ctrpts,plan);//(*func)(bx,ctrpts,plan);
233  fvc=get_moment_dans_plan(cx,ctrpts,plan);//(*func)(cx,ctrpts,plan);
234  }
235  }
236 
237  fa=get_moment_dans_plan(ax,ctrpts,plan);//(*func)(ax,ctrpts,plan);
238  fb=get_moment_dans_plan(bx,ctrpts,plan);//(*func)(bx,ctrpts,plan);
239  if (fb>fa)
240  {
241  std::swap(ax,bx);
242  std::swap(fb,fa);
243  }
244  cx=bx+GOLD*(bx-ax);
245  fc=get_moment_dans_plan(cx,ctrpts,plan);//(*func)(cx,ctrpts,plan);
246  double2 d=2.;
247  double2 zer=0.;
248  while (fb>fc)
249  {
250  r=(bx-ax)*(fb-fc);
251  q=(bx-cx)*(fb-fa);
252  u=bx-((bx-cx)*q-(bx-ax)*r)/(d*get_signe(get_max((q-r).get_fabs(),TINY),q-r));//(d*Sign(Max(abs(q-r),TINY),q-r));
253  ulim=bx+GLIMIT*(cx-bx);
254  if ((bx-u)*(u-cx)>zer)
255  {
256  fu=get_moment_dans_plan(u,ctrpts,plan);//(*func)(u,ctrpts,plan);
257  if (fu<fc)
258  {
259  ax=bx;
260  bx=u;
261  fa=fb;
262  fb=fu;
263  return;
264  }
265  else if (fu>fb)
266  {
267  cx=u;
268  fc=fu;
269  return;
270  }
271  u=cx+GOLD*(cx-bx);
272  fu=get_moment_dans_plan(u,ctrpts,plan);
273  }
274  else if ((cx-u)*(u-ulim)>zer)
275  {
276  fu=get_moment_dans_plan(u,ctrpts,plan);
277  if (fu<fc)
278  {
279  bx=cx;
280  cx=u;
281  u=cx+GOLD*(cx-bx);
282  get_shift(fb,fc,fu,get_moment_dans_plan(u,ctrpts,plan));
283  }
284  }
285  else if ((u-ulim)*(ulim-cx)>=zer)
286  {
287  u=ulim;
288  fu=get_moment_dans_plan(u,ctrpts,plan);
289  }
290  else
291  {
292  u=cx+GOLD*(cx-bx);
293  fu=get_moment_dans_plan(u,ctrpts,plan);
294  }
295  get_shift(ax,bx,cx,u);
296  get_shift(fa,fb,fc,fu);
297  }
298 }
299 
300 
301 
302 
303 std::vector<OT_VECTEUR_4DD> VCT_OUTILS::get_system_axes(std::vector<OT_VECTEUR_4DD>& ctrpts)
304 {
305  double e1_proj[3];
306  double e2_proj[3];
307  double normal_palan_project[3];
308  double normal_au_plan[3];
309  double theta,c,s;
310  double root[3]={0.,0.,0.};
311  OT_ALGORITHME_GEOMETRIQUE algo;
312  int pris=0;
313  OT_MATRICE_3D P, P_1;
314 
315  std::vector<OT_VECTEUR_4DD> syst_axe;
316  int nb_points=ctrpts.size();
317  std::vector<OT_VECTEUR_4DD> ctrpts_proj;
318  OT_VECTEUR_4DD axe1,axe2,axe3,axe4;
319  double2 ax,bx,cx,fa,fb,fc;
320  int plan=12;
321 
322  double2 z0=ctrpts[0].get_z() ;
323  double2 y0=ctrpts[0].get_y() ;
324  double2 x0=ctrpts[0].get_x() ;
325 
326  int cmpt1=0;
327  int cmpt2=0;
328  int cmpt3=0;
329  for (int i=0;i<nb_points;i++)
330  {
331  if (ctrpts[i].get_x()==x0) cmpt1++;
332  if (ctrpts[i].get_y()==y0) cmpt2++;
333  if (ctrpts[i].get_z()==z0) cmpt3++;
334  }
335 
336  if (cmpt1==nb_points) {
337  plan=23;
338  normal_au_plan[0]=1.;
339  normal_au_plan[1]=0.;
340  normal_au_plan[2]=0.;
341  }
342  if (cmpt2==nb_points) {
343  plan=13;
344  normal_au_plan[0]=0.;
345  normal_au_plan[1]=1.;
346  normal_au_plan[2]=0.;
347  }
348  if (cmpt3==nb_points) {
349  plan=12;
350  normal_au_plan[0]=0.;
351  normal_au_plan[1]=0.;
352  normal_au_plan[2]=1.;
353  }
354 
355 
356  get_minimum_de_Brak(ax,bx,cx,fa,fb,fc,ctrpts,plan);
357 
358  theta= bx.get_x();
359  if (theta==1e-6) theta=0.;
360  c=cos(theta);
361  s=sin(theta);
362 
363  if (plan==12)
364  {
365  axe1.change_x(c);
366  axe1.change_y(s);
367  axe1.change_z(0.);
368  axe1.change_w(0.);
369 
370  axe2.change_x(-s);
371  axe2.change_y(c);
372  axe2.change_z(0);
373  axe2.change_w(0);
374  }
375  if (plan==13)
376  {
377  axe1.change_x(c);
378  axe1.change_y(0.);
379  axe1.change_z(s);
380  axe1.change_w(0.);
381 
382  axe2.change_x(-s);
383  axe2.change_y(0);
384  axe2.change_z(c);
385  axe2.change_w(0);
386  }
387  if (plan==23)
388  {
389  axe1.change_x(0);
390  axe1.change_y(c);
391  axe1.change_z(s);
392  axe1.change_w(0.);
393 
394  axe2.change_x(0);
395  axe2.change_y(-s);
396  axe2.change_z(c);
397  axe2.change_w(0);
398  }
399 
400  if (cmpt1==nb_points||cmpt2==nb_points||cmpt3==nb_points)
401  {
402 
403  axe3[0]=normal_au_plan[0];
404  axe3[1]=normal_au_plan[1];
405  axe3[2]=normal_au_plan[2];
406 
407  syst_axe.insert( syst_axe.end(),axe1);
408  syst_axe.insert( syst_axe.end(),axe2);
409  syst_axe.insert( syst_axe.end(),axe3);
410 
411  return syst_axe;
412  }
413 
414  normal_palan_project[0] =s;
415  normal_palan_project[1] =-c;
416  normal_palan_project[2] =0.;
417 
418 
419  for (int i=0;i<nb_points;i++)
420  {
421  OT_VECTEUR_4DD pt_proj;
422  double pnt[3];
423  double proj_pnt[3];
424 
425  pnt[0] =(ctrpts[i].get_x()).get_x();
426  pnt[1] =(ctrpts[i].get_y()).get_x();
427  pnt[2] =(ctrpts[i].get_z()).get_x();
428 
429  algo.Proj3D_Point_Plan (normal_palan_project, root, pnt, proj_pnt);
430 
431  if ((proj_pnt[0]!=0.||proj_pnt[1]!=0.||proj_pnt[2]!=0)&&!pris)
432  {
433  e1_proj[0]=proj_pnt[0];
434  e1_proj[1]=proj_pnt[1];
435  e1_proj[2]=proj_pnt[2];
436  double norm=sqrt(pow(proj_pnt[0],2)+pow(proj_pnt[1],2)+pow(proj_pnt[2],2));
437 
438  e1_proj[0]=e1_proj[0]/norm;
439  e1_proj[1]=e1_proj[1]/norm;
440  e1_proj[2]=e1_proj[2]/norm;
441 
442  e2_proj[0]=normal_palan_project[1]*e1_proj[2]-normal_palan_project[2]*e1_proj[1];
443  e2_proj[1]=normal_palan_project[2]*e1_proj[0]-normal_palan_project[0]*e1_proj[2];
444  e2_proj[2]=normal_palan_project[0]*e1_proj[1]-normal_palan_project[1]*e1_proj[0];
445 
446  OT_VECTEUR_3D V1(e1_proj[0],e2_proj[0],normal_palan_project[0]);
447  OT_VECTEUR_3D V2(e1_proj[1],e2_proj[1],normal_palan_project[1]);
448  OT_VECTEUR_3D V3(e1_proj[2],e2_proj[2],normal_palan_project[2]);
449 
450  P.change_vecteur1(V1);
451  P.change_vecteur2(V2);
452  P.change_vecteur3(V3);
453 
454  P_1=P.inverse();
455  pris=1;
456  }
457 
458  OT_VECTEUR_3D V_PT(proj_pnt[0],proj_pnt[1],proj_pnt[2]);
459 
460  OT_VECTEUR_3D V=P_1*V_PT;
461 
462 
463  pt_proj.change_x(V[0]);
464  pt_proj.change_y(V[1]);
465  pt_proj.change_z(V[2]);
466 
467  ctrpts_proj.insert(ctrpts_proj.end(),pt_proj);
468  }
469 
470  get_minimum_de_Brak(ax,bx,cx,fa,fb,fc,ctrpts_proj,plan);
471 
472  theta= bx.get_x();
473  c=cos(theta);
474  s=sin(theta);
475  OT_VECTEUR_3D Vp(c,s,0.);
476  double nnv_x=Vp*P.get_vecteur1();
477  double nnv_y=Vp*P.get_vecteur2();
478  double nnv_z=Vp*P.get_vecteur3();
479 
480  axe2.change_x(nnv_x);
481  axe2.change_y(nnv_y);
482  axe2.change_z(nnv_z);
483 
484  double2 val=axe1*axe2;
485 
486  axe3[0]=axe1[1]*axe2[2]-axe1[2]*axe2[1];
487  axe3[1]=axe1[2]*axe2[0]-axe1[2]*axe2[2];
488  axe3[2]=axe1[0]*axe2[1]-axe1[2]*axe2[0];
489 
490  axe3[3]=0.;
491 
492 
493  syst_axe.insert( syst_axe.end(),axe1);
494  syst_axe.insert( syst_axe.end(),axe2);
495  syst_axe.insert( syst_axe.end(),axe3);
496 
497  return syst_axe;
498 }
499 
500 
501 
502 
503 OT_MATRICE_3D VCT_OUTILS::get_system_axes(OT_VECTEUR_4DD& root,std::vector<OT_VECTEUR_4DD>& axes,std::vector<OT_VECTEUR_4DD>& ctrpts)
504 {
505 
506  double normal_palan_project[3];
507  double origine[3];
508  double2 ax,bx,cx,fa,fb,fc;
509  double theta,cosin,sinus;
510  OT_MATRICE_3D p,qT, pT,q;
511  std::vector<OT_VECTEUR_4DD> ctrpts_proj;
512  std::vector<OT_VECTEUR_4DD> syst_axe;
513  int nb_points=ctrpts.size();
514  OT_ALGORITHME_GEOMETRIQUE algo;
515 
516  normal_palan_project[0] =(axes[2].get_x()).get_x();
517  normal_palan_project[1] =(axes[2].get_y()).get_x();
518  normal_palan_project[2] =(axes[2].get_z()).get_x();
519  origine[0] =root[0].get_x();
520  origine[1] =root[1].get_x();
521  origine[2] =root[2].get_x();
522 
523  OT_VECTEUR_3D V1((axes[0].get_x()).get_x(),(axes[0].get_y()).get_x(),(axes[0].get_z()).get_x());
524  OT_VECTEUR_3D V2((axes[1].get_x()).get_x(),(axes[1].get_y()).get_x(),(axes[1].get_z()).get_x());
525  OT_VECTEUR_3D V3((axes[2].get_x()).get_x(),(axes[2].get_y()).get_x(),(axes[2].get_z()).get_x());
526 
527  p.change_vecteur1(V1);
528  p.change_vecteur2(V2);
529  p.change_vecteur3(V3);
530  pT=p.transpose();
531 
532  for (int i=0;i<nb_points;i++)
533  {
534  OT_VECTEUR_4DD pt_proj;
535  double point[3];
536  double proj_pnt[3];
537 
538 
539  point[0] =(ctrpts[i].get_x()).get_x();
540  point[1] =(ctrpts[i].get_y()).get_x();
541  point[2] =(ctrpts[i].get_z()).get_x();
542 
543  algo.Proj3D_Point_Plan (normal_palan_project, origine, point, proj_pnt);
544  for (int i=0;i<3;i++)
545  {
546  proj_pnt[i]-= origine[i];
547  }
548 
549  OT_VECTEUR_3D V_PT(proj_pnt[0],proj_pnt[1],proj_pnt[2]);
550 
551  OT_VECTEUR_3D V=pT*V_PT;
552 
553 
554  pt_proj.change_x(V[0]);
555  pt_proj.change_y(V[1]);
556  pt_proj.change_z(V[2]);
557 
558  ctrpts_proj.insert(ctrpts_proj.end(),pt_proj);
559 
560  }
561 
562  get_minimum_de_Brak(ax,bx,cx,fa,fb,fc,ctrpts_proj,12);
563 
564  theta= bx.get_x();
565  cosin=cos(theta);
566  sinus=sin(theta);
567 
568  OT_VECTEUR_4DD e1,e2,e3;
569 
570  e1.change_x(cosin);
571  e1.change_y(sinus);
572  e1.change_z(0.);
573  e1.change_w(0.);
574 
575  e2.change_x(-sinus);
576  e2.change_y(cosin);
577  e2.change_z(0);
578  e2.change_w(0);
579  e3=e1^e2;
580 
581 
582 
583 
584  V1.change_x(cosin);
585  V1.change_y(sinus);
586  V1.change_z(0);
587 
588  V2.change_x((e2[0].get_x()));
589  V2.change_y((e2[1].get_x()));
590  V2.change_z((e2[2].get_x()));
591 
592  V3.change_x((e3[0].get_x()));
593  V3.change_y((e3[1].get_x()));
594  V3.change_z((e3[2].get_x()));
595  q.change_vecteur1(V1);
596  q.change_vecteur2(V2);
597  q.change_vecteur3(V3);
598  qT=q.transpose();
599  syst_axe.insert( syst_axe.end(),e1);
600  syst_axe.insert( syst_axe.end(),e2);
601  syst_axe.insert( syst_axe.end(),e3);
602 
603  OT_MATRICE_3D w=p*q; //les vecteurs de la base est en colone
604  //w=w.inverse();
605 
606  return w;
607 }
608 
609 
610 
611 OT_VECTEUR_4DD VCT_OUTILS::get_plan_medien(std::vector<OT_VECTEUR_4DD>& ctrpts)
612 {
613  int nb_pts=ctrpts.size();
614  OT_MATRICE_3D p;
615  OT_VECTEUR_3D v;
616  for (int i=0;i<nb_pts;i++)
617  {
618  OT_VECTEUR_4DD pt=ctrpts[i];
619  p(0,0)=p(0,0)+pt[0].get_x()*pt[0].get_x();
620  p(0,1)=p(0,0)+pt[0].get_x()*pt[1].get_x();
621  p(0,2)=p(0,0)+pt[0].get_x();
622  p(1,1)=p(0,0)+pt[1].get_x()*pt[1].get_x();
623  p(1,2)=p(0,0)+pt[1].get_x();
624  v[0]=v[0]+pt[0].get_x()*pt[2].get_x();
625  v[1]=v[1]+pt[1].get_x()*pt[2].get_x();
626  v[2]=v[1]+pt[2].get_x();
627  }
628  p(1,0)=p(0,1);
629  p(2,0)=p(0,2);
630  p(2,1)=p(2,1);
631 
632  p=p.inverse();
633  OT_VECTEUR_3D param=p*v;
634  OT_VECTEUR_4DD tparam(param[0],param[1],1,0.);
635  tparam=tparam.vecteur_norme();
636  double2 nor= tparam.norme();
637  double2 prec=1e-5 ;
638  for (int j=0;j<4;j++)
639  {
640  if (tparam[j].get_fabs()<prec)
641  tparam[j]=0.;
642  }
643  tparam[3]=tparam[3]/nor;
644  return tparam;
645 
646 }
OT_VECTEUR_3D::change_z
virtual void change_z(double z)
Definition: ot_mathematique.cpp:444
OT_VECTEUR_4DD::change_x
virtual void change_x(double2 x)
Definition: ot_mathematique.cpp:1456
double2::x
double x
Definition: ot_doubleprecision.h:84
OT_MATRICE_3D::change_vecteur3
void change_vecteur3(OT_VECTEUR_3D v)
Definition: ot_mathematique.cpp:810
OT_VECTEUR_4DD::change_y
virtual void change_y(double2 y)
Definition: ot_mathematique.cpp:1460
OT_VECTEUR_4DD::change_w
virtual void change_w(double2 w)
Definition: ot_mathematique.cpp:1468
a
#define a(i, j)
vct_outils.h
OT_VECTEUR_3D::change_y
virtual void change_y(double y)
Definition: ot_mathematique.cpp:439
double2::get_x
double get_x()
Definition: ot_doubleprecision.cpp:367
VCT_OUTILS::get_max
double2 get_max(double2 a, double2 b)
Definition: vct_outils.cpp:93
OT_ALGORITHME_GEOMETRIQUE::Proj3D_Point_Plan
static void Proj3D_Point_Plan(double *norm, double *root, double *pnt, double *proj_pnt)
Definition: ot_algorithme_geometrique.cpp:309
OT_MATRICE_3D::transpose
void transpose(OT_MATRICE_3D &res) const
Definition: ot_mathematique.cpp:750
VCT_OUTILS::get_system_axes
virtual std::vector< OT_VECTEUR_4DD > get_system_axes(std::vector< OT_VECTEUR_4DD > &ctrpts)
Definition: vct_outils.cpp:303
swap
void swap(double2 &a, double2 &b)
Definition: ot_fonctions.cpp:106
VCT_OUTILS::get_moment_dans_plan
virtual double2 get_moment_dans_plan(double2 theta, std::vector< OT_VECTEUR_4DD > &ctrpts, int plan)
Definition: vct_outils.cpp:33
V2
bool V2(MCBody *_mcBody, MG_ELEMENT_TOPOLOGIQUE *topo)
Definition: CAD4FE_MCBody.cpp:804
VCT_OUTILS::get_shift
void get_shift(double2 &a, double2 &b, double2 &c, double2 d)
Definition: vct_outils.cpp:120
double2
Definition: ot_doubleprecision.h:29
VCT_OUTILS::get_signe
double2 get_signe(double2 a, double2 b)
Definition: vct_outils.cpp:103
OT_MATRICE_3D
Definition: ot_mathematique.h:160
V
void V(MCAA *mcaa)
Definition: CAD4FE_MCAA.cpp:1794
OT_ALGORITHME_GEOMETRIQUE
Definition: ot_algorithme_geometrique.h:32
OT_MATRICE_3D::change_vecteur2
void change_vecteur2(OT_VECTEUR_3D v)
Definition: ot_mathematique.cpp:806
VCT_OUTILS::ordre
double ordre
Definition: vct_outils.h:56
OT_VECTEUR_4DD::get_x
virtual double2 get_x(void) const
Definition: ot_mathematique.cpp:1424
VCT_OUTILS::get_plan_medien
virtual OT_VECTEUR_4DD get_plan_medien(std::vector< OT_VECTEUR_4DD > &ctrpts)
Definition: vct_outils.cpp:611
VCT_OUTILS::get_permutation
void get_permutation(double2 &a, double2 &b)
Definition: vct_outils.cpp:113
VCT_OUTILS::get_minimum_de_Brak
virtual void get_minimum_de_Brak(double2 &ax, double2 &bx, double2 &cx, double2 &fa, double2 &fb, double2 &fc, std::vector< OT_VECTEUR_4DD > &ctrpts, int plan)
Definition: vct_outils.cpp:127
OT_VECTEUR_3D
Definition: ot_mathematique.h:94
OT_VECTEUR_4DD::change_z
virtual void change_z(double2 z)
Definition: ot_mathematique.cpp:1464
sqrt
double2 sqrt(double2 &val)
Definition: ot_doubleprecision.cpp:345
VCT_OUTILS::VCT_OUTILS
VCT_OUTILS(double ord)
Definition: vct_outils.cpp:28
OT_VECTEUR_4DD::norme
double2 norme()
Definition: ot_mathematique.cpp:1395
OT_MATRICE_3D::inverse
OT_MATRICE_3D inverse() const
Definition: ot_mathematique.cpp:767
cos
double2 cos(double2 &val)
Definition: ot_doubleprecision.cpp:206
OT_VECTEUR_4DD
Definition: ot_mathematique.h:284
P
#define P(i, j)
VCT_OUTILS::get_min
double2 get_min(double2 a, double2 b)
Definition: vct_outils.cpp:98
OT_VECTEUR_4DD::vecteur_norme
OT_VECTEUR_4DD vecteur_norme()
Definition: ot_mathematique.cpp:1401
OT_VECTEUR_3D::change_x
virtual void change_x(double x)
Definition: ot_mathematique.cpp:434
OT_MATRICE_3D::change_vecteur1
void change_vecteur1(OT_VECTEUR_3D v)
Definition: ot_mathematique.cpp:802
sin
double2 sin(double2 &val)
Definition: ot_doubleprecision.cpp:250