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

void SLD_SURFACE::initialisation(string idface)
{
idoriginal=idface;
fonction.GetParID((char*)idface.c_str(),swFace);
swFace->IGetSurface(&swSurface);
CComVariant vparam;
swSurface->Parameterization( &vparam);
SafeDoubleArray saparam(vparam);
u_min=saparam[0];
u_max=saparam[1];
v_min=saparam[2];
v_max=saparam[3];
periodique_u=0;
periodique_v=0;
int val1,val2;
OPERATEUR::doubleto2int(saparam[4],val1,val2);
if ((val1==13701) && (val2==13701)) periodique_u=1;
OPERATEUR::doubleto2int(saparam[5],val1,val2);
if ((val1==13701) && (val2==13701)) periodique_v=1;
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();
swSurface->GetBSurfParams2(false,false,vp0,0.001,&sense,&vRetval);
SafeDoubleArray sda(vRetval);
int uordre,vordre;
int numcpt,numlpt;
int dim,dummy;
OPERATEUR::doubleto2int(sda[0],uordre,vordre);
OPERATEUR::doubleto2int(sda[1],numcpt,numlpt);
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);


};


SLD_SURFACE::~SLD_SURFACE()
{
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 periodique_u;
}

int SLD_SURFACE::est_periodique_v(void)
{
return periodique_v;
}

double SLD_SURFACE::get_periode_u(void)
{
if (!periodique_u) return 0.;
return u_max-u_min;
}

double SLD_SURFACE::get_periode_v(void)
{
if (!periodique_v) return 0.;
return v_max-v_min;
}


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 u_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(TPL_LISTE_ENTITE<double> &param)
{
stsurface->get_param_NURBS(param);
}


#endif


