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


#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"


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

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