step/src/stspherical.cpp

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  MAGiC
//####//  Jean Christophe Cuilliere et Vincent FRANCOIS
//####//  Departement de Genie Mecanique - UQTR
//####//------------------------------------------------------------
//####//  MAGIC est un projet de recherche de l equipe ERICCA
//####//  du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
//####//  http://www.uqtr.ca/ericca
//####//  http://www.uqtr.ca/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       stspherical.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:53:59 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------


#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 GEOMETRIE::CONST::Co_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)
{

    param.ajouter(2);


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


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

    param.ajouter(0);
    param.ajouter(0);
    param.ajouter(0);
    param.ajouter(0.5);
    param.ajouter(1);
    param.ajouter(1);
    param.ajouter(1);


    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);


    double xyz[3];
    double w;
    double rx=0.;
    double ry=0.;
    double rz=rayon;
    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();
    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;
        }
        }
        param.ajouter(pole1_x);
        param.ajouter(pole1_y);
        param.ajouter(pole1_z);
        param.ajouter(1*w);


        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);


        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);


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


    }

    indx_premier_ptctr=22;

}
Revision:	1156
Committed:	Thu Jun 13 22:02:48 2024 UTC (14 months ago) by francois
File size:	8749 byte(s)
Log Message:	compatibilité Ubuntu 22.04 Suppression des refeences à Windows Ajout d'une banière
#	User	Rev	Content
1	francois	1156	//####//------------------------------------------------------------
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	francois	283
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(rayoncos(uv[1])cos(uv[0]),rayoncos(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(-rayonsin(uv[0])cos(uv[1]),rayoncos(uv[0])cos(uv[1]),0.);
64			OT_VECTEUR_3D localv(-rayonsin(uv[1])cos(uv[0]),-rayonsin(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(-rayoncos(uv[1])cos(uv[0]),-rayoncos(uv[1])sin(uv[0]),0.);
77			OT_VECTEUR_3D localuv(rayonsin(uv[0])sin(uv[1]),-rayoncos(uv[0])sin(uv[1]),0.);
78			OT_VECTEUR_3D localvv(-rayoncos(uv[1])cos(uv[0]),-rayoncos(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	francois	1149	return GEOMETRIE::CONST::Co_SPHERE;
191	francois	283	}
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			}