Revision:	5
Committed:	Tue Jun 12 20:26:34 2007 UTC (17 years, 11 months ago)
Original Path:	*magic/lib/geometrie/geometrie/src/sld_surface.cpp*
File size:	10108 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		// 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
53		SLD_SURFACE::SLD_SURFACE(string idface,SLD_FONCTION& fonc):MG_SURFACE(),fonction(fonc)
54		{
55		initialisation(idface);
56		}
57
58		void SLD_SURFACE::initialisation(string idface)
59		{
60		idoriginal=idface;
61		fonction.GetParID((char*)idface.c_str(),swFace);
62		swFace->IGetSurface(&swSurface);
63		CComVariant vparam;
64		swSurface->Parameterization( &vparam);
65		SafeDoubleArray saparam(vparam);
66		u_min=saparam[0];
67		u_max=saparam[1];
68		v_min=saparam[2];
69		v_max=saparam[3];
70		periodique_u=0;
71		periodique_v=0;
72		int val1,val2;
73		OPERATEUR::doubleto2int(saparam[4],val1,val2);
74		if ((val1==13701) && (val2==13701)) periodique_u=1;
75		OPERATEUR::doubleto2int(saparam[5],val1,val2);
76		if ((val1==13701) && (val2==13701)) periodique_v=1;
77		stsurface=NULL;
78		VARIANT_BOOL retval;
79		swSurface->IsPlane(&retval);
80		if (retval==1)
81		{
82		CComVariant vRetval;
83		vRetval=swSurface->get_PlaneParams();
84		SafeDoubleArray sda(vRetval);
85		double origine[3];
86		double dir[3];
87		origine[0]=sda[3];
88		origine[1]=sda[4];
89		origine[2]=sda[5];
90		dir[0]=sda[0];
91		dir[1]=sda[1];
92		dir[2]=sda[2];
93		stsurface=new ST_PLANE(origine,dir);
94		return;
95		}
96		swSurface->IsCylinder(&retval);
97		if (retval==1)
98		{
99		CComVariant vRetval;
100		vRetval=swSurface->get_CylinderParams();
101		SafeDoubleArray sda(vRetval);
102		double origine[3];
103		double dir[3];
104		origine[0]=sda[0];
105		origine[1]=sda[1];
106		origine[2]=sda[2];
107		dir[0]=sda[3];
108		dir[1]=sda[4];
109		dir[2]=sda[5];
110		double rayon=sda[6];
111		stsurface=new ST_CYLINDRICAL(origine,dir,NULL,rayon);
112		return;
113		}
114		swSurface->IsCone(&retval);
115		if (retval==1)
116		{
117		CComVariant vRetval;
118		vRetval=swSurface->get_ConeParams();
119		SafeDoubleArray sda(vRetval);
120		double origine[3];
121		double dir[3];
122		origine[0]=sda[0];
123		origine[1]=sda[1];
124		origine[2]=sda[2];
125		dir[0]=-sda[3];
126		dir[1]=-sda[4];
127		dir[2]=-sda[5];
128		double rayon=sda[6];
129		double angle=sda[7];
130		stsurface=new ST_CONICAL(origine,dir,NULL,rayon,angle);
131		return;
132		}
133		swSurface->IsSphere(&retval);
134		if (retval==1)
135		{
136		CComVariant vRetval;
137		vRetval=swSurface->get_SphereParams() ;
138		SafeDoubleArray sda(vRetval);
139		double origine[3];
140		origine[0]=sda[0];
141		origine[1]=sda[1];
142		origine[2]=sda[2];
143		double rayon=sda[3];
144		stsurface=new ST_SPHERICAL(origine,NULL,NULL,rayon);
145		return;
146		}
147		swSurface->IsTorus(&retval) ;
148		if (retval==1)
149		{
150		CComVariant vRetval;
151		vRetval=swSurface->get_TorusParams();
152		SafeDoubleArray sda(vRetval);
153		double origine[3];
154		double dir[3];
155		origine[0]=sda[0];
156		origine[1]=sda[1];
157		origine[2]=sda[2];
158		dir[0]=sda[3];
159		dir[1]=sda[4];
160		dir[2]=sda[5];
161		double grayon=sda[6];
162		double prayon=sda[7];
163		stsurface=new ST_TOROIDAL(origine,dir,grayon,prayon);
164		return;
165		}
166		VARIANT vRetval;
167		VARIANT_BOOL sense;
168		VARIANT vp0;
169		vp0=swFace->GetUVBounds();
170		swSurface->GetBSurfParams2(false,false,vp0,0.001,&sense,&vRetval);
171		SafeDoubleArray sda(vRetval);
172		int uordre,vordre;
173		int numcpt,numlpt;
174		int dim,dummy;
175		OPERATEUR::doubleto2int(sda[0],uordre,vordre);
176		OPERATEUR::doubleto2int(sda[1],numcpt,numlpt);
177		OPERATEUR::doubleto2int(sda[3],dim,dummy);
178		vector<double> knots_u;
179		vector<double> knots_v;
180		vector<double> poids;
181		vector<double> ptsctr;
182		for (int i=0;i<uordre+numcpt;i++)
183		knots_u.insert(knots_u.end(),sda[4+i]);
184		for (int i=0;i<vordre+numlpt;i++)
185		knots_v.insert(knots_v.end(),sda[4+uordre+numcpt+i]);
186		for (int i=0;i<numcpt;i++)
187		for (int j=0;j<numlpt;j++)
188		{
189		int num=j*numcpt+i;
190		ptsctr.insert(ptsctr.end(),sda[4+uordre+numcpt+vordre+numlpt+dim*num]);
191		ptsctr.insert(ptsctr.end(),sda[4+uordre+numcpt+vordre+numlpt+dim*num+1]);
192		ptsctr.insert(ptsctr.end(),sda[4+uordre+numcpt+vordre+numlpt+dim*num+2]);
193		if (dim==4) poids.insert(poids.end(),sda[4+uordre+numcpt+vordre+numlpt+dim*num+3]);
194		else poids.insert(poids.end(),1.);
195		}
196		int sens;
197		sens=1;
198		stsurface=new ST_B_SPLINE_SURF(uordre-1,vordre-1,knots_u,knots_v,ptsctr,poids,sens);
199
200
201		};
202
203
204		SLD_SURFACE::~SLD_SURFACE()
205		{
206		if (stsurface!=NULL) delete stsurface;
207		}
208
209		void SLD_SURFACE::evaluer(double uv,double xyz)
210		{
211		if (stsurface!=NULL)
212		{
213		stsurface->evaluer(uv,xyz);
214		return;
215		}
216		//entrée
217		double UParam=uv[0];
218		double VParam=uv[1];
219		long NumUDeriv=0;
220		long NumVDeriv=0;
221		//sortie
222		CComVariant vretval;
223
224		swSurface->Evaluate ( UParam, VParam, NumUDeriv, NumVDeriv, &vretval);
225		SafeDoubleArray saretval(vretval);
226		//notre résultat
227		xyz[0]=saretval[0];
228		xyz[1]=saretval[1];
229		xyz[2]=saretval[2];
230		}
231
232		void SLD_SURFACE::deriver(double uv,double xyzdu, double *xyzdv)
233		{
234		if (stsurface!=NULL)
235		{
236		stsurface->deriver(uv,xyzdu,xyzdv);
237		return;
238		}
239		//entrée
240		double UParam=uv[0];
241		double VParam=uv[1];
242		long NumUDeriv=1;
243		long NumVDeriv=1;
244		//sortie
245		CComVariant vretval;
246
247		swSurface->Evaluate ( UParam, VParam, NumUDeriv, NumVDeriv, &vretval);
248		SafeDoubleArray saretval(vretval);
249		xyzdu[0]=saretval[3];
250		xyzdu[1]=saretval[4];
251		xyzdu[2]=saretval[5];
252		xyzdv[0]=saretval[6];
253		xyzdv[1]=saretval[7];
254		xyzdv[2]=saretval[8];
255		}
256
257		void SLD_SURFACE::deriver_seconde(double uv,double xyzduu,double* xyzduv,double* xyzdvv,double xyz, double xyzdu, double *xyzdv)
258		{
259		if (stsurface!=NULL)
260		{
261		stsurface->deriver_seconde(uv,xyzduu,xyzduv,xyzdvv,xyz,xyzdu,xyzdv);
262		return;
263		}
264		//entrée
265		double UParam=uv[0];
266		double VParam=uv[1];
267		long NumUDeriv=2;
268		long NumVDeriv=2;
269		//sortie
270		CComVariant vretval;
271
272		swSurface->Evaluate ( UParam, VParam, NumUDeriv, NumVDeriv, &vretval);
273		SafeDoubleArray saretval(vretval);
274		// virtual void deriver_seconde(double uv,double xyzduu,double* xyzduv,double* xyzdvv,
275		//double xyz = NULL , double xyzdu = NULL , double *xyzdv =NULL);
276		if(xyz!=NULL) //or xyz~=NULL
277		{
278		xyz[0]=saretval[0];
279		xyz[1]=saretval[1];
280		xyz[2]=saretval[2];
281		}
282		if(xyzdu!= NULL)
283		{
284		xyzdu[0]=saretval[3];
285		xyzdu[1]=saretval[4];
286		xyzdu[2]=saretval[5];
287		}
288		if(xyzdv!=NULL)
289		{
290		xyzdv[0]=saretval[9];
291		xyzdv[1]=saretval[10];
292		xyzdv[2]=saretval[11];
293		}
294		//affectation normale
295		xyzduu[0]=saretval[6];
296		xyzduu[1]=saretval[7];
297		xyzduu[2]=saretval[8];
298		xyzduv[0]=saretval[12];
299		xyzduv[1]=saretval[13];
300		xyzduv[2]=saretval[14];
301		xyzdvv[0]=saretval[18];
302		xyzdvv[1]=saretval[19];
303		xyzdvv[2]=saretval[20];
304		}
305
306		void SLD_SURFACE::inverser(double* uv,double *xyz,double precision)
307		{//Paramètre précision
308		if (stsurface!=NULL)
309		{
310		stsurface->inverser(uv,xyz,precision);
311		return;
312		}
313		CComVariant vUV;
314		swSurface->ReverseEvaluate(xyz[0], xyz[1], xyz[2], &vUV);
315		SafeDoubleArray saUV(vUV);
316		uv[0] = saUV[0];
317		uv[1] = saUV[1];
318		}
319
320		int SLD_SURFACE::est_periodique_u(void)
321		{
322		return periodique_u;
323		}
324
325		int SLD_SURFACE::est_periodique_v(void)
326		{
327		return periodique_v;
328		}
329
330		double SLD_SURFACE::get_periode_u(void)
331		{
332		if (!periodique_u) return 0.;
333		return u_max-u_min;
334		}
335
336		double SLD_SURFACE::get_periode_v(void)
337		{
338		if (!periodique_v) return 0.;
339		return v_max-v_min;
340		}
341
342
343		double SLD_SURFACE::get_umin()
344		{
345		if (stsurface!=NULL)
346		return stsurface->get_umin();;
347		return u_min;
348		}
349
350		double SLD_SURFACE::get_umax()
351		{
352		if (stsurface!=NULL)
353		return stsurface->get_umax();;
354		return u_max;
355		}
356
357		double SLD_SURFACE::get_vmin()
358		{
359		if (stsurface!=NULL)
360		return stsurface->get_vmin();;
361		return v_min;
362		}
363
364		double SLD_SURFACE::get_vmax()
365		{
366		if (stsurface!=NULL)
367		return stsurface->get_vmax();;
368		return u_max;
369		}
370
371
372
373		void SLD_SURFACE::enregistrer(ostream& o)
374		{
375		o << "%" << get_id() << "=SURFACE_SLD("<< idoriginal.c_str() << ");" << endl;
376		}
377
378
379
380		int SLD_SURFACE::get_type_geometrique(TPL_LISTE_ENTITE<double> &param)
381		{
382		if (stsurface!=NULL)
383		return stsurface->get_type_geometrique(param);;
384		return 0;
385		}
386
387
388
389		void SLD_SURFACE::get_param_NURBS(TPL_LISTE_ENTITE<double> &param)
390		{
391		stsurface->get_param_NURBS(param);
392		}
393
394
395		#endif
396
397
398
399