geometrie/src/sld_surface.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)
//------------------------------------------------------------
//------------------------------------------------------------
//
//       sld_surface.cpp
//
//------------------------------------------------------------
//------------------------------------------------------------
//  COPYRIGHT 2000
//  Version du 02/03/2006 à 11H22
//------------------------------------------------------------
//------------------------------------------------------------


#include "gestionversion.h"

#ifdef BREP_SLD

#include "mg_surface.h"
#include "sld_surface.h"
#include <system.hpp>
#include <atl\atlmod.h>
#include "smartvars.h"
//#include <clx.h>
#include "sld_fonction.h"
#include "stplane.h"
#include "stcylindrical.h"
#include "stconical.h"
#include "stspherical.h"
#include "sttoroidal.h"
#include "stbsplines.h"


//TComModule& _Module=*static_cast<TComModule*>(NULL);

SLD_SURFACE::SLD_SURFACE(unsigned long num,string idface,SLD_FONCTION& fonc):MG_SURFACE(num),fonction(fonc)
{
initialisation(idface);
}


SLD_SURFACE::SLD_SURFACE(string idface,SLD_FONCTION& fonc):MG_SURFACE(),fonction(fonc)
{
initialisation(idface);
}

SLD_SURFACE::SLD_SURFACE(string idface, SLD_FONCTION& fonc, CComPtr < IFace2 > & p_swFace) : MG_SURFACE(), swFace(p_swFace), fonction(fonc)
{                       
swFace->IGetSurface(&swSurface);
initialisation();
}

void SLD_SURFACE::initialisation(string idface)
{
idoriginal=idface;
fonction.GetParID((char*)idface.c_str(),swFace);
swFace->IGetSurface(&swSurface);
initialisation();
}

