sat/src/sat_plane.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)
//------------------------------------------------------------
//------------------------------------------------------------
//
//       sat_plane.cpp
//
//------------------------------------------------------------
//------------------------------------------------------------
//  COPYRIGHT 2000
//  Version du 02/03/2006 à 11H24
//------------------------------------------------------------
//------------------------------------------------------------


#include "gestionversion.h"
#include "sat_plane.h"
#include "constantegeo.h"
#include "ot_mathematique.h"


SAT_PLANE::SAT_PLANE(unsigned long num):SAT_SURFACE(num)
{
}

SAT_PLANE::SAT_PLANE():SAT_SURFACE()
{
}

SAT_PLANE::~SAT_PLANE()
{
}


void SAT_PLANE::calcule_parametre(void)
{
OT_VECTEUR_3D vec_normal(normal);
vec_normal.norme();
if (!(OPERATEUR::egal(vec_normal.get_x(),0.,0.0001)))
                {
                dir1[0]=vec_normal.get_y();
                dir1[1]=(-vec_normal.get_x());
                dir1[2]=0.;
                }
        else if (!(OPERATEUR::egal(vec_normal.get_y(),0.,0.0001)))
                {
                dir1[0]=0.;
                dir1[1]=(-vec_normal.get_z());
                dir1[2]=vec_normal.get_y();
                }
        else
                {
                dir1[0]=vec_normal.get_z();
                dir1[1]=0.;
                dir1[2]=0.;
                }
OT_VECTEUR_3D vec_dir1(dir1);
vec_dir1.norme();
OT_VECTEUR_3D vec_dir2=vec_normal&vec_dir1;
dir2[0]=vec_dir2.get_x();
dir2[1]=vec_dir2.get_y();
dir2[2]=vec_dir2.get_z();
}


void  SAT_PLANE::evaluer(double *uv,double *xyz)
{
xyz[0]=root[0]+uv[0]*dir1[0]+uv[1]*dir2[0];
xyz[1]=root[1]+uv[0]*dir1[1]+uv[1]*dir2[1];
xyz[2]=root[2]+uv[0]*dir1[2]+uv[1]*dir2[2];
}

void  SAT_PLANE::deriver(double *uv,double *xyzdu, double *xyzdv)
{
xyzdu[0]=dir1[0];
xyzdu[1]=dir1[1];
xyzdu[2]=dir1[2];
xyzdv[0]=dir2[0];
xyzdv[1]=dir2[1];
xyzdv[2]=dir2[2];
}

void  SAT_PLANE::deriver_seconde(double *uv,double* xyzduu,double* xyzduv,double* xyzdvv,double *xyz, double *xyzdu , double *xyzdv )
{
xyzduu[0]=0.;
xyzduu[1]=0.;
xyzduu[2]=0.;
xyzduv[0]=0.;
xyzduv[1]=0.;
xyzduv[2]=0.;
xyzdvv[0]=0.;
xyzdvv[1]=0.;
xyzdvv[2]=0.;
evaluer(uv,xyz);
deriver(uv,xyzdu,xyzdv);
}

void  SAT_PLANE::inverser(double *uv,double *xyz,double precision)
{
double coord[3];
int n1,n2;
coord[0]=xyz[0]-root[0];
coord[1]=xyz[1]-root[1];
coord[2]=xyz[2]-root[2];;
double det=dir1[0]*dir2[1]-dir1[1]*dir2[0];
if (!(OPERATEUR::egal(det,0.0,0.0001)))
        {
        n1=0;n2=1;
        }
else
        {
        det=dir1[0]*dir2[2]-dir1[2]*dir2[0];
        if (!(OPERATEUR::egal(det,0.0,0.0001)))
                {
                n1=0;n2=2;
                }
        else
                {
                n1=1;n2=2;
                det=dir1[1]*dir2[2]-dir1[2]*dir2[1];
                }
                }
        uv[0]=(coord[n1]*dir2[n2]-coord[n2]*dir2[n1])/det;
        uv[1]=(dir1[n1]*coord[n2]-dir1[n2]*coord[n1])/det;

}

