MAGiC  V5.0
Mailleurs Automatiques de Géometries intégrés à la Cao
stplane.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 //####// stplane.cpp
15 //####//
16 //####//------------------------------------------------------------
17 //####//------------------------------------------------------------
18 //####// COPYRIGHT 2000-2024
19 //####// jeu 13 jun 2024 11:53:59 EDT
20 //####//------------------------------------------------------------
21 //####//------------------------------------------------------------
22 
23 
24 
25 #include <stdlib.h>
26 #include <math.h>
27 #include "st_ident.h"
28 #include "stplane.h"
29 #include "st_gestionnaire.h"
30 #include "stdirection.h"
31 #include "st_point.h"
32 #include "constantegeo.h"
33 
34 
35 
36 
37 ST_PLANE::ST_PLANE(long LigneCourante,std::string idori,long axis2_placement_3d):ST_SURFACE(LigneCourante,idori), id_axis2_placement_3d(axis2_placement_3d)
38 {
39 }
40 
41 ST_PLANE::ST_PLANE(double *xyz,double *direction):ST_SURFACE()
42 {
43  initialiser(xyz,direction);
44 }
45 
46 long ST_PLANE::get_id_axis2_placement_3d(void)
47 {
48  return id_axis2_placement_3d;
49 }
50 
51 void ST_PLANE::calcul_parametre(void)
52 {
53  OT_VECTEUR_3D vec_normal(normal);
54  vec_normal.norme();
55  if (!(OPERATEUR::egal(vec_normal.get_x(),0.,0.000001)))
56  {
57  dir1[0]=vec_normal.get_y();
58  dir1[1]=(-vec_normal.get_x());
59  dir1[2]=0.;
60  }
61  else if (!(OPERATEUR::egal(vec_normal.get_y(),0.,0.000001)))
62  {
63  dir1[0]=0.;
64  dir1[1]=(-vec_normal.get_z());
65  dir1[2]=vec_normal.get_y();
66  }
67  else
68  {
69  dir1[0]=vec_normal.get_z();
70  dir1[1]=0.;
71  dir1[2]=0.;
72  }
73  OT_VECTEUR_3D vec_dir1(dir1);
74  vec_dir1.norme();
75  OT_VECTEUR_3D vec_dir2=vec_normal&vec_dir1;
76  dir2[0]=vec_dir2.get_x();
77  dir2[1]=vec_dir2.get_y();
78  dir2[2]=vec_dir2.get_z();
79 }
80 
81 void ST_PLANE::evaluer(double *uv,double *xyz)
82 {
83  xyz[0]=origine.get_x()+uv[0]*dir1[0]+uv[1]*dir2[0];
84  xyz[1]=origine.get_y()+uv[0]*dir1[1]+uv[1]*dir2[1];
85  xyz[2]=origine.get_z()+uv[0]*dir1[2]+uv[1]*dir2[2];
86 }
87 void ST_PLANE::deriver(double *uv,double *xyzdu, double *xyzdv)
88 {
89  xyzdu[0]=dir1[0];
90  xyzdu[1]=dir1[1];
91  xyzdu[2]=dir1[2];
92  xyzdv[0]=dir2[0];
93  xyzdv[1]=dir2[1];
94  xyzdv[2]=dir2[2];
95 }
96 void ST_PLANE::deriver_seconde(double *uv,double* xyzduu,double* xyzduv,double* xyzdvv,double *xyz , double *xyzdu , double *xyzdv )
97 {
98  xyzduu[0]=0.;
99  xyzduu[1]=0.;
100  xyzduu[2]=0.;
101  xyzduv[0]=0.;
102  xyzduv[1]=0.;
103  xyzduv[2]=0.;
104  xyzdvv[0]=0.;
105  xyzdvv[1]=0.;
106  xyzdvv[2]=0.;
107  evaluer(uv,xyz);
108  deriver(uv,xyzdu,xyzdv);
109 }
110 void ST_PLANE::inverser(double *uv,double *xyz,double precision)
111 {
112  double coord[3];
113  int n1,n2;
114  coord[0]=xyz[0]-origine.get_x();
115  coord[1]=xyz[1]-origine.get_y();
116  coord[2]=xyz[2]-origine.get_z();;
117  double det=dir1[0]*dir2[1]-dir1[1]*dir2[0];
118  if (!(OPERATEUR::egal(det,0.0,0.0001)))
119  {
120  n1=0;
121  n2=1;
122  }
123  else
124  {
125  det=dir1[0]*dir2[2]-dir1[2]*dir2[0];
126  if (!(OPERATEUR::egal(det,0.0,0.0001)))
127  {
128  n1=0;
129  n2=2;
130  }
131  else
132  {
133  n1=1;
134  n2=2;
135  det=dir1[1]*dir2[2]-dir1[2]*dir2[1];
136  }
137  }
138  uv[0]=(coord[n1]*dir2[n2]-coord[n2]*dir2[n1])/det;
139  uv[1]=(dir1[n1]*coord[n2]-dir1[n2]*coord[n1])/det;
140 
141 }
142 int ST_PLANE::est_periodique_u(void)
143 {
144  return 0;
145 }
146 int ST_PLANE::est_periodique_v(void)
147 {
148  return 0;
149 }
150 double ST_PLANE::get_periode_u(void)
151 {
152  return 0.;
153 }
154 double ST_PLANE::get_periode_v(void)
155 {
156  return 0.;
157 }
158 double ST_PLANE::get_umin(void)
159 {
160  return -1e300;
161 }
162 double ST_PLANE::get_umax(void)
163 {
164  return 1e300;
165 }
166 double ST_PLANE::get_vmin(void)
167 {
168  return -1e300;
169 }
170 double ST_PLANE::get_vmax(void)
171 {
172  return 1e300;
173 }
174 void ST_PLANE::initialiser(ST_GESTIONNAIRE *gest)
175 {
176  ST_AXIS2_PLACEMENT_3D* axe=gest->lst_axis2_placement_3d.getid(id_axis2_placement_3d);
177  ST_DIRECTION* dirz=gest->lst_direction.getid(axe->get_id_direction1());
178  ST_POINT* point=gest->lst_point.getid(axe->get_id_point());
179  double xyz[3];
180  point->evaluer(xyz);
181  double *direct=dirz->get_direction();
182  initialiser(xyz,direct);
183 }
184 
185 void ST_PLANE::initialiser(double *point, double *dirnorm)
186 {
187  origine.change_x(point[0]);
188  origine.change_y(point[1]);
189  origine.change_z(point[2]);
190  normal[0]=dirnorm[0];
191  normal[1]=dirnorm[1];
192  normal[2]=dirnorm[2];
193  calcul_parametre();
194 }
195 
196 
197 
198 int ST_PLANE::get_type_geometrique(TPL_LISTE_ENTITE<double> &param)
199 {
200  param.ajouter(origine.get_x());
201  param.ajouter(origine.get_y());
202  param.ajouter(origine.get_z());
203  param.ajouter(normal[0]);
204  param.ajouter(normal[1]);
205  param.ajouter(normal[2]);
206  return GEOMETRIE::CONST::Co_PLAN;
207 }
208 
209 
210 void ST_PLANE::est_util(ST_GESTIONNAIRE* gest)
211 {
212  util=true;
213  gest->lst_axis2_placement_3d.getid(id_axis2_placement_3d)->est_util(gest);
214 }
215 
216 
217 void ST_PLANE::get_param_NURBS(int& indx_premier_ptctr,TPL_LISTE_ENTITE<double> &param)
218 {
219 
220  double uv[2];
221  double xyz[3];
222 
223  param.ajouter(2);
224 
225  param.ajouter(2);
226  param.ajouter(2);
227 
228 
229  param.ajouter(2);
230  param.ajouter(2);
231 
232 
233  param.ajouter(0);
234  param.ajouter(0);
235  param.ajouter(1);
236  param.ajouter(1);
237 
238 
239  param.ajouter(0);
240  param.ajouter(0);
241  param.ajouter(1);
242  param.ajouter(1);
243 
244 
245 
246  double inf_val=10e6;
247 
248 
249  xyz[0]=origine.get_x()+inf_val*dir1[0]+inf_val*dir2[0];
250  xyz[1]=origine.get_y()+inf_val*dir1[1]+inf_val*dir2[1];
251  xyz[2]=origine.get_z()+inf_val*dir1[2]+inf_val*dir2[2];
252 
253  param.ajouter(xyz[0]);
254  param.ajouter(xyz[1]);
255  param.ajouter(xyz[2]);
256  param.ajouter(1);
257 
258 
259 
260  xyz[0]=origine.get_x()-inf_val*dir1[0]+inf_val*dir2[0];
261  xyz[1]=origine.get_y()-inf_val*dir1[1]+inf_val*dir2[1];
262  xyz[2]=origine.get_z()-inf_val*dir1[2]+inf_val*dir2[2];
263 
264  param.ajouter(xyz[0]);
265  param.ajouter(xyz[1]);
266  param.ajouter(xyz[2]);
267  param.ajouter(1);
268 
269 
270  xyz[0]=origine.get_x()+inf_val*dir1[0]-inf_val*dir2[0];
271  xyz[1]=origine.get_y()+inf_val*dir1[1]-inf_val*dir2[1];
272  xyz[2]=origine.get_z()+inf_val*dir1[2]-inf_val*dir2[2];
273 
274  param.ajouter(xyz[0]);
275  param.ajouter(xyz[1]);
276  param.ajouter(xyz[2]);
277  param.ajouter(1);
278 
279 
280 
281  xyz[0]=origine.get_x()-inf_val*dir1[0]-inf_val*dir2[0];
282  xyz[1]=origine.get_y()-inf_val*dir1[1]-inf_val*dir2[1];
283  xyz[2]=origine.get_z()-inf_val*dir1[2]-inf_val*dir2[2];
284 
285  param.ajouter(xyz[0]);
286  param.ajouter(xyz[1]);
287  param.ajouter(xyz[2]);
288  param.ajouter(1);
289 
290 
291  indx_premier_ptctr=13;
292 
293 }
ST_GESTIONNAIRE
Definition: st_gestionnaire.h:55
OT_VECTEUR_3D::change_z
virtual void change_z(double z)
Definition: ot_mathematique.cpp:444
ST_PLANE::evaluer
virtual void evaluer(double *uv, double *xyz)
Definition: stplane.cpp:81
ST_AXIS2_PLACEMENT_3D
Definition: staxis2place3d.h:32
ST_GESTIONNAIRE::lst_direction
TPL_MAP_ENTITE< class ST_DIRECTION * > lst_direction
Definition: st_gestionnaire.h:90
st_gestionnaire.h
ST_PLANE::get_vmin
virtual double get_vmin(void)
Definition: stplane.cpp:166
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_PLANE::get_id_axis2_placement_3d
virtual long get_id_axis2_placement_3d(void)
Definition: stplane.cpp:46
ST_AXIS2_PLACEMENT_3D::est_util
virtual void est_util(class ST_GESTIONNAIRE *gest)
Definition: staxis2place3d.cpp:53
ST_PLANE::est_periodique_v
virtual int est_periodique_v(void)
Definition: stplane.cpp:146
ST_PLANE::calcul_parametre
virtual void calcul_parametre(void)
Definition: stplane.cpp:51
ST_PLANE::get_type_geometrique
virtual int get_type_geometrique(TPL_LISTE_ENTITE< double > &param)
Definition: stplane.cpp:198
OT_VECTEUR_3D::get_x
virtual double get_x(void) const
Definition: ot_mathematique.cpp:417
ST_GESTIONNAIRE::lst_point
TPL_MAP_ENTITE< class ST_POINT * > lst_point
Definition: st_gestionnaire.h:91
ST_DIRECTION
Definition: stdirection.h:32
ST_PLANE::get_param_NURBS
virtual void get_param_NURBS(int &indx_premier_ptctr, TPL_LISTE_ENTITE< double > &param)
Definition: stplane.cpp:217
ST_POINT
Definition: st_point.h:30
ST_PLANE::deriver_seconde
virtual void deriver_seconde(double *uv, double *xyzduu, double *xyzduv, double *xyzdvv, double *xyz=NULL, double *xyzdu=NULL, double *xyzdv=NULL)
Definition: stplane.cpp:96
ST_PLANE::initialiser
virtual void initialiser(class ST_GESTIONNAIRE *gest)
Definition: stplane.cpp:174
st_ident.h
ST_PLANE::dir2
double dir2[3]
Definition: stplane.h:63
stdirection.h
ST_PLANE::origine
OT_VECTEUR_3D origine
Definition: stplane.h:65
ST_PLANE::get_umax
virtual double get_umax(void)
Definition: stplane.cpp:162
OPERATEUR::egal
static int egal(double a, double b, double eps)
Definition: ot_mathematique.cpp:1629
ST_PLANE::get_umin
virtual double get_umin(void)
Definition: stplane.cpp:158
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
ST_PLANE::deriver
virtual void deriver(double *uv, double *xyzdu, double *xyzdv)
Definition: stplane.cpp:87
OT_VECTEUR_3D::norme
virtual void norme(void)
Definition: ot_mathematique.cpp:494
GEOMETRIE::CONST::Co_PLAN
@ Co_PLAN
Definition: constantegeo.h:32
ST_PLANE::ST_PLANE
ST_PLANE(long LigneCourante, std::string idori, long axis2_placement_3d)
Definition: stplane.cpp:37
ST_PLANE::normal
double normal[3]
Definition: stplane.h:64
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_PLANE::get_periode_u
virtual double get_periode_u(void)
Definition: stplane.cpp:150
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
ST_PLANE::est_periodique_u
virtual int est_periodique_u(void)
Definition: stplane.cpp:142
ST_PLANE::get_periode_v
virtual double get_periode_v(void)
Definition: stplane.cpp:154
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_PLANE::est_util
virtual void est_util(class ST_GESTIONNAIRE *gest)
Definition: stplane.cpp:210
ST_PLANE::get_vmax
virtual double get_vmax(void)
Definition: stplane.cpp:170
ST_PLANE::inverser
virtual void inverser(double *uv, double *xyz, double precision=1e-6)
Definition: stplane.cpp:110
OT_VECTEUR_3D::get_z
virtual double get_z(void) const
Definition: ot_mathematique.cpp:429
ST_PLANE::id_axis2_placement_3d
long id_axis2_placement_3d
Definition: stplane.h:61
TPL_LISTE_ENTITE< double >
ST_IDENTIFICATEUR::util
bool util
Definition: st_ident.h:46
st_point.h
stplane.h
ST_PLANE::dir1
double dir1[3]
Definition: stplane.h:62
OT_VECTEUR_3D::change_x
virtual void change_x(double x)
Definition: ot_mathematique.cpp:434