void SLD_SURFACE::initialisation()
{
CComVariant vparam;
swSurface->Parameterization( &vparam);
SafeDoubleArray saparam(vparam);
u_min=saparam[0];
u_max=saparam[1];
v_min=saparam[2];
v_max=saparam[3];
stsurface=NULL;
VARIANT_BOOL retval;
swSurface->IsPlane(&retval);
if (retval==1)
        {
        CComVariant vRetval;
        vRetval=swSurface->get_PlaneParams();
        SafeDoubleArray sda(vRetval);
        double origine[3];
        double dir[3];
        origine[0]=sda[3];
        origine[1]=sda[4];
        origine[2]=sda[5];
        dir[0]=sda[0];
        dir[1]=sda[1];
        dir[2]=sda[2];
        stsurface=new ST_PLANE(origine,dir);
        return;
        }
swSurface->IsCylinder(&retval);
if (retval==1)
        {
        CComVariant vRetval;
        vRetval=swSurface->get_CylinderParams();
        SafeDoubleArray sda(vRetval);
        double origine[3];
        double dir[3];
        origine[0]=sda[0];
        origine[1]=sda[1];
        origine[2]=sda[2];
        dir[0]=sda[3];
        dir[1]=sda[4];
        dir[2]=sda[5];
        double rayon=sda[6];
        stsurface=new ST_CYLINDRICAL(origine,dir,NULL,rayon);
        return;
        }
swSurface->IsCone(&retval);
if (retval==1)
        {
        CComVariant vRetval;
        vRetval=swSurface->get_ConeParams();
        SafeDoubleArray sda(vRetval);
        double origine[3];
        double dir[3];
        origine[0]=sda[0];
        origine[1]=sda[1];
        origine[2]=sda[2];
        dir[0]=-sda[3];
        dir[1]=-sda[4];
        dir[2]=-sda[5];
        double rayon=sda[6];
        double angle=sda[7];
        stsurface=new ST_CONICAL(origine,dir,NULL,rayon,angle);
        return;
        }
swSurface->IsSphere(&retval);
if (retval==1)
        {
        CComVariant vRetval;
        vRetval=swSurface->get_SphereParams() ;
        SafeDoubleArray sda(vRetval);
        double origine[3];
        origine[0]=sda[0];
        origine[1]=sda[1];
        origine[2]=sda[2];
        double rayon=sda[3];
        stsurface=new ST_SPHERICAL(origine,NULL,NULL,rayon);
        return;
        }
swSurface->IsTorus(&retval) ;
if (retval==1)
        {
        CComVariant vRetval;
        vRetval=swSurface->get_TorusParams();
        SafeDoubleArray sda(vRetval);
        double origine[3];
        double dir[3];
        origine[0]=sda[0];
        origine[1]=sda[1];
        origine[2]=sda[2];
        dir[0]=sda[3];
        dir[1]=sda[4];
        dir[2]=sda[5];
        double grayon=sda[6];
        double prayon=sda[7];
        stsurface=new ST_TOROIDAL(origine,dir,grayon,prayon);
        return;
        }
VARIANT vRetval;
VARIANT_BOOL sense;
VARIANT vp0;
vp0=swFace->GetUVBounds();
double  tolerance = fonction.GetValeurTolerance() ;
swSurface->GetBSurfParams2(false,false,vp0,tolerance,&sense,&vRetval);
SafeDoubleArray sda(vRetval);
int uordre,vordre;
int numcpt,numlpt;
int uperiodic,vperiodic;
int dim,dummy;
OPERATEUR::doubleto2int(sda[0],uordre,vordre);
OPERATEUR::doubleto2int(sda[1],numcpt,numlpt);
OPERATEUR::doubleto2int(sda[2],uperiodic,vperiodic);
OPERATEUR::doubleto2int(sda[3],dim,dummy);
vector<double> knots_u;
vector<double> knots_v;
vector<double> poids;
vector<double> ptsctr;
for (int i=0;i<uordre+numcpt;i++)
        knots_u.insert(knots_u.end(),sda[4+i]);
for (int i=0;i<vordre+numlpt;i++)
        knots_v.insert(knots_v.end(),sda[4+uordre+numcpt+i]);
for (int i=0;i<numcpt;i++)
        for (int j=0;j<numlpt;j++)
        {
        int num=j*numcpt+i;
        ptsctr.insert(ptsctr.end(),sda[4+uordre+numcpt+vordre+numlpt+dim*num]);
        ptsctr.insert(ptsctr.end(),sda[4+uordre+numcpt+vordre+numlpt+dim*num+1]);
        ptsctr.insert(ptsctr.end(),sda[4+uordre+numcpt+vordre+numlpt+dim*num+2]);
        if (dim==4) poids.insert(poids.end(),sda[4+uordre+numcpt+vordre+numlpt+dim*num+3]);
        else poids.insert(poids.end(),1.);
        }
int sens;
sens=1;
stsurface=new ST_B_SPLINE_SURF(uordre-1,vordre-1,knots_u,knots_v,ptsctr,poids,sens);
// Gilles: J'ai rencontré le cas d'une surface NURBS dont ST_BSPLINE_SURF
// ne détecte pas la périodicité: le critère de périodicité de ST_BSPLINE_SURF est
// l'égalité des points de controle pour umin/umax ou vmin/vmax
// résultat: imposibilité de mailler 
//
// j'ai préféré corriger en ajoutant la méthode set_periodique_u() à ST_BSPLINE_SURF
// afin d'utiliser les informations de périodicité données explicitement par
// SolidWorks
((ST_B_SPLINE_SURF*) stsurface)->set_periodique_u( uperiodic );
((ST_B_SPLINE_SURF*) stsurface)->set_periodique_v( vperiodic );
};


SLD_SURFACE::~SLD_SURFACE()
{                                     
if (swFace.p != NULL) swFace.p = NULL;
if (swSurface.p != NULL) swSurface.p = NULL;
if (stsurface!=NULL) delete stsurface;
}

