step/src/stspherical.cpp

//------------------------------------------------------------
//------------------------------------------------------------
//  MAGiC
//  Jean Christophe Cuillière et Vincent FRANCOIS
//  Département de Génie Mécanique - UQTR
//------------------------------------------------------------
//  Le projet MAGIC est un projet de recherche du département
//  de génie mécanique de l'Université du Québec à
//  Trois Rivières
//  Les librairies ne peuvent être utilisées sans l'accord
//  des auteurs (contact : francois@uqtr.ca)
//------------------------------------------------------------
//------------------------------------------------------------
//
//       stspherical.cpp
//
//------------------------------------------------------------
//------------------------------------------------------------
//  COPYRIGHT 2000
//  Version du 02/03/2006 à 11H24
//------------------------------------------------------------
//------------------------------------------------------------


#include "gestionversion.h"

#include "stspherical.h"
#include "st_gestionnaire.h"
#include "constantegeo.h"

#include <math.h>


ST_SPHERICAL::ST_SPHERICAL(long LigneCourante,std::string idori,long axis2,double ray):ST_SURFACE(LigneCourante,idori),id_axis2_placement_3d(axis2),rayon(ray)
{
}

ST_SPHERICAL::ST_SPHERICAL(double *xyz,double *dirz,double *dirx,double ray):ST_SURFACE(),rayon(ray)
{
initialiser(xyz,dirz,dirx);
}


long ST_SPHERICAL::get_id_axis2_placement_3d(void)
{
return id_axis2_placement_3d;
}

double ST_SPHERICAL::get_rayon(void)
{
return rayon;
}
void  ST_SPHERICAL::evaluer(double *uv,double *xyz)
{
OT_VECTEUR_3D local(rayon*cos(uv[1])*cos(uv[0]),rayon*cos(uv[1])*sin(uv[0]),rayon*sin(uv[1]));
OT_VECTEUR_3D global=origine+repere*local;
xyz[0]=global.get_x();
xyz[1]=global.get_y();
xyz[2]=global.get_z();
}
void  ST_SPHERICAL::deriver(double *uv,double *xyzdu, double *xyzdv)
{
OT_VECTEUR_3D localu(-rayon*sin(uv[0])*cos(uv[1]),rayon*cos(uv[0])*cos(uv[1]),0.);
OT_VECTEUR_3D localv(-rayon*sin(uv[1])*cos(uv[0]),-rayon*sin(uv[1])*sin(uv[0]),rayon*cos(uv[1]));
OT_VECTEUR_3D globalu=repere*localu;
OT_VECTEUR_3D globalv=repere*localv;
xyzdu[0]=globalu.get_x();
xyzdu[1]=globalu.get_y();
xyzdu[2]=globalu.get_z();
xyzdv[0]=globalv.get_x();
xyzdv[1]=globalv.get_y();
xyzdv[2]=globalv.get_z();
}
void  ST_SPHERICAL::deriver_seconde(double *uv,double* xyzduu,double* xyzduv,double* xyzdvv,double *xyz , double *xyzdu , double *xyzdv )
{
OT_VECTEUR_3D localuu(-rayon*cos(uv[1])*cos(uv[0]),-rayon*cos(uv[1])*sin(uv[0]),0.);
OT_VECTEUR_3D localuv(rayon*sin(uv[0])*sin(uv[1]),-rayon*cos(uv[0])*sin(uv[1]),0.);
OT_VECTEUR_3D localvv(-rayon*cos(uv[1])*cos(uv[0]),-rayon*cos(uv[1])*sin(uv[0]),-rayon*sin(uv[1]));
OT_VECTEUR_3D globaluu=repere*localuu;
OT_VECTEUR_3D globaluv=repere*localuv;
OT_VECTEUR_3D globalvv=repere*localvv;
xyzduu[0]=globaluu.get_x();
xyzduu[1]=globaluu.get_y();
xyzduu[2]=globaluu.get_z();
xyzduv[0]=globaluv.get_x();
xyzduv[1]=globaluv.get_y();
xyzduv[2]=globaluv.get_z();
xyzdvv[0]=globalvv.get_x();
xyzdvv[1]=globalvv.get_y();
xyzdvv[2]=globalvv.get_z();
if ((xyzdu!=NULL) && (xyzdv!=NULL ) ) deriver(uv,xyzdu,xyzdv);
if (xyz!=NULL) evaluer(uv,xyz);
}
void  ST_SPHERICAL::inverser(double *uv,double *xyz,double precision)
{
double sign;
OT_VECTEUR_3D global(xyz[0],xyz[1],xyz[2]);
OT_MATRICE_3D transpose_repere;
repere.transpose(transpose_repere);
OT_VECTEUR_3D vecteur=transpose_repere*(global-origine);
double valeur1;
valeur1=vecteur.get_z()/rayon;
if (valeur1>1) valeur1=1;
if (valeur1<-1) valeur1=-1;
uv[1]=asin(valeur1);
double valeur2;
valeur2=vecteur.get_x()/(rayon*cos(uv[1]));
if (valeur2>1) valeur2=1;
if (valeur2<-1) valeur2=-1;
uv[0]=acos(valeur2);
sign=vecteur.get_y()/(rayon*cos(uv[1]));
if (sign<-0.000001) uv[0]= 2.*M_PI-uv[0];
}
int ST_SPHERICAL::est_periodique_u(void)
{
return 1;
}
int ST_SPHERICAL::est_periodique_v(void)
{
return 0;
}
double ST_SPHERICAL::get_periode_u(void)
{
return 2.*M_PI;
}
double ST_SPHERICAL::get_periode_v(void)
{
return 0;
}
double  ST_SPHERICAL::get_umin(void)
{
return 0.;
}
double  ST_SPHERICAL::get_umax(void)
{
return 2.*M_PI;
}
double  ST_SPHERICAL::get_vmin(void)
{
return -M_PI/2.;
}
double  ST_SPHERICAL::get_vmax(void)
{
return M_PI/2.;
}

