mtu/src/sld_surface.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/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       sld_surface.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:54 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------


#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 "sld_fonction.h"
#include "stplane.h"
#include "stcylindrical.h"
#include "stconical.h"
#include "stspherical.h"
#include "sttoroidal.h"
#include "stbsplines.h"


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);
    ((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;
    }
    double UParam=uv[0];
    double VParam=uv[1];
    long NumUDeriv=0;
    long NumVDeriv=0;
    CComVariant vretval;

    swSurface->Evaluate ( UParam, VParam, NumUDeriv, NumVDeriv, &vretval);
    SafeDoubleArray saretval(vretval);
    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;
    }
    double UParam=uv[0];
    double VParam=uv[1];
    long NumUDeriv=1;
    long NumVDeriv=1;
    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;
    }
    double UParam=uv[0];
    double VParam=uv[1];
    long NumUDeriv=2;
    long NumVDeriv=2;
    CComVariant vretval;

    swSurface->Evaluate ( UParam, VParam, NumUDeriv, NumVDeriv, &vretval);
    SafeDoubleArray saretval(vretval);
    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];
    }
    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,double version)
{
    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:	1158
Committed:	Thu Jun 13 22:18:49 2024 UTC (11 months, 1 week ago) by francois
File size:	10298 byte(s)
Log Message:	compatibilité Ubuntu 22.04 Suppression des refeences à Windows Ajout d'une banière
#	User	Rev	Content
1	francois	1158	//####//------------------------------------------------------------
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			//####// sld_surface.cpp
15			//####//
16			//####//------------------------------------------------------------
17			//####//------------------------------------------------------------
18			//####// COPYRIGHT 2000-2024
19			//####// jeu 13 jun 2024 11:58:54 EDT
20			//####//------------------------------------------------------------
21			//####//------------------------------------------------------------
22	francois	283
23
24			#include "gestionversion.h"
25
26			#ifdef BREP_SLD
27
28			#include "mg_surface.h"
29			#include "sld_surface.h"
30			#include <system.hpp>
31			#include <atl\atlmod.h>
32			#include "smartvars.h"
33			#include "sld_fonction.h"
34			#include "stplane.h"
35			#include "stcylindrical.h"
36			#include "stconical.h"
37			#include "stspherical.h"
38			#include "sttoroidal.h"
39			#include "stbsplines.h"
40
41
42
43			SLD_SURFACE::SLD_SURFACE(unsigned long num,string idface,SLD_FONCTION& fonc):MG_SURFACE(num),fonction(fonc)
44			{
45			initialisation(idface);
46			}
47
48
49			SLD_SURFACE::SLD_SURFACE(string idface,SLD_FONCTION& fonc):MG_SURFACE(),fonction(fonc)
50			{
51			initialisation(idface);
52			}
53
54			SLD_SURFACE::SLD_SURFACE(string idface, SLD_FONCTION& fonc, CComPtr < IFace2 > & p_swFace) : MG_SURFACE(), swFace(p_swFace), fonction(fonc)
55			{
56			swFace->IGetSurface(&swSurface);
57			initialisation();
58			}
59
60			void SLD_SURFACE::initialisation(string idface)
61			{
62			idoriginal=idface;
63			fonction.GetParID((char*)idface.c_str(),swFace);
64			swFace->IGetSurface(&swSurface);
65			initialisation();
66			}
67
68			void SLD_SURFACE::initialisation()
69			{
70			CComVariant vparam;
71			swSurface->Parameterization( &vparam);
72			SafeDoubleArray saparam(vparam);
73			u_min=saparam[0];
74			u_max=saparam[1];
75			v_min=saparam[2];
76			v_max=saparam[3];
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			double tolerance = fonction.GetValeurTolerance() ;
171			swSurface->GetBSurfParams2(false,false,vp0,tolerance,&sense,&vRetval);
172			SafeDoubleArray sda(vRetval);
173			int uordre,vordre;
174			int numcpt,numlpt;
175			int uperiodic,vperiodic;
176			int dim,dummy;
177			OPERATEUR::doubleto2int(sda[0],uordre,vordre);
178			OPERATEUR::doubleto2int(sda[1],numcpt,numlpt);
179			OPERATEUR::doubleto2int(sda[2],uperiodic,vperiodic);
180			OPERATEUR::doubleto2int(sda[3],dim,dummy);
181			vector<double> knots_u;
182			vector<double> knots_v;
183			vector<double> poids;
184			vector<double> ptsctr;
185			for (int i=0;i<uordre+numcpt;i++)
186			knots_u.insert(knots_u.end(),sda[4+i]);
187			for (int i=0;i<vordre+numlpt;i++)
188			knots_v.insert(knots_v.end(),sda[4+uordre+numcpt+i]);
189			for (int i=0;i<numcpt;i++)
190			for (int j=0;j<numlpt;j++)
191			{
192			int num=j*numcpt+i;
193			ptsctr.insert(ptsctr.end(),sda[4+uordre+numcpt+vordre+numlpt+dim*num]);
194			ptsctr.insert(ptsctr.end(),sda[4+uordre+numcpt+vordre+numlpt+dim*num+1]);
195			ptsctr.insert(ptsctr.end(),sda[4+uordre+numcpt+vordre+numlpt+dim*num+2]);
196			if (dim==4) poids.insert(poids.end(),sda[4+uordre+numcpt+vordre+numlpt+dim*num+3]);
197			else poids.insert(poids.end(),1.);
198			}
199			int sens;
200			sens=1;
201			stsurface=new ST_B_SPLINE_SURF(uordre-1,vordre-1,knots_u,knots_v,ptsctr,poids,sens);
202			((ST_B_SPLINE_SURF*) stsurface)->set_periodique_u( uperiodic );
203			((ST_B_SPLINE_SURF*) stsurface)->set_periodique_v( vperiodic );
204			};
205
206
207			SLD_SURFACE::~SLD_SURFACE()
208			{
209			if (swFace.p != NULL) swFace.p = NULL;
210			if (swSurface.p != NULL) swSurface.p = NULL;
211			if (stsurface!=NULL) delete stsurface;
212			}
213
214			void SLD_SURFACE::evaluer(double uv,double xyz)
215			{
216			if (stsurface!=NULL)
217			{
218			stsurface->evaluer(uv,xyz);
219			return;
220			}
221			double UParam=uv[0];
222			double VParam=uv[1];
223			long NumUDeriv=0;
224			long NumVDeriv=0;
225			CComVariant vretval;
226
227			swSurface->Evaluate ( UParam, VParam, NumUDeriv, NumVDeriv, &vretval);
228			SafeDoubleArray saretval(vretval);
229			xyz[0]=saretval[0];
230			xyz[1]=saretval[1];
231			xyz[2]=saretval[2];
232			}
233
234			void SLD_SURFACE::deriver(double uv,double xyzdu, double *xyzdv)
235			{
236			if (stsurface!=NULL)
237			{
238			stsurface->deriver(uv,xyzdu,xyzdv);
239			return;
240			}
241			double UParam=uv[0];
242			double VParam=uv[1];
243			long NumUDeriv=1;
244			long NumVDeriv=1;
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			double UParam=uv[0];
265			double VParam=uv[1];
266			long NumUDeriv=2;
267			long NumVDeriv=2;
268			CComVariant vretval;
269
270			swSurface->Evaluate ( UParam, VParam, NumUDeriv, NumVDeriv, &vretval);
271			SafeDoubleArray saretval(vretval);
272			if (xyz!=NULL) //or xyz~=NULL
273			{
274			xyz[0]=saretval[0];
275			xyz[1]=saretval[1];
276			xyz[2]=saretval[2];
277			}
278			if (xyzdu!= NULL)
279			{
280			xyzdu[0]=saretval[3];
281			xyzdu[1]=saretval[4];
282			xyzdu[2]=saretval[5];
283			}
284			if (xyzdv!=NULL)
285			{
286			xyzdv[0]=saretval[9];
287			xyzdv[1]=saretval[10];
288			xyzdv[2]=saretval[11];
289			}
290			xyzduu[0]=saretval[6];
291			xyzduu[1]=saretval[7];
292			xyzduu[2]=saretval[8];
293			xyzduv[0]=saretval[12];
294			xyzduv[1]=saretval[13];
295			xyzduv[2]=saretval[14];
296			xyzdvv[0]=saretval[18];
297			xyzdvv[1]=saretval[19];
298			xyzdvv[2]=saretval[20];
299			}
300
301			void SLD_SURFACE::inverser(double* uv,double *xyz,double precision)
302			{//Param�tre pr�cision
303			if (stsurface!=NULL)
304			{
305			stsurface->inverser(uv,xyz,precision);
306			return;
307			}
308			CComVariant vUV;
309			swSurface->ReverseEvaluate(xyz[0], xyz[1], xyz[2], &vUV);
310			SafeDoubleArray saUV(vUV);
311			uv[0] = saUV[0];
312			uv[1] = saUV[1];
313			}
314
315			int SLD_SURFACE::est_periodique_u(void)
316			{
317			return stsurface->est_periodique_u();
318			}
319
320			int SLD_SURFACE::est_periodique_v(void)
321			{
322			return stsurface->est_periodique_v();
323			}
324
325			double SLD_SURFACE::get_periode_u(void)
326			{
327			return stsurface->get_periode_u();
328			}
329
330			double SLD_SURFACE::get_periode_v(void)
331			{
332			return stsurface->get_periode_v();
333			}
334
335			double SLD_SURFACE::get_umin()
336			{
337			if (stsurface != NULL)
338			return stsurface->get_umin();
339			return u_min;
340			}
341
342			double SLD_SURFACE::get_umax()
343			{
344			if (stsurface != NULL)
345			return stsurface->get_umax();
346			return u_max;
347			}
348
349			double SLD_SURFACE::get_vmin()
350			{
351			if (stsurface != NULL)
352			return stsurface->get_vmin();
353			return v_min;
354			}
355
356			double SLD_SURFACE::get_vmax()
357			{
358			if (stsurface != NULL)
359			return stsurface->get_vmax();
360			return v_max;
361			}
362
363	francois	763	void SLD_SURFACE::enregistrer(ostream& o,double version)
364	francois	283	{
365			o << "%" << get_id() << "=SURFACE_SLD("<< idoriginal.c_str() << ");" << endl;
366			}
367
368
369
370			int SLD_SURFACE::get_type_geometrique(TPL_LISTE_ENTITE<double> &param)
371			{
372			if (stsurface!=NULL)
373			return stsurface->get_type_geometrique(param);;
374			return 0;
375			}
376
377
378
379			void SLD_SURFACE::get_param_NURBS(int& indx_premier_ptctr,TPL_LISTE_ENTITE<double> &param)
380			{
381			stsurface->get_param_NURBS(indx_premier_ptctr,param);
382			}
383
384
385			#endif
386
387
388
389