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)
{
    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:	283
Committed:	Tue Sep 13 21:11:20 2011 UTC (13 years, 8 months ago) by francois
File size:	8702 byte(s)
Log Message:	structure de l'écriture
#	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			void SLD_COURBE::enregistrer(std::ostream& o)
328			{
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