void  SLD_SURFACE::evaluer(double *uv,double *xyz)
{
if (stsurface!=NULL)
        {
        stsurface->evaluer(uv,xyz);
        return;
        }
//entrée
 double UParam=uv[0];
 double VParam=uv[1];
 long NumUDeriv=0;
 long NumVDeriv=0;
//sortie
 CComVariant vretval;

swSurface->Evaluate ( UParam, VParam, NumUDeriv, NumVDeriv, &vretval);
 SafeDoubleArray saretval(vretval);
 //notre résultat
xyz[0]=saretval[0];
xyz[1]=saretval[1];
xyz[2]=saretval[2];
}

void  SLD_SURFACE::deriver(double *uv,double *xyzdu, double *xyzdv)
{
if (stsurface!=NULL)
        {
        stsurface->deriver(uv,xyzdu,xyzdv);
        return;
        }
//entrée
 double UParam=uv[0];
 double VParam=uv[1];
 long NumUDeriv=1;
 long NumVDeriv=1;
//sortie
 CComVariant vretval;

swSurface->Evaluate ( UParam, VParam, NumUDeriv, NumVDeriv, &vretval);
SafeDoubleArray saretval(vretval);
xyzdu[0]=saretval[3];
xyzdu[1]=saretval[4];
xyzdu[2]=saretval[5];
xyzdv[0]=saretval[6];
xyzdv[1]=saretval[7];
xyzdv[2]=saretval[8];
}

void  SLD_SURFACE::deriver_seconde(double *uv,double* xyzduu,double* xyzduv,double* xyzdvv,double *xyz, double *xyzdu, double *xyzdv)
{
if (stsurface!=NULL)
        {
        stsurface->deriver_seconde(uv,xyzduu,xyzduv,xyzdvv,xyz,xyzdu,xyzdv);
        return;
        }
//entrée
 double UParam=uv[0];
 double VParam=uv[1];
 long NumUDeriv=2;
 long NumVDeriv=2;
//sortie
 CComVariant vretval;

swSurface->Evaluate ( UParam, VParam, NumUDeriv, NumVDeriv, &vretval);
 SafeDoubleArray saretval(vretval);
// virtual void  deriver_seconde(double *uv,double* xyzduu,double* xyzduv,double* xyzdvv,
//double *xyz = NULL , double *xyzdu = NULL , double *xyzdv =NULL);
if(xyz!=NULL)    //or xyz~=NULL
        {
        xyz[0]=saretval[0];
        xyz[1]=saretval[1];
        xyz[2]=saretval[2];
        }
if(xyzdu!= NULL)
        {
        xyzdu[0]=saretval[3];
        xyzdu[1]=saretval[4];
        xyzdu[2]=saretval[5];
        }
if(xyzdv!=NULL)
        {
        xyzdv[0]=saretval[9];
        xyzdv[1]=saretval[10];
        xyzdv[2]=saretval[11];
        }
//affectation normale
xyzduu[0]=saretval[6];
xyzduu[1]=saretval[7];
xyzduu[2]=saretval[8];
xyzduv[0]=saretval[12];
xyzduv[1]=saretval[13];
xyzduv[2]=saretval[14];
xyzdvv[0]=saretval[18];
xyzdvv[1]=saretval[19];
xyzdvv[2]=saretval[20];
}

void  SLD_SURFACE::inverser(double* uv,double *xyz,double precision)
{//Paramètre précision
if (stsurface!=NULL)
        {
        stsurface->inverser(uv,xyz,precision);
        return;
        }
CComVariant vUV;
swSurface->ReverseEvaluate(xyz[0], xyz[1], xyz[2], &vUV);
SafeDoubleArray saUV(vUV);
uv[0] = saUV[0];
uv[1] = saUV[1];
}

int SLD_SURFACE::est_periodique_u(void)
{
    return stsurface->est_periodique_u();
}

int SLD_SURFACE::est_periodique_v(void)
{
    return stsurface->est_periodique_v();
}

double SLD_SURFACE::get_periode_u(void)
{
    return stsurface->get_periode_u();
}

double SLD_SURFACE::get_periode_v(void)
{
    return stsurface->get_periode_v();
}

double  SLD_SURFACE::get_umin()
{
    if (stsurface != NULL)
        return stsurface->get_umin();
    return u_min;
}