void ST_SPHERICAL::initialiser(ST_GESTIONNAIRE *gest)
{
ST_AXIS2_PLACEMENT_3D* axe=gest->lst_axis2_placement_3d.getid(id_axis2_placement_3d);
ST_DIRECTION* dirz=gest->lst_direction.getid(axe->get_id_direction1());
ST_DIRECTION* dirx=gest->lst_direction.getid(axe->get_id_direction2());
ST_POINT* point=gest->lst_point.getid(axe->get_id_point());
double xyz[3];
point->evaluer(xyz);
double *directz=dirz->get_direction();
double *directx=dirx->get_direction();
initialiser(xyz,directz,directx);
}


void ST_SPHERICAL::initialiser(double *xyz,double *dirz, double *dirx)
{
origine.change_x(xyz[0]);
origine.change_y(xyz[1]);
origine.change_z(xyz[2]);
double axez[3]={0.,0.,1.};
double axex[3]={1.,0.,0.};
if (dirz==NULL)
        {
        dirz=axez;
        dirx=axex;
        }
OT_VECTEUR_3D z(dirz[0],dirz[1],dirz[2]);
z.norme();
OT_VECTEUR_3D x(dirx[0],dirx[1],dirx[2]);
x.norme();
OT_VECTEUR_3D y=z&x;
repere.change_vecteur1(x);
repere.change_vecteur2(y);
repere.change_vecteur3(z);
}


int ST_SPHERICAL::get_type_geometrique(TPL_LISTE_ENTITE<double> &param)
{
param.ajouter(origine.get_x());
param.ajouter(origine.get_y());
param.ajouter(origine.get_z());
param.ajouter(rayon);
return MGCo_SPHERE;
}


void ST_SPHERICAL::est_util(ST_GESTIONNAIRE* gest)
{
util=true;
gest->lst_axis2_placement_3d.getid(id_axis2_placement_3d)->est_util(gest);
}


