geometrie/src/sld_courbe.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_courbe.cpp
//
//------------------------------------------------------------
//------------------------------------------------------------
//  COPYRIGHT 2000
//  Version du 02/03/2006 � 11H22
//------------------------------------------------------------
//------------------------------------------------------------


#include "gestionversion.h"

#ifdef BREP_SLD

#include <system.hpp>
#include "sld_courbe.h"

#include <atl\atlmod.h>

#include "smartvars.h"
#include "sld_fonction.h"
#include "stline.h"
#include "stcircle.h"
#include "stellipse.h"
#include "stbspline.h"

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

//Premier constructeru bseoin tmin et tmax
SLD_COURBE::SLD_COURBE(unsigned long num,std::string idarete,SLD_FONCTION& fonc):MG_COURBE(num),fonction(fonc)
{
    initialiser(idarete);
}

SLD_COURBE::SLD_COURBE(std::string idarete,SLD_FONCTION& fonc):MG_COURBE(),fonction(fonc)
{
    initialiser(idarete);
}

SLD_COURBE::SLD_COURBE(std::string idarete,SLD_FONCTION& fonc, CComPtr<IEdge> & p_swEdge):MG_COURBE(),fonction(fonc), swArete(p_swEdge)
{
    swArete->IGetCurve(&swCurve);
    initialiser();
}

SLD_COURBE::~SLD_COURBE()
{
    if (swArete.p != NULL) swArete.p=NULL;
    if (swCurve.p != NULL) swCurve.p=NULL;
    if (stcourbe!=NULL) delete stcourbe;
}

void SLD_COURBE::initialiser(std::string idarete)
{
    idoriginal=idarete;
    fonction.GetParID((char*)idarete.c_str(),swArete);
    if (swArete ==NULL)
    {
        fonction.GetParID((char*)idarete.c_str(),swArete);
        while (swArete==NULL)
        {
            fonction.GetParID((char*)idarete.c_str(),swArete);
        }

    }
    swArete->IGetCurve(&swCurve);
    initialiser();
}

void SLD_COURBE::initialiser()
{
    VARIANT_BOOL isClosed;//TRUE for closed curves, FALSE for other types
    VARIANT_BOOL isPeriodic;// TRUE for periodic curves, FALSE for other types
    VARIANT_BOOL retval;//TRUE if the operation was successful, FALSE if not
    swCurve->GetEndParams ( &t_min, &t_max, &isClosed, &isPeriodic, &retval );
    if (isPeriodic==1) periodique=1;
    else periodique=0;
    stcourbe=NULL;
    swCurve->IsLine(&retval);
    if (retval==1)
    {
        CComVariant vRetval;
        vRetval=swCurve->get_LineParams();
        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];
        stcourbe=new ST_LINE(origine,dir);
        return;
    }
    swCurve->IsCircle(&retval);
    if (retval==1)
    {
        CComVariant vRetval;
        vRetval=swCurve->get_CircleParams();
        SafeDoubleArray sda(vRetval);
        double origine[3];
        double axe[3];
        double rayon;
        origine[0]=sda[0];
        origine[1]=sda[1];
        origine[2]=sda[2];
        axe[0]=sda[3];
        axe[1]=sda[4];
        axe[2]=sda[5];
        rayon=sda[6];
        stcourbe=new ST_CIRCLE(origine,axe,rayon);
        return;
    }
    swCurve->IsEllipse(&retval);
    if (retval==1)
    {
        CComVariant vRetval;
        vRetval=swCurve->GetEllipseParams();
        SafeDoubleArray sda(vRetval);
        double origine[3];
        double dirx[3];
        double diry[3];
        double rayona;
        double rayonb;
        origine[0]=sda[0];
        origine[1]=sda[1];
        origine[2]=sda[2];
        rayona=sda[3];
        dirx[0]=sda[4];
        dirx[1]=sda[5];
        dirx[2]=sda[6];
        rayonb=sda[7];
        diry[0]=sda[8];
        diry[1]=sda[9];
        diry[2]=sda[10];
        OT_VECTEUR_3D x(dirx[0],dirx[1],dirx[2]);
        OT_VECTEUR_3D y(diry[0],diry[1],diry[2]);
        OT_VECTEUR_3D z=x&y;
        double *dirz=z.get_xyz();
        stcourbe=new ST_ELLIPSE(origine,dirz,dirx,rayona,rayonb);
        return;
    }
    CComVariant vRetval;
    swCurve->GetBCurveParams(False,&vRetval);
    SafeDoubleArray sda(vRetval);
    int dim,ordre,num,periode;
    OPERATEUR::doubleto2int(sda[0],dim,ordre);
    OPERATEUR::doubleto2int(sda[1],num,periode);
    std::vector<double> knots;
    for (int i=0;i<num+ordre;i++)
        knots.insert(knots.end(),sda[2+i]);
    std::vector<double> points;
    std::vector<double> poids;
    for (int i=0;i<num;i++)
    {
        points.insert(points.end(),sda[2+num+ordre+dim*i]);
        points.insert(points.end(),sda[2+num+ordre+dim*i+1]);
        points.insert(points.end(),sda[2+num+ordre+dim*i+2]);
        if (dim==4) poids.insert(poids.end(),sda[2+num+ordre+dim*i+3]);
        else poids.insert(poids.end(),1.);
    }
    stcourbe=new ST_B_SPLINE(ordre-1,knots,points,poids);
}