double  SLD_SURFACE::get_umax()
{
    if (stsurface != NULL)
        return stsurface->get_umax();
    return u_max;
}

double  SLD_SURFACE::get_vmin()
{
    if (stsurface != NULL)
        return stsurface->get_vmin();
    return v_min;
}

double  SLD_SURFACE::get_vmax()
{
    if (stsurface != NULL)
        return stsurface->get_vmax();
    return v_max;
}

void  SLD_SURFACE::enregistrer(ostream& o)
{
o << "%" << get_id() << "=SURFACE_SLD("<< idoriginal.c_str() << ");" << endl;
}


int SLD_SURFACE::get_type_geometrique(TPL_LISTE_ENTITE<double> &param)
{
if (stsurface!=NULL)
        return stsurface->get_type_geometrique(param);;
return 0;
}


void SLD_SURFACE::get_param_NURBS(int& indx_premier_ptctr,TPL_LISTE_ENTITE<double> &param)
{
stsurface->get_param_NURBS(indx_premier_ptctr,param);
}


#endif


Revision:	27
Committed:	Thu Jul 5 15:26:40 2007 UTC (17 years, 10 months ago) by foucault
Original Path:	*magic/lib/geometrie/geometrie/src/sld_surface.cpp*
File size:	11065 byte(s)
Log Message:
#	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			// sld_surface.cpp
16			//
17			//------------------------------------------------------------
18			//------------------------------------------------------------
19			// COPYRIGHT 2000
20			// Version du 02/03/2006 à 11H22
21			//------------------------------------------------------------
22			//------------------------------------------------------------
23
24
25			#include "gestionversion.h"
26
27			#ifdef BREP_SLD
28
29			#include "mg_surface.h"
30			#include "sld_surface.h"
31			#include <system.hpp>
32			#include <atl\atlmod.h>
33			#include "smartvars.h"
34			//#include <clx.h>
35			#include "sld_fonction.h"
36			#include "stplane.h"
37			#include "stcylindrical.h"
38			#include "stconical.h"
39			#include "stspherical.h"
40			#include "sttoroidal.h"
41			#include "stbsplines.h"
42
43
44			//TComModule& _Module=static_cast<TComModule>(NULL);
45
46			SLD_SURFACE::SLD_SURFACE(unsigned long num,string idface,SLD_FONCTION& fonc):MG_SURFACE(num),fonction(fonc)
47			{
48			initialisation(idface);
49			}
50
51
52			SLD_SURFACE::SLD_SURFACE(string idface,SLD_FONCTION& fonc):MG_SURFACE(),fonction(fonc)
53			{
54			initialisation(idface);
55			}
56
57	foucault	27	SLD_SURFACE::SLD_SURFACE(string idface, SLD_FONCTION& fonc, CComPtr < IFace2 > & p_swFace) : MG_SURFACE(), swFace(p_swFace), fonction(fonc)
58			{
59			swFace->IGetSurface(&swSurface);
60			initialisation();
61			}
62
63		5	void SLD_SURFACE::initialisation(string idface)
64			{
65			idoriginal=idface;
66			fonction.GetParID((char*)idface.c_str(),swFace);
67			swFace->IGetSurface(&swSurface);
68	foucault	27	initialisation();
69			}
70
71			void SLD_SURFACE::initialisation()
72			{
73		5	CComVariant vparam;
74			swSurface->Parameterization( &vparam);
75			SafeDoubleArray saparam(vparam);
76			u_min=saparam[0];
77			u_max=saparam[1];
78			v_min=saparam[2];
79			v_max=saparam[3];
80			stsurface=NULL;
81			VARIANT_BOOL retval;
82			swSurface->IsPlane(&retval);
83			if (retval==1)
84			{
85			CComVariant vRetval;
86			vRetval=swSurface->get_PlaneParams();
87			SafeDoubleArray sda(vRetval);
88			double origine[3];
89			double dir[3];
90			origine[0]=sda[3];
91			origine[1]=sda[4];
92			origine[2]=sda[5];
93			dir[0]=sda[0];
94			dir[1]=sda[1];
95			dir[2]=sda[2];
96			stsurface=new ST_PLANE(origine,dir);
97			return;
98			}
99			swSurface->IsCylinder(&retval);
100			if (retval==1)
101			{
102			CComVariant vRetval;
103			vRetval=swSurface->get_CylinderParams();
104			SafeDoubleArray sda(vRetval);
105			double origine[3];
106			double dir[3];
107			origine[0]=sda[0];
108			origine[1]=sda[1];
109			origine[2]=sda[2];
110			dir[0]=sda[3];
111			dir[1]=sda[4];
112			dir[2]=sda[5];
113			double rayon=sda[6];
114			stsurface=new ST_CYLINDRICAL(origine,dir,NULL,rayon);
115			return;
116			}
117			swSurface->IsCone(&retval);
118			if (retval==1)
119			{
120			CComVariant vRetval;
121			vRetval=swSurface->get_ConeParams();
122			SafeDoubleArray sda(vRetval);
123			double origine[3];
124			double dir[3];
125			origine[0]=sda[0];
126			origine[1]=sda[1];
127			origine[2]=sda[2];
128			dir[0]=-sda[3];
129			dir[1]=-sda[4];
130			dir[2]=-sda[5];
131			double rayon=sda[6];
132			double angle=sda[7];
133			stsurface=new ST_CONICAL(origine,dir,NULL,rayon,angle);
134			return;
135			}
136			swSurface->IsSphere(&retval);
137			if (retval==1)
138			{
139			CComVariant vRetval;
140			vRetval=swSurface->get_SphereParams() ;
141			SafeDoubleArray sda(vRetval);
142			double origine[3];
143			origine[0]=sda[0];
144			origine[1]=sda[1];
145			origine[2]=sda[2];
146			double rayon=sda[3];
147			stsurface=new ST_SPHERICAL(origine,NULL,NULL,rayon);
148			return;
149			}
150			swSurface->IsTorus(&retval) ;
151			if (retval==1)
152			{
153			CComVariant vRetval;
154			vRetval=swSurface->get_TorusParams();
155			SafeDoubleArray sda(vRetval);
156			double origine[3];
157			double dir[3];
158			origine[0]=sda[0];
159			origine[1]=sda[1];
160			origine[2]=sda[2];
161			dir[0]=sda[3];
162			dir[1]=sda[4];
163			dir[2]=sda[5];
164			double grayon=sda[6];
165			double prayon=sda[7];
166			stsurface=new ST_TOROIDAL(origine,dir,grayon,prayon);
167			return;
168			}
169			VARIANT vRetval;
170			VARIANT_BOOL sense;
171			VARIANT vp0;
172			vp0=swFace->GetUVBounds();
173	bournival	24	double tolerance = fonction.GetValeurTolerance() ;
174			swSurface->GetBSurfParams2(false,false,vp0,tolerance,&sense,&vRetval);
175		5	SafeDoubleArray sda(vRetval);
176			int uordre,vordre;
177			int numcpt,numlpt;
178	foucault	27	int uperiodic,vperiodic;
179		5	int dim,dummy;
180			OPERATEUR::doubleto2int(sda[0],uordre,vordre);
181			OPERATEUR::doubleto2int(sda[1],numcpt,numlpt);
182	foucault	27	OPERATEUR::doubleto2int(sda[2],uperiodic,vperiodic);
183		5	OPERATEUR::doubleto2int(sda[3],dim,dummy);
184			vector<double> knots_u;
185			vector<double> knots_v;
186			vector<double> poids;
187			vector<double> ptsctr;
188			for (int i=0;i<uordre+numcpt;i++)
189			knots_u.insert(knots_u.end(),sda[4+i]);
190			for (int i=0;i<vordre+numlpt;i++)
191			knots_v.insert(knots_v.end(),sda[4+uordre+numcpt+i]);
192			for (int i=0;i<numcpt;i++)
193			for (int j=0;j<numlpt;j++)
194			{
195			int num=j*numcpt+i;
196			ptsctr.insert(ptsctr.end(),sda[4+uordre+numcpt+vordre+numlpt+dim*num]);
197			ptsctr.insert(ptsctr.end(),sda[4+uordre+numcpt+vordre+numlpt+dim*num+1]);
198			ptsctr.insert(ptsctr.end(),sda[4+uordre+numcpt+vordre+numlpt+dim*num+2]);
199			if (dim==4) poids.insert(poids.end(),sda[4+uordre+numcpt+vordre+numlpt+dim*num+3]);
200			else poids.insert(poids.end(),1.);
201			}
202			int sens;
203			sens=1;
204			stsurface=new ST_B_SPLINE_SURF(uordre-1,vordre-1,knots_u,knots_v,ptsctr,poids,sens);
205	foucault	27	// Gilles: J'ai rencontré le cas d'une surface NURBS dont ST_BSPLINE_SURF
206			// ne détecte pas la périodicité: le critère de périodicité de ST_BSPLINE_SURF est
207			// l'égalité des points de controle pour umin/umax ou vmin/vmax
208			// résultat: imposibilité de mailler
209			//
210			// j'ai préféré corriger en ajoutant la méthode set_periodique_u() à ST_BSPLINE_SURF
211			// afin d'utiliser les informations de périodicité données explicitement par
212			// SolidWorks
213			((ST_B_SPLINE_SURF*) stsurface)->set_periodique_u( uperiodic );
214			((ST_B_SPLINE_SURF*) stsurface)->set_periodique_v( vperiodic );
215		5	};
216
217
218			SLD_SURFACE::~SLD_SURFACE()
219	foucault	27	{
220			if (swFace.p != NULL) swFace.p = NULL;
221			if (swSurface.p != NULL) swSurface.p = NULL;
222		5	if (stsurface!=NULL) delete stsurface;
223			}
224
225			void SLD_SURFACE::evaluer(double uv,double xyz)
226			{
227			if (stsurface!=NULL)
228			{
229			stsurface->evaluer(uv,xyz);
230			return;
231			}
232			//entrée
233			double UParam=uv[0];
234			double VParam=uv[1];
235			long NumUDeriv=0;
236			long NumVDeriv=0;
237			//sortie
238			CComVariant vretval;
239
240			swSurface->Evaluate ( UParam, VParam, NumUDeriv, NumVDeriv, &vretval);
241			SafeDoubleArray saretval(vretval);
242			//notre résultat
243			xyz[0]=saretval[0];
244			xyz[1]=saretval[1];
245			xyz[2]=saretval[2];
246			}
247
248			void SLD_SURFACE::deriver(double uv,double xyzdu, double *xyzdv)
249			{
250			if (stsurface!=NULL)
251			{
252			stsurface->deriver(uv,xyzdu,xyzdv);
253			return;
254			}
255			//entrée
256			double UParam=uv[0];
257			double VParam=uv[1];
258			long NumUDeriv=1;
259			long NumVDeriv=1;
260			//sortie
261			CComVariant vretval;
262
263			swSurface->Evaluate ( UParam, VParam, NumUDeriv, NumVDeriv, &vretval);
264			SafeDoubleArray saretval(vretval);
265			xyzdu[0]=saretval[3];
266			xyzdu[1]=saretval[4];
267			xyzdu[2]=saretval[5];
268			xyzdv[0]=saretval[6];
269			xyzdv[1]=saretval[7];
270			xyzdv[2]=saretval[8];
271			}
272
273			void SLD_SURFACE::deriver_seconde(double uv,double xyzduu,double* xyzduv,double* xyzdvv,double xyz, double xyzdu, double *xyzdv)
274			{
275			if (stsurface!=NULL)
276			{
277			stsurface->deriver_seconde(uv,xyzduu,xyzduv,xyzdvv,xyz,xyzdu,xyzdv);
278			return;
279			}
280			//entrée
281			double UParam=uv[0];
282			double VParam=uv[1];
283			long NumUDeriv=2;
284			long NumVDeriv=2;
285			//sortie
286			CComVariant vretval;
287
288			swSurface->Evaluate ( UParam, VParam, NumUDeriv, NumVDeriv, &vretval);
289			SafeDoubleArray saretval(vretval);
290			// virtual void deriver_seconde(double uv,double xyzduu,double* xyzduv,double* xyzdvv,
291			//double xyz = NULL , double xyzdu = NULL , double *xyzdv =NULL);
292			if(xyz!=NULL) //or xyz~=NULL
293			{
294			xyz[0]=saretval[0];
295			xyz[1]=saretval[1];
296			xyz[2]=saretval[2];
297			}
298			if(xyzdu!= NULL)
299			{
300			xyzdu[0]=saretval[3];
301			xyzdu[1]=saretval[4];
302			xyzdu[2]=saretval[5];
303			}
304			if(xyzdv!=NULL)
305			{
306			xyzdv[0]=saretval[9];
307			xyzdv[1]=saretval[10];
308			xyzdv[2]=saretval[11];
309			}
310			//affectation normale
311			xyzduu[0]=saretval[6];
312			xyzduu[1]=saretval[7];
313			xyzduu[2]=saretval[8];
314			xyzduv[0]=saretval[12];
315			xyzduv[1]=saretval[13];
316			xyzduv[2]=saretval[14];
317			xyzdvv[0]=saretval[18];
318			xyzdvv[1]=saretval[19];
319			xyzdvv[2]=saretval[20];
320			}
321
322			void SLD_SURFACE::inverser(double* uv,double *xyz,double precision)
323			{//Paramètre précision
324			if (stsurface!=NULL)
325			{
326			stsurface->inverser(uv,xyz,precision);
327			return;
328			}
329			CComVariant vUV;
330			swSurface->ReverseEvaluate(xyz[0], xyz[1], xyz[2], &vUV);
331			SafeDoubleArray saUV(vUV);
332			uv[0] = saUV[0];
333			uv[1] = saUV[1];
334			}
335
336			int SLD_SURFACE::est_periodique_u(void)
337			{
338	foucault	27	return stsurface->est_periodique_u();
339		5	}
340
341			int SLD_SURFACE::est_periodique_v(void)
342			{
343	foucault	27	return stsurface->est_periodique_v();
344		5	}
345
346			double SLD_SURFACE::get_periode_u(void)
347			{
348	foucault	27	return stsurface->get_periode_u();
349		5	}
350
351			double SLD_SURFACE::get_periode_v(void)
352			{
353	foucault	27	return stsurface->get_periode_v();
354		5	}
355
356			double SLD_SURFACE::get_umin()
357			{
358	foucault	27	if (stsurface != NULL)
359			return stsurface->get_umin();
360			return u_min;
361		5	}
362
363			double SLD_SURFACE::get_umax()
364			{
365	foucault	27	if (stsurface != NULL)
366			return stsurface->get_umax();
367			return u_max;
368		5	}
369
370			double SLD_SURFACE::get_vmin()
371			{
372	foucault	27	if (stsurface != NULL)
373			return stsurface->get_vmin();
374			return v_min;
375		5	}
376
377			double SLD_SURFACE::get_vmax()
378			{
379	foucault	27	if (stsurface != NULL)
380			return stsurface->get_vmax();
381			return v_max;
382		5	}
383
384			void SLD_SURFACE::enregistrer(ostream& o)
385			{
386			o << "%" << get_id() << "=SURFACE_SLD("<< idoriginal.c_str() << ");" << endl;
387			}
388
389
390
391			int SLD_SURFACE::get_type_geometrique(TPL_LISTE_ENTITE<double> &param)
392			{
393			if (stsurface!=NULL)
394			return stsurface->get_type_geometrique(param);;
395			return 0;
396			}
397
398
399
400	francois	19	void SLD_SURFACE::get_param_NURBS(int& indx_premier_ptctr,TPL_LISTE_ENTITE<double> &param)
401		5	{
402	francois	19	stsurface->get_param_NURBS(indx_premier_ptctr,param);
403		5	}
404
405
406			#endif
407
408
409
410