sld_courbe.cpp

Aller à la documentation de ce fichier.

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