void  SLD_COURBE::evaluer(double t,double *xyz)
{
    if (stcourbe!=NULL)
    {
        stcourbe->evaluer(t,xyz);
        return;
    }
    CComVariant vparam;
    swCurve->Evaluate(t,&vparam);
    SafeDoubleArray param(vparam);
    xyz[0]=param[0];
    xyz[1]=param[1];
    xyz[2]=param[2];
}

void  SLD_COURBE::deriver(double t,double *dxyz)
{
    if (stcourbe!=NULL)
    {
        stcourbe->deriver(t,dxyz);
        return;
    }
    CComVariant vparam;
    swCurve->Evaluate(t,&vparam);
    SafeDoubleArray param(vparam);
    dxyz[0]=param[3];
    dxyz[1]=param[4];
    dxyz[2]=param[5];
}

void  SLD_COURBE::deriver_seconde(double t,double *ddxyz,double*dxyz,double*xyz)
{
    if (stcourbe!=NULL)
    {
        stcourbe->deriver_seconde(t,ddxyz,dxyz,xyz);
        return;
    }
    double epsilon=(t_max-t_min)*10e-6;
    double t1,t2;
    if (t-epsilon<t_min)
    {
        t1=t_min;
        t2=t_min+2*epsilon;
    }
    else if (t+epsilon>t_max)
    {
        t1=t_max-2*epsilon;
        t2=t_max;
    }
    else
    {
        t1=t-epsilon;
        t2=t+epsilon;
    }
    CComVariant vparam1;
    CComVariant vparam2;
    swCurve->Evaluate(t1,&vparam1);
    swCurve->Evaluate(t2,&vparam2);
    SafeDoubleArray param1(vparam1);
    SafeDoubleArray param2(vparam2);
    ddxyz[0]=(param2[3]-param1[3])/(2*epsilon);
    ddxyz[1]=(param2[4]-param1[4])/(2*epsilon);
    ddxyz[2]=(param2[5]-param1[5])/(2*epsilon);

//diff�rent cas
    if (dxyz!=NULL)
    {
        CComVariant vparam;
        swCurve->Evaluate(t,&vparam);
        SafeDoubleArray param(vparam);
        dxyz[0]=param[3];
        dxyz[1]=param[4];
        dxyz[2]=param[5];
        if (xyz!=NULL)
        {
            xyz[0]=param[0];
            xyz[1]=param[1];
            xyz[2]=param[2];
        }
    }
}

void  SLD_COURBE::inverser(double& t,double *xyz,double precision)
{
    if (stcourbe!=NULL)
    {
        stcourbe->inverser(t,xyz,precision);
        return;
    }
    CComVariant retval;
    swCurve->GetClosestPointOn ( xyz[0], xyz[1], xyz[2], &retval )   ;
    SafeDoubleArray vretval(retval);
    t=vretval[3];
}

double  SLD_COURBE::get_tmin(void)
{
    if (stcourbe!=NULL)
    {
        return stcourbe->get_tmin();
    }
    return tmin;
}

double  SLD_COURBE::get_tmax(void)
{
    if (stcourbe!=NULL)
    {
        return stcourbe->get_tmax();
    }
    return tmax;
}


double  SLD_COURBE::get_longueur(double t1,double t2,double precis)
{
    if (stcourbe!=NULL)
    {
        return stcourbe->get_longueur(t1,t2,precis);
    }
    double retval;
    swCurve->GetLength2(t1,t2,&retval);
    return retval;
}


int SLD_COURBE::est_periodique(void)
{
    if (stcourbe!=NULL)
    {
        return stcourbe->est_periodique();
    }
    return periodique;
}


double SLD_COURBE::get_periode(void)
{
    if (stcourbe!=NULL)
    {
        return stcourbe->get_periode();
    }
    return t_max-t_min;
}