void ST_SPHERICAL:: get_param_NURBS(int& indx_premier_ptctr,TPL_LISTE_ENTITE<double> &param)
{

// The first parameter indicate the code access
param.ajouter(2);

// The  follewing two parameters of the list indicate the orders of the net points

param.ajouter(4);
param.ajouter(4);

// The follewing two parameters indicate the number of rows and colons of the control points
// respectively to the two parameters directions

param.ajouter(4);
param.ajouter(7);

// this present the knot vector in the u-direction
param.ajouter(0);
param.ajouter(0);
param.ajouter(0);
param.ajouter(0.5);
param.ajouter(1);
param.ajouter(1);
param.ajouter(1);


// the following is the V_knots of the semicircle in the direction V
param.ajouter(0);
param.ajouter(0);
param.ajouter(0);
param.ajouter(0.25);
param.ajouter(0.5);
param.ajouter(0.5);
param.ajouter(0.75);
param.ajouter(1);
param.ajouter(1);
param.ajouter(1);


// the weight of the controle point are given in this vecteur wi={1,0.5,0.5,1}
// Notice that the controle point at the north and south poles of the sphere
// are repeated sventh times P0,0=....=P6,0 and P0,3=....=P0,3

double xyz[3];
double w;
double rx=0.;
double ry=0.;
double rz=rayon;
//==========================================
//POLE 1
//==========================================
OT_VECTEUR_3D loc(0,0,rz);
OT_VECTEUR_3D glob=origine+repere*loc;

double pole1_x=glob.get_x();
double pole1_y=glob.get_y();
double pole1_z=glob.get_z();
//==========================================
//POLE 2
//==========================================
loc.change_z(-rz);
glob=origine+repere*loc;

double pole2_x=glob.get_x();
double pole2_y=glob.get_y();
double pole2_z=glob.get_z();
//==========================================

for(int v=0;v<7;v++)
 {

switch (v){
case 0: {rx=rayon;ry=0;w=1; break;}
case 1: {rx=rayon;ry=rayon;w=0.5; break;}
case 2: {rx=-rayon;ry=rayon;w=0.5; break;}
case 3: {rx=-rayon;ry=0;w=1; break;}
case 4: {rx=-rayon;ry=-rayon;w=0.5; break;}
case 5: {rx=rayon;ry=-rayon;w=0.5; break;}
case 6: {rx=rayon;ry=0;w=1; break;}
}
//P0j
param.ajouter(pole1_x);
param.ajouter(pole1_y);
param.ajouter(pole1_z);
param.ajouter(1*w);

//P1j

loc.change_x(rx);
loc.change_y(ry);
loc.change_z(pole1_z);

glob=origine+repere*loc;

xyz[0]=glob.get_x();
xyz[1]=glob.get_y();
xyz[2]=glob.get_z();

param.ajouter(xyz[0]);
param.ajouter(xyz[1]);
param.ajouter(xyz[2]);
param.ajouter(0.5*w);

//P2j

loc.change_z(pole2_z);

glob=origine+repere*loc;

xyz[0]=glob.get_x();
xyz[1]=glob.get_y();
xyz[2]=glob.get_z();

param.ajouter(xyz[0]);
param.ajouter(xyz[1]);
param.ajouter(xyz[2]);
param.ajouter(0.5*w);


//P3j

param.ajouter(pole2_x);
param.ajouter(pole2_y);
param.ajouter(pole2_z);
param.ajouter(1*w);


 }

indx_premier_ptctr=22;

}
Revision:	19
Committed:	Wed Jun 20 17:47:45 2007 UTC (17 years, 10 months ago) by francois
Original Path:	*magic/lib/step/step/src/stspherical.cpp*
File size:	8658 byte(s)
Log Message:	ajout d'un index dans les param NURBS
#	User	Rev	Content
1		5	//------------------------------------------------------------
2			//------------------------------------------------------------
3			// MAGiC
4			// Jean Christophe Cuillière et Vincent FRANCOIS
5			// Département de Génie Mécanique - UQTR
6			//------------------------------------------------------------
7			// Le projet MAGIC est un projet de recherche du département
8			// de génie mécanique de l'Université du Québec à
9			// Trois Rivières
10			// Les librairies ne peuvent être utilisées sans l'accord
11			// des auteurs (contact : francois@uqtr.ca)
12			//------------------------------------------------------------
13			//------------------------------------------------------------
14			//
15			// stspherical.cpp
16			//
17			//------------------------------------------------------------
18			//------------------------------------------------------------
19			// COPYRIGHT 2000
20			// Version du 02/03/2006 à 11H24
21			//------------------------------------------------------------
22			//------------------------------------------------------------
23
24
25			#include "gestionversion.h"
26
27			#include "stspherical.h"
28			#include "st_gestionnaire.h"
29			#include "constantegeo.h"
30
31			#include <math.h>
32
33
34
35
36			ST_SPHERICAL::ST_SPHERICAL(long LigneCourante,std::string idori,long axis2,double ray):ST_SURFACE(LigneCourante,idori),id_axis2_placement_3d(axis2),rayon(ray)
37			{
38			}
39
40			ST_SPHERICAL::ST_SPHERICAL(double xyz,double dirz,double *dirx,double ray):ST_SURFACE(),rayon(ray)
41			{
42			initialiser(xyz,dirz,dirx);
43			}
44
45
46			long ST_SPHERICAL::get_id_axis2_placement_3d(void)
47			{
48			return id_axis2_placement_3d;
49			}
50
51			double ST_SPHERICAL::get_rayon(void)
52			{
53			return rayon;
54			}
55			void ST_SPHERICAL::evaluer(double uv,double xyz)
56			{
57			OT_VECTEUR_3D local(rayoncos(uv[1])cos(uv[0]),rayoncos(uv[1])sin(uv[0]),rayon*sin(uv[1]));
58			OT_VECTEUR_3D global=origine+repere*local;
59			xyz[0]=global.get_x();
60			xyz[1]=global.get_y();
61			xyz[2]=global.get_z();
62			}
63			void ST_SPHERICAL::deriver(double uv,double xyzdu, double *xyzdv)
64			{
65			OT_VECTEUR_3D localu(-rayonsin(uv[0])cos(uv[1]),rayoncos(uv[0])cos(uv[1]),0.);
66			OT_VECTEUR_3D localv(-rayonsin(uv[1])cos(uv[0]),-rayonsin(uv[1])sin(uv[0]),rayon*cos(uv[1]));
67			OT_VECTEUR_3D globalu=repere*localu;
68			OT_VECTEUR_3D globalv=repere*localv;
69			xyzdu[0]=globalu.get_x();
70			xyzdu[1]=globalu.get_y();
71			xyzdu[2]=globalu.get_z();
72			xyzdv[0]=globalv.get_x();
73			xyzdv[1]=globalv.get_y();
74			xyzdv[2]=globalv.get_z();
75			}
76			void ST_SPHERICAL::deriver_seconde(double uv,double xyzduu,double* xyzduv,double* xyzdvv,double xyz , double xyzdu , double *xyzdv )
77			{
78			OT_VECTEUR_3D localuu(-rayoncos(uv[1])cos(uv[0]),-rayoncos(uv[1])sin(uv[0]),0.);
79			OT_VECTEUR_3D localuv(rayonsin(uv[0])sin(uv[1]),-rayoncos(uv[0])sin(uv[1]),0.);
80			OT_VECTEUR_3D localvv(-rayoncos(uv[1])cos(uv[0]),-rayoncos(uv[1])sin(uv[0]),-rayon*sin(uv[1]));
81			OT_VECTEUR_3D globaluu=repere*localuu;
82			OT_VECTEUR_3D globaluv=repere*localuv;
83			OT_VECTEUR_3D globalvv=repere*localvv;
84			xyzduu[0]=globaluu.get_x();
85			xyzduu[1]=globaluu.get_y();
86			xyzduu[2]=globaluu.get_z();
87			xyzduv[0]=globaluv.get_x();
88			xyzduv[1]=globaluv.get_y();
89			xyzduv[2]=globaluv.get_z();
90			xyzdvv[0]=globalvv.get_x();
91			xyzdvv[1]=globalvv.get_y();
92			xyzdvv[2]=globalvv.get_z();
93			if ((xyzdu!=NULL) && (xyzdv!=NULL ) ) deriver(uv,xyzdu,xyzdv);
94			if (xyz!=NULL) evaluer(uv,xyz);
95			}
96			void ST_SPHERICAL::inverser(double uv,double xyz,double precision)
97			{
98			double sign;
99			OT_VECTEUR_3D global(xyz[0],xyz[1],xyz[2]);
100			OT_MATRICE_3D transpose_repere;
101			repere.transpose(transpose_repere);
102			OT_VECTEUR_3D vecteur=transpose_repere*(global-origine);
103			double valeur1;
104			valeur1=vecteur.get_z()/rayon;
105			if (valeur1>1) valeur1=1;
106			if (valeur1<-1) valeur1=-1;
107			uv[1]=asin(valeur1);
108			double valeur2;
109			valeur2=vecteur.get_x()/(rayon*cos(uv[1]));
110			if (valeur2>1) valeur2=1;
111			if (valeur2<-1) valeur2=-1;
112			uv[0]=acos(valeur2);
113			sign=vecteur.get_y()/(rayon*cos(uv[1]));
114			if (sign<-0.000001) uv[0]= 2.*M_PI-uv[0];
115			}
116			int ST_SPHERICAL::est_periodique_u(void)
117			{
118			return 1;
119			}
120			int ST_SPHERICAL::est_periodique_v(void)
121			{
122			return 0;
123			}
124			double ST_SPHERICAL::get_periode_u(void)
125			{
126			return 2.*M_PI;
127			}
128			double ST_SPHERICAL::get_periode_v(void)
129			{
130			return 0;
131			}
132			double ST_SPHERICAL::get_umin(void)
133			{
134			return 0.;
135			}
136			double ST_SPHERICAL::get_umax(void)
137			{
138			return 2.*M_PI;
139			}
140			double ST_SPHERICAL::get_vmin(void)
141			{
142			return -M_PI/2.;
143			}
144			double ST_SPHERICAL::get_vmax(void)
145			{
146			return M_PI/2.;
147			}
148
149			void ST_SPHERICAL::initialiser(ST_GESTIONNAIRE *gest)
150			{
151			ST_AXIS2_PLACEMENT_3D* axe=gest->lst_axis2_placement_3d.getid(id_axis2_placement_3d);
152			ST_DIRECTION* dirz=gest->lst_direction.getid(axe->get_id_direction1());
153			ST_DIRECTION* dirx=gest->lst_direction.getid(axe->get_id_direction2());
154			ST_POINT* point=gest->lst_point.getid(axe->get_id_point());
155			double xyz[3];
156			point->evaluer(xyz);
157			double *directz=dirz->get_direction();
158			double *directx=dirx->get_direction();
159			initialiser(xyz,directz,directx);
160			}
161
162
163			void ST_SPHERICAL::initialiser(double xyz,double dirz, double *dirx)
164			{
165			origine.change_x(xyz[0]);
166			origine.change_y(xyz[1]);
167			origine.change_z(xyz[2]);
168			double axez[3]={0.,0.,1.};
169			double axex[3]={1.,0.,0.};
170			if (dirz==NULL)
171			{
172			dirz=axez;
173			dirx=axex;
174			}
175			OT_VECTEUR_3D z(dirz[0],dirz[1],dirz[2]);
176			z.norme();
177			OT_VECTEUR_3D x(dirx[0],dirx[1],dirx[2]);
178			x.norme();
179			OT_VECTEUR_3D y=z&x;
180			repere.change_vecteur1(x);
181			repere.change_vecteur2(y);
182			repere.change_vecteur3(z);
183			}
184
185
186			int ST_SPHERICAL::get_type_geometrique(TPL_LISTE_ENTITE<double> &param)
187			{
188			param.ajouter(origine.get_x());
189			param.ajouter(origine.get_y());
190			param.ajouter(origine.get_z());
191			param.ajouter(rayon);
192			return MGCo_SPHERE;
193			}
194
195
196			void ST_SPHERICAL::est_util(ST_GESTIONNAIRE* gest)
197			{
198			util=true;
199			gest->lst_axis2_placement_3d.getid(id_axis2_placement_3d)->est_util(gest);
200			}
201
202
203
204	francois	19	void ST_SPHERICAL:: get_param_NURBS(int& indx_premier_ptctr,TPL_LISTE_ENTITE<double> &param)
205		5	{
206
207			// The first parameter indicate the code access
208			param.ajouter(2);
209
210			// The follewing two parameters of the list indicate the orders of the net points
211
212			param.ajouter(4);
213			param.ajouter(4);
214
215			// The follewing two parameters indicate the number of rows and colons of the control points
216			// respectively to the two parameters directions
217
218			param.ajouter(4);
219			param.ajouter(7);
220
221			// this present the knot vector in the u-direction
222			param.ajouter(0);
223			param.ajouter(0);
224			param.ajouter(0);
225			param.ajouter(0.5);
226			param.ajouter(1);
227			param.ajouter(1);
228			param.ajouter(1);
229
230	francois	19
231		5	// the following is the V_knots of the semicircle in the direction V
232			param.ajouter(0);
233			param.ajouter(0);
234			param.ajouter(0);
235	francois	19	param.ajouter(0.25);
236		5	param.ajouter(0.5);
237	francois	19	param.ajouter(0.5);
238			param.ajouter(0.75);
239		5	param.ajouter(1);
240			param.ajouter(1);
241			param.ajouter(1);
242
243	francois	19
244
245		5	// the weight of the controle point are given in this vecteur wi={1,0.5,0.5,1}
246			// Notice that the controle point at the north and south poles of the sphere
247			// are repeated sventh times P0,0=....=P6,0 and P0,3=....=P0,3
248
249			double xyz[3];
250			double w;
251			double rx=0.;
252			double ry=0.;
253			double rz=rayon;
254			//==========================================
255			//POLE 1
256			//==========================================
257			OT_VECTEUR_3D loc(0,0,rz);
258			OT_VECTEUR_3D glob=origine+repere*loc;
259
260			double pole1_x=glob.get_x();
261			double pole1_y=glob.get_y();
262			double pole1_z=glob.get_z();
263			//==========================================
264			//POLE 2
265			//==========================================
266			loc.change_z(-rz);
267			glob=origine+repere*loc;
268
269			double pole2_x=glob.get_x();
270			double pole2_y=glob.get_y();
271			double pole2_z=glob.get_z();
272			//==========================================
273
274			for(int v=0;v<7;v++)
275			{
276
277			switch (v){
278			case 0: {rx=rayon;ry=0;w=1; break;}
279			case 1: {rx=rayon;ry=rayon;w=0.5; break;}
280			case 2: {rx=-rayon;ry=rayon;w=0.5; break;}
281			case 3: {rx=-rayon;ry=0;w=1; break;}
282			case 4: {rx=-rayon;ry=-rayon;w=0.5; break;}
283			case 5: {rx=rayon;ry=-rayon;w=0.5; break;}
284			case 6: {rx=rayon;ry=0;w=1; break;}
285			}
286			//P0j
287			param.ajouter(pole1_x);
288			param.ajouter(pole1_y);
289			param.ajouter(pole1_z);
290			param.ajouter(1*w);
291
292			//P1j
293
294			loc.change_x(rx);
295			loc.change_y(ry);
296	francois	19	loc.change_z(pole1_z);
297		5
298			glob=origine+repere*loc;
299
300			xyz[0]=glob.get_x();
301			xyz[1]=glob.get_y();
302			xyz[2]=glob.get_z();
303
304			param.ajouter(xyz[0]);
305			param.ajouter(xyz[1]);
306			param.ajouter(xyz[2]);
307			param.ajouter(0.5*w);
308
309			//P2j
310
311	francois	19	loc.change_z(pole2_z);
312		5
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			//P3j
326
327			param.ajouter(pole2_x);
328			param.ajouter(pole2_y);
329			param.ajouter(pole2_z);
330			param.ajouter(1*w);
331
332
333			}
334
335	francois	19	indx_premier_ptctr=22;
336		5
337			}