sld_surface.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_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