int SAT_PLANE::est_periodique_u(void)
{
return 0;
}

int SAT_PLANE::est_periodique_v(void)
{
return 0;
}

double SAT_PLANE::get_periode_u(void)
{
return 0.;
}

double SAT_PLANE::get_periode_v(void)
{
return 0.;
}

double  SAT_PLANE::get_umin(void)
{
return -1e300;
}

double  SAT_PLANE::get_umax(void)
{
return 1e300;
}

double  SAT_PLANE::get_vmin(void)
{
return -1e300;
}

double  SAT_PLANE::get_vmax(void)
{
return 1e300;
}


int SAT_PLANE::get_type_geometrique(TPL_LISTE_ENTITE<double> &param)
{
param.ajouter(root[0]);
param.ajouter(root[1]);
param.ajouter(root[2]);
param.ajouter(normal[0]);
param.ajouter(normal[1]);
param.ajouter(normal[2]);
return MGCo_PLAN;
}


void SAT_PLANE::get_param_NURBS(TPL_LISTE_ENTITE<double> &param)
{

// For a plan the net controls point is
double uv[2];
double xyz[3];

// 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(2);
param.ajouter(2);

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

param.ajouter(2);
param.ajouter(2);

// this present the knot vector in the u-direction

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

// this present the knot vector in the v-direction

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

// note that the cordinate of the control points are given in the homogeneous cordinates


double inf_val=10e6;

// this is the firt control point with cordinate (+inf,+inf)

xyz[0]=root[0]+inf_val*dir1[0]+inf_val*dir2[0];
xyz[1]=root[1]+inf_val*dir1[1]+inf_val*dir2[1];
xyz[2]=root[2]+inf_val*dir1[2]+inf_val*dir2[2];

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


// this is the second control point with cordinate (-inf,+inf)

xyz[0]=root[0]-inf_val*dir1[0]+inf_val*dir2[0];
xyz[1]=root[1]-inf_val*dir1[1]+inf_val*dir2[1];
xyz[2]=root[2]-inf_val*dir1[2]+inf_val*dir2[2];

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


// this is the third control point with cordinate (-inf,-inf)

xyz[0]=root[0]-inf_val*dir1[0]-inf_val*dir2[0];
xyz[1]=root[1]-inf_val*dir1[1]-inf_val*dir2[1];
xyz[2]=root[2]-inf_val*dir1[2]-inf_val*dir2[2];

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

// this is the second control point with cordinate (inf,-inf)

xyz[0]=root[0]+inf_val*dir1[0]-inf_val*dir2[0];
xyz[1]=root[1]+inf_val*dir1[1]-inf_val*dir2[1];
xyz[2]=root[2]+inf_val*dir1[2]-inf_val*dir2[2];

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


}
Revision:	5
Committed:	Tue Jun 12 20:26:34 2007 UTC (17 years, 11 months ago)
Original Path:	*magic/lib/sat/sat/src/sat_plane.cpp*
File size:	6141 byte(s)
Log Message:
#	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		// sat_plane.cpp
16		//
17		//------------------------------------------------------------
18		//------------------------------------------------------------
19		// COPYRIGHT 2000
20		// Version du 02/03/2006 à 11H24
21		//------------------------------------------------------------
22		//------------------------------------------------------------
23
24
25		#include "gestionversion.h"
26		#include "sat_plane.h"
27		#include "constantegeo.h"
28		#include "ot_mathematique.h"
29
30
31		SAT_PLANE::SAT_PLANE(unsigned long num):SAT_SURFACE(num)
32		{
33		}
34
35		SAT_PLANE::SAT_PLANE():SAT_SURFACE()
36		{
37		}
38
39		SAT_PLANE::~SAT_PLANE()
40		{
41		}
42
43
44
45		void SAT_PLANE::calcule_parametre(void)
46		{
47		OT_VECTEUR_3D vec_normal(normal);
48		vec_normal.norme();
49		if (!(OPERATEUR::egal(vec_normal.get_x(),0.,0.0001)))
50		{
51		dir1[0]=vec_normal.get_y();
52		dir1[1]=(-vec_normal.get_x());
53		dir1[2]=0.;
54		}
55		else if (!(OPERATEUR::egal(vec_normal.get_y(),0.,0.0001)))
56		{
57		dir1[0]=0.;
58		dir1[1]=(-vec_normal.get_z());
59		dir1[2]=vec_normal.get_y();
60		}
61		else
62		{
63		dir1[0]=vec_normal.get_z();
64		dir1[1]=0.;
65		dir1[2]=0.;
66		}
67		OT_VECTEUR_3D vec_dir1(dir1);
68		vec_dir1.norme();
69		OT_VECTEUR_3D vec_dir2=vec_normal&vec_dir1;
70		dir2[0]=vec_dir2.get_x();
71		dir2[1]=vec_dir2.get_y();
72		dir2[2]=vec_dir2.get_z();
73		}
74
75
76		void SAT_PLANE::evaluer(double uv,double xyz)
77		{
78		xyz[0]=root[0]+uv[0]dir1[0]+uv[1]dir2[0];
79		xyz[1]=root[1]+uv[0]dir1[1]+uv[1]dir2[1];
80		xyz[2]=root[2]+uv[0]dir1[2]+uv[1]dir2[2];
81		}
82
83		void SAT_PLANE::deriver(double uv,double xyzdu, double *xyzdv)
84		{
85		xyzdu[0]=dir1[0];
86		xyzdu[1]=dir1[1];
87		xyzdu[2]=dir1[2];
88		xyzdv[0]=dir2[0];
89		xyzdv[1]=dir2[1];
90		xyzdv[2]=dir2[2];
91		}
92
93		void SAT_PLANE::deriver_seconde(double uv,double xyzduu,double* xyzduv,double* xyzdvv,double xyz, double xyzdu , double *xyzdv )
94		{
95		xyzduu[0]=0.;
96		xyzduu[1]=0.;
97		xyzduu[2]=0.;
98		xyzduv[0]=0.;
99		xyzduv[1]=0.;
100		xyzduv[2]=0.;
101		xyzdvv[0]=0.;
102		xyzdvv[1]=0.;
103		xyzdvv[2]=0.;
104		evaluer(uv,xyz);
105		deriver(uv,xyzdu,xyzdv);
106		}
107
108		void SAT_PLANE::inverser(double uv,double xyz,double precision)
109		{
110		double coord[3];
111		int n1,n2;
112		coord[0]=xyz[0]-root[0];
113		coord[1]=xyz[1]-root[1];
114		coord[2]=xyz[2]-root[2];;
115		double det=dir1[0]dir2[1]-dir1[1]dir2[0];
116		if (!(OPERATEUR::egal(det,0.0,0.0001)))
117		{
118		n1=0;n2=1;
119		}
120		else
121		{
122		det=dir1[0]dir2[2]-dir1[2]dir2[0];
123		if (!(OPERATEUR::egal(det,0.0,0.0001)))
124		{
125		n1=0;n2=2;
126		}
127		else
128		{
129		n1=1;n2=2;
130		det=dir1[1]dir2[2]-dir1[2]dir2[1];
131		}
132		}
133		uv[0]=(coord[n1]dir2[n2]-coord[n2]dir2[n1])/det;
134		uv[1]=(dir1[n1]coord[n2]-dir1[n2]coord[n1])/det;
135
136		}
137
138		int SAT_PLANE::est_periodique_u(void)
139		{
140		return 0;
141		}
142
143		int SAT_PLANE::est_periodique_v(void)
144		{
145		return 0;
146		}
147
148		double SAT_PLANE::get_periode_u(void)
149		{
150		return 0.;
151		}
152
153		double SAT_PLANE::get_periode_v(void)
154		{
155		return 0.;
156		}
157
158		double SAT_PLANE::get_umin(void)
159		{
160		return -1e300;
161		}
162
163		double SAT_PLANE::get_umax(void)
164		{
165		return 1e300;
166		}
167
168		double SAT_PLANE::get_vmin(void)
169		{
170		return -1e300;
171		}
172
173		double SAT_PLANE::get_vmax(void)
174		{
175		return 1e300;
176		}
177
178
179		int SAT_PLANE::get_type_geometrique(TPL_LISTE_ENTITE<double> &param)
180		{
181		param.ajouter(root[0]);
182		param.ajouter(root[1]);
183		param.ajouter(root[2]);
184		param.ajouter(normal[0]);
185		param.ajouter(normal[1]);
186		param.ajouter(normal[2]);
187		return MGCo_PLAN;
188		}
189
190
191
192		void SAT_PLANE::get_param_NURBS(TPL_LISTE_ENTITE<double> &param)
193		{
194
195		// For a plan the net controls point is
196		double uv[2];
197		double xyz[3];
198
199		// The first parameter indicate the code access
200		param.ajouter(2);
201		// The follewing two parameters of the list indicate the orders of the net points
202
203		param.ajouter(2);
204		param.ajouter(2);
205
206		// The follewing two parameters indicate the number of rows and colons of the control points
207		// respectively to the two parameters directions
208
209		param.ajouter(2);
210		param.ajouter(2);
211
212		// this present the knot vector in the u-direction
213
214		param.ajouter(0);
215		param.ajouter(0);
216		param.ajouter(1);
217		param.ajouter(1);
218
219		// this present the knot vector in the v-direction
220
221		param.ajouter(0);
222		param.ajouter(0);
223		param.ajouter(1);
224		param.ajouter(1);
225
226		// note that the cordinate of the control points are given in the homogeneous cordinates
227
228
229		double inf_val=10e6;
230
231		// this is the firt control point with cordinate (+inf,+inf)
232
233		xyz[0]=root[0]+inf_valdir1[0]+inf_valdir2[0];
234		xyz[1]=root[1]+inf_valdir1[1]+inf_valdir2[1];
235		xyz[2]=root[2]+inf_valdir1[2]+inf_valdir2[2];
236
237		param.ajouter(xyz[0]);
238		param.ajouter(xyz[1]);
239		param.ajouter(xyz[2]);
240		param.ajouter(0);
241
242
243		// this is the second control point with cordinate (-inf,+inf)
244
245		xyz[0]=root[0]-inf_valdir1[0]+inf_valdir2[0];
246		xyz[1]=root[1]-inf_valdir1[1]+inf_valdir2[1];
247		xyz[2]=root[2]-inf_valdir1[2]+inf_valdir2[2];
248
249		param.ajouter(xyz[0]);
250		param.ajouter(xyz[1]);
251		param.ajouter(xyz[2]);
252		param.ajouter(0);
253
254
255		// this is the third control point with cordinate (-inf,-inf)
256
257		xyz[0]=root[0]-inf_valdir1[0]-inf_valdir2[0];
258		xyz[1]=root[1]-inf_valdir1[1]-inf_valdir2[1];
259		xyz[2]=root[2]-inf_valdir1[2]-inf_valdir2[2];
260
261		param.ajouter(xyz[0]);
262		param.ajouter(xyz[1]);
263		param.ajouter(xyz[2]);
264		param.ajouter(0);
265
266		// this is the second control point with cordinate (inf,-inf)
267
268		xyz[0]=root[0]+inf_valdir1[0]-inf_valdir2[0];
269		xyz[1]=root[1]+inf_valdir1[1]-inf_valdir2[1];
270		xyz[2]=root[2]+inf_valdir1[2]-inf_valdir2[2];
271
272		param.ajouter(xyz[0]);
273		param.ajouter(xyz[1]);
274		param.ajouter(xyz[2]);
275		param.ajouter(0);
276
277
278		}