void SLD_COURBE::enregistrer(std::ostream& o,double version)
{
    o << "%" << get_id() << "=COURBE_SLD("<< idoriginal.c_str()  << ");"<<std::endl;
}


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

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


#endif


Revision:	763
Committed:	Wed Dec 2 19:55:53 2015 UTC (9 years, 5 months ago) by francois
File size:	8717 byte(s)
Log Message:	Le fichier MAGiC est maintenant versionné. LA version actuelle est 2.0. L'ancienne version est 1.0. Tout est transparent pour l'utilisateur. Les vieilles versions sont lisibles mais les nouveaux enregistrements sont dans la version la plus récente. Changement des conditions aux limites : ajout d'un parametre pour dire si la condition numerique est une valeur ou une formule ou un lien vers une autre entité magic. Les parametres pour saisir sont maintenant -ccf -ccfi -ccff -ccft -ccfit -ccfft
#	User	Rev	Content
1	foucault	27	//------------------------------------------------------------
2			//------------------------------------------------------------
3			// MAGiC
4	francois	283	// Jean Christophe Cuilli�re et Vincent FRANCOIS
5			// D�partement de G�nie M�canique - UQTR
6	foucault	27	//------------------------------------------------------------
7	francois	283	// 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	foucault	27	// des auteurs (contact : francois@uqtr.ca)
12			//------------------------------------------------------------
13			//------------------------------------------------------------
14			//
15			// sld_courbe.cpp
16			//
17			//------------------------------------------------------------
18			//------------------------------------------------------------
19			// COPYRIGHT 2000
20	francois	283	// Version du 02/03/2006 � 11H22
21	foucault	27	//------------------------------------------------------------
22			//------------------------------------------------------------
23
24
25			#include "gestionversion.h"
26
27			#ifdef BREP_SLD
28
29			#include <system.hpp>
30			#include "sld_courbe.h"
31
32			#include <atl\atlmod.h>
33
34			#include "smartvars.h"
35			#include "sld_fonction.h"
36			#include "stline.h"
37			#include "stcircle.h"
38			#include "stellipse.h"
39			#include "stbspline.h"
40
41			//TComModule& _Module=static_cast<TComModule>(NULL);
42
43			//Premier constructeru bseoin tmin et tmax
44			SLD_COURBE::SLD_COURBE(unsigned long num,std::string idarete,SLD_FONCTION& fonc):MG_COURBE(num),fonction(fonc)
45			{
46	francois	283	initialiser(idarete);
47	foucault	27	}
48
49			SLD_COURBE::SLD_COURBE(std::string idarete,SLD_FONCTION& fonc):MG_COURBE(),fonction(fonc)
50			{
51	francois	283	initialiser(idarete);
52	foucault	27	}
53
54			SLD_COURBE::SLD_COURBE(std::string idarete,SLD_FONCTION& fonc, CComPtr<IEdge> & p_swEdge):MG_COURBE(),fonction(fonc), swArete(p_swEdge)
55	bournival	34	{
56	francois	283	swArete->IGetCurve(&swCurve);
57			initialiser();
58	foucault	27	}
59
60			SLD_COURBE::~SLD_COURBE()
61			{
62	francois	283	if (swArete.p != NULL) swArete.p=NULL;
63			if (swCurve.p != NULL) swCurve.p=NULL;
64			if (stcourbe!=NULL) delete stcourbe;
65	foucault	27	}
66
67			void SLD_COURBE::initialiser(std::string idarete)
68			{
69	francois	283	idoriginal=idarete;
70			fonction.GetParID((char*)idarete.c_str(),swArete);
71			if (swArete ==NULL)
72	bournival	34	{
73	francois	283	fonction.GetParID((char*)idarete.c_str(),swArete);
74			while (swArete==NULL)
75			{
76			fonction.GetParID((char*)idarete.c_str(),swArete);
77			}
78
79	bournival	34	}
80	francois	283	swArete->IGetCurve(&swCurve);
81			initialiser();
82	bournival	34	}
83	foucault	27
84			void SLD_COURBE::initialiser()
85			{
86	francois	283	VARIANT_BOOL isClosed;//TRUE for closed curves, FALSE for other types
87			VARIANT_BOOL isPeriodic;// TRUE for periodic curves, FALSE for other types
88			VARIANT_BOOL retval;//TRUE if the operation was successful, FALSE if not
89			swCurve->GetEndParams ( &t_min, &t_max, &isClosed, &isPeriodic, &retval );
90			if (isPeriodic==1) periodique=1;
91			else periodique=0;
92			stcourbe=NULL;
93			swCurve->IsLine(&retval);
94			if (retval==1)
95			{
96	foucault	27	CComVariant vRetval;
97			vRetval=swCurve->get_LineParams();
98			SafeDoubleArray sda(vRetval);
99			double origine[3];
100			double dir[3];
101			origine[0]=sda[0];
102			origine[1]=sda[1];
103			origine[2]=sda[2];
104			dir[0]=sda[3];
105			dir[1]=sda[4];
106			dir[2]=sda[5];
107			stcourbe=new ST_LINE(origine,dir);
108			return;
109	francois	283	}
110			swCurve->IsCircle(&retval);
111			if (retval==1)
112			{
113	foucault	27	CComVariant vRetval;
114			vRetval=swCurve->get_CircleParams();
115			SafeDoubleArray sda(vRetval);
116			double origine[3];
117			double axe[3];
118			double rayon;
119			origine[0]=sda[0];
120			origine[1]=sda[1];
121			origine[2]=sda[2];
122			axe[0]=sda[3];
123			axe[1]=sda[4];
124			axe[2]=sda[5];
125			rayon=sda[6];
126			stcourbe=new ST_CIRCLE(origine,axe,rayon);
127			return;
128	francois	283	}
129			swCurve->IsEllipse(&retval);
130			if (retval==1)
131			{
132	foucault	27	CComVariant vRetval;
133			vRetval=swCurve->GetEllipseParams();
134			SafeDoubleArray sda(vRetval);
135			double origine[3];
136			double dirx[3];
137			double diry[3];
138			double rayona;
139			double rayonb;
140			origine[0]=sda[0];
141			origine[1]=sda[1];
142			origine[2]=sda[2];
143			rayona=sda[3];
144			dirx[0]=sda[4];
145			dirx[1]=sda[5];
146			dirx[2]=sda[6];
147			rayonb=sda[7];
148			diry[0]=sda[8];
149			diry[1]=sda[9];
150			diry[2]=sda[10];
151			OT_VECTEUR_3D x(dirx[0],dirx[1],dirx[2]);
152			OT_VECTEUR_3D y(diry[0],diry[1],diry[2]);
153			OT_VECTEUR_3D z=x&y;
154			double *dirz=z.get_xyz();
155			stcourbe=new ST_ELLIPSE(origine,dirz,dirx,rayona,rayonb);
156			return;
157	francois	283	}
158			CComVariant vRetval;
159			swCurve->GetBCurveParams(False,&vRetval);
160			SafeDoubleArray sda(vRetval);
161			int dim,ordre,num,periode;
162			OPERATEUR::doubleto2int(sda[0],dim,ordre);
163			OPERATEUR::doubleto2int(sda[1],num,periode);
164			std::vector<double> knots;
165			for (int i=0;i<num+ordre;i++)
166	foucault	27	knots.insert(knots.end(),sda[2+i]);
167	francois	283	std::vector<double> points;
168			std::vector<double> poids;
169			for (int i=0;i<num;i++)
170			{
171	foucault	27	points.insert(points.end(),sda[2+num+ordre+dim*i]);
172			points.insert(points.end(),sda[2+num+ordre+dim*i+1]);
173			points.insert(points.end(),sda[2+num+ordre+dim*i+2]);
174			if (dim==4) poids.insert(poids.end(),sda[2+num+ordre+dim*i+3]);
175			else poids.insert(poids.end(),1.);
176	francois	283	}
177			stcourbe=new ST_B_SPLINE(ordre-1,knots,points,poids);
178	foucault	27	}
179
180
181			void SLD_COURBE::evaluer(double t,double *xyz)
182			{
183	francois	283	if (stcourbe!=NULL)
184			{
185	foucault	27	stcourbe->evaluer(t,xyz);
186			return;
187	francois	283	}
188			CComVariant vparam;
189			swCurve->Evaluate(t,&vparam);
190			SafeDoubleArray param(vparam);
191			xyz[0]=param[0];
192			xyz[1]=param[1];
193			xyz[2]=param[2];
194	foucault	27	}
195
196			void SLD_COURBE::deriver(double t,double *dxyz)
197			{
198	francois	283	if (stcourbe!=NULL)
199			{
200	foucault	27	stcourbe->deriver(t,dxyz);
201			return;
202	francois	283	}
203			CComVariant vparam;
204			swCurve->Evaluate(t,&vparam);
205			SafeDoubleArray param(vparam);
206			dxyz[0]=param[3];
207			dxyz[1]=param[4];
208			dxyz[2]=param[5];
209	foucault	27	}
210
211			void SLD_COURBE::deriver_seconde(double t,double ddxyz,doubledxyz,double*xyz)
212			{
213	francois	283	if (stcourbe!=NULL)
214			{
215	foucault	27	stcourbe->deriver_seconde(t,ddxyz,dxyz,xyz);
216			return;
217	francois	283	}
218			double epsilon=(t_max-t_min)*10e-6;
219			double t1,t2;
220			if (t-epsilon<t_min)
221			{
222	foucault	27	t1=t_min;
223			t2=t_min+2*epsilon;
224	francois	283	}
225			else if (t+epsilon>t_max)
226			{
227	foucault	27	t1=t_max-2*epsilon;
228			t2=t_max;
229	francois	283	}
230			else
231			{
232	foucault	27	t1=t-epsilon;
233			t2=t+epsilon;
234	francois	283	}
235			CComVariant vparam1;
236			CComVariant vparam2;
237			swCurve->Evaluate(t1,&vparam1);
238			swCurve->Evaluate(t2,&vparam2);
239			SafeDoubleArray param1(vparam1);
240			SafeDoubleArray param2(vparam2);
241			ddxyz[0]=(param2[3]-param1[3])/(2*epsilon);
242			ddxyz[1]=(param2[4]-param1[4])/(2*epsilon);
243			ddxyz[2]=(param2[5]-param1[5])/(2*epsilon);
244	foucault	27
245	francois	283	//diff�rent cas
246			if (dxyz!=NULL)
247			{
248	foucault	27	CComVariant vparam;
249			swCurve->Evaluate(t,&vparam);
250			SafeDoubleArray param(vparam);
251			dxyz[0]=param[3];
252			dxyz[1]=param[4];
253			dxyz[2]=param[5];
254	francois	283	if (xyz!=NULL)
255			{
256			xyz[0]=param[0];
257			xyz[1]=param[1];
258			xyz[2]=param[2];
259	foucault	27	}
260	francois	283	}
261	foucault	27	}
262
263			void SLD_COURBE::inverser(double& t,double *xyz,double precision)
264			{
265	francois	283	if (stcourbe!=NULL)
266			{
267	foucault	27	stcourbe->inverser(t,xyz,precision);
268			return;
269	francois	283	}
270			CComVariant retval;
271			swCurve->GetClosestPointOn ( xyz[0], xyz[1], xyz[2], &retval ) ;
272			SafeDoubleArray vretval(retval);
273			t=vretval[3];
274	foucault	27	}
275
276			double SLD_COURBE::get_tmin(void)
277			{
278	francois	283	if (stcourbe!=NULL)
279			{
280	foucault	27	return stcourbe->get_tmin();
281	francois	283	}
282			return tmin;
283	foucault	27	}
284
285			double SLD_COURBE::get_tmax(void)
286			{
287	francois	283	if (stcourbe!=NULL)
288			{
289	foucault	27	return stcourbe->get_tmax();
290	francois	283	}
291			return tmax;
292	foucault	27	}
293
294
295
296			double SLD_COURBE::get_longueur(double t1,double t2,double precis)
297			{
298	francois	283	if (stcourbe!=NULL)
299			{
300	foucault	27	return stcourbe->get_longueur(t1,t2,precis);
301	francois	283	}
302			double retval;
303			swCurve->GetLength2(t1,t2,&retval);
304			return retval;
305	foucault	27	}
306
307
308			int SLD_COURBE::est_periodique(void)
309			{
310	francois	283	if (stcourbe!=NULL)
311			{
312	foucault	27	return stcourbe->est_periodique();
313	francois	283	}
314			return periodique;
315	foucault	27	}
316
317
318			double SLD_COURBE::get_periode(void)
319			{
320	francois	283	if (stcourbe!=NULL)
321			{
322	foucault	27	return stcourbe->get_periode();
323	francois	283	}
324			return t_max-t_min;
325	foucault	27	}
326
327	francois	763	void SLD_COURBE::enregistrer(std::ostream& o,double version)
328	foucault	27	{
329	francois	283	o << "%" << get_id() << "=COURBE_SLD("<< idoriginal.c_str() << ");"<<std::endl;
330	foucault	27	}
331
332
333			int SLD_COURBE::get_type_geometrique(TPL_LISTE_ENTITE<double> &param)
334			{
335	francois	283	if (stcourbe!=NULL)
336			return stcourbe->get_type_geometrique(param);
337			return 0;
338	foucault	27	}
339
340			void SLD_COURBE::get_param_NURBS(int& indx_premier_ptctr,TPL_LISTE_ENTITE<double> &param)
341			{
342	francois	283	stcourbe->get_param_NURBS(indx_premier_ptctr,param);
343	foucault	27	}
344
345
346
347
348
349			#endif
350
351