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:	283
Committed:	Tue Sep 13 21:11:20 2011 UTC (13 years, 8 months ago) by francois
File size:	9581 byte(s)
Log Message:	structure de l'écriture
#	User	Rev	Content
1	francois	283	//------------------------------------------------------------
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			void ST_SPHERICAL:: get_param_NURBS(int& indx_premier_ptctr,TPL_LISTE_ENTITE<double> &param)
205			{
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
231			// 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			param.ajouter(0.25);
236			param.ajouter(0.5);
237			param.ajouter(0.5);
238			param.ajouter(0.75);
239			param.ajouter(1);
240			param.ajouter(1);
241			param.ajouter(1);
242
243
244
245			// 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: {
279			rx=rayon;
280			ry=0;
281			w=1;
282			break;
283			}
284			case 1: {
285			rx=rayon;
286			ry=rayon;
287			w=0.5;
288			break;
289			}
290			case 2: {
291			rx=-rayon;
292			ry=rayon;
293			w=0.5;
294			break;
295			}
296			case 3: {
297			rx=-rayon;
298			ry=0;
299			w=1;
300			break;
301			}
302			case 4: {
303			rx=-rayon;
304			ry=-rayon;
305			w=0.5;
306			break;
307			}
308			case 5: {
309			rx=rayon;
310			ry=-rayon;
311			w=0.5;
312			break;
313			}
314			case 6: {
315			rx=rayon;
316			ry=0;
317			w=1;
318			break;
319			}
320			}
321			//P0j
322			param.ajouter(pole1_x);
323			param.ajouter(pole1_y);
324			param.ajouter(pole1_z);
325			param.ajouter(1*w);
326
327			//P1j
328
329			loc.change_x(rx);
330			loc.change_y(ry);
331			loc.change_z(pole1_z);
332
333			glob=origine+repere*loc;
334
335			xyz[0]=glob.get_x();
336			xyz[1]=glob.get_y();
337			xyz[2]=glob.get_z();
338
339			param.ajouter(xyz[0]);
340			param.ajouter(xyz[1]);
341			param.ajouter(xyz[2]);
342			param.ajouter(0.5*w);
343
344			//P2j
345
346			loc.change_z(pole2_z);
347
348			glob=origine+repere*loc;
349
350			xyz[0]=glob.get_x();
351			xyz[1]=glob.get_y();
352			xyz[2]=glob.get_z();
353
354			param.ajouter(xyz[0]);
355			param.ajouter(xyz[1]);
356			param.ajouter(xyz[2]);
357			param.ajouter(0.5*w);
358
359
360			//P3j
361
362			param.ajouter(pole2_x);
363			param.ajouter(pole2_y);
364			param.ajouter(pole2_z);
365			param.ajouter(1*w);
366
367
368			}
369
370			indx_premier_ptctr=22;
371
372			}