st_b_spline_surf2.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/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       st_b_spline_surf2.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:53:59 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
 
#pragma hdrstop
 
 
#include "st_b_spline_surf2.h"
#include <vector>
#include "st_gestionnaire.h"
#include "ot_systeme.h"
#include "constantegeo.h"
 
#include <math.h>
 
#pragma package(smart_init)
 
 
ST_B_SPLINE_SURF2::ST_B_SPLINE_SURF2(long LigneCourante,std::string idori,int bs_degre_u,int bs_degre_v,std::vector<int> bs_indexptsctr,std::vector<int> bs_knots_multiplicities_u,std::vector<int> bs_knots_multiplicities_v,std::vector<double> bs_knots_u,std::vector<double> bs_knots_v):ST_SURFACE(LigneCourante,idori),degre_u(bs_degre_u),degre_v(bs_degre_v),sens(1)
{
    int r_u=bs_knots_multiplicities_u.size();
    for (int k=0;k<r_u;k++)
    {
        for (int j=0;j<bs_knots_multiplicities_u[k];j++)
            knots_u.insert(knots_u.end(),bs_knots_u[k]);
    }
    int r_v=bs_knots_multiplicities_v.size();
    for (int k=0;k<r_v;k++)
    {
        for (int j=0;j<bs_knots_multiplicities_v[k];j++)
            knots_v.insert(knots_v.end(),bs_knots_v[k]);
    }
    nb_point=bs_indexptsctr.size();
    nb_ptsctr_u=knots_u.size()-degre_u-1;
    nb_ptsctr_v=knots_v.size()-degre_v-1;
    for (int i=0;i<nb_point;i++)
    {
        indexptsctr.insert(indexptsctr.end(),bs_indexptsctr[i]);
    }
    umin=knots_u[0];
    umax=knots_u[knots_u.size()-1];
    vmin=knots_v[0];
    vmax=knots_v[knots_v.size()-1];
}
 
ST_B_SPLINE_SURF2::ST_B_SPLINE_SURF2(int bs_degre_u,int bs_degre_v,std::vector<double> &bs_knots_u,std::vector<double> &bs_knots_v,std::vector<double> &bs_ptsctr,std::vector<double> &bs_poids,int sense):ST_SURFACE(),degre_u(bs_degre_u),degre_v(bs_degre_v),sens(sense)
{
    int r_u=bs_knots_u.size();
    for (int k=0;k<r_u;k++)
        knots_u.insert(knots_u.end(),bs_knots_u[k]);
    int r_v=bs_knots_v.size();
    for (int k=0;k<r_v;k++)
        knots_v.insert(knots_v.end(),bs_knots_v[k]);
    nb_point=bs_ptsctr.size()/3;
    nb_ptsctr_u=knots_u.size()-degre_u-1;
    nb_ptsctr_v=knots_v.size()-degre_v-1;
    for (int i=0;i<nb_point;i++)
    {
        double x=bs_ptsctr[3*i];
        double y=bs_ptsctr[3*i+1];
        double z=bs_ptsctr[3*i+2];
        double w=bs_poids[i];
        ptsctr.push_back(OT_VECTEUR_4D(w*x,w*y,w*z,w));
    }
    periodique_u=1;
    for (int i=0; i<nb_ptsctr_v; i++)
    {
        double *xyz1=ptsctr[i];
        double *xyz2=ptsctr[nb_ptsctr_v*(nb_ptsctr_u-1)+i];
        if ((!(OPERATEUR::egal (xyz1[0],xyz2[0],1E-10))) || (!(OPERATEUR::egal (xyz1[1],xyz2[1],1E-10))) || (!(OPERATEUR::egal (xyz1[2],xyz2[2],1E-10))))
        {
            periodique_u=0;
            break;
        }
    }
    if (periodique_u==1)
    {
        int i=knots_u.size();
        periode_u=(knots_u[i-1]-knots_u[0]);
    }
    else periode_u=0;
    periodique_v=1;
    for (int j=0; j<nb_ptsctr_u; j++)
    {
        double *xyz3=ptsctr[j];
        double *xyz4=ptsctr[(j*nb_ptsctr_v+nb_ptsctr_v-1)];
        if ((!(OPERATEUR::egal (xyz3[0],xyz4[0],1E-10))) || (!(OPERATEUR::egal (xyz3[1],xyz4[1],1E-10))) || (!(OPERATEUR::egal (xyz3[2],xyz4[2],1E-10))))
        {
            periodique_v=0;
            break;
        }
    }
    if (periodique_v==1)
    {
        int j=knots_v.size();
        periode_v=(knots_v[j-1]-knots_v[0]);
    }
    else periode_v=0;
    umin=knots_u[0];
    umax=knots_u[knots_u.size()-1];
    vmin=knots_v[0];
    vmax=knots_v[knots_v.size()-1];
}
 
 
ST_B_SPLINE_SURF2::~ST_B_SPLINE_SURF2()
{
 
}
 
int  ST_B_SPLINE_SURF2::get_intervalle(int nb_pt, int degre, double t, std::vector<double> &knots)
{
    int inter;
    if (OPERATEUR::egal(t,knots[nb_pt],1E-12)==1) inter=nb_pt-1;
    else
    {
        int low=degre;
        int high=nb_pt+1;
        int mid=((low+high)/2);
        while ((t<knots[mid-1]) || (t>=knots[mid]))
        {
            if (t<knots[mid-1]) high=mid;
            else low=mid;
            mid=(low+high)/2;
        }
        inter=mid-1;
    }
    return inter;
}
 
void  ST_B_SPLINE_SURF2::get_valeur_fonction(int inter, double t, int degre, std::vector<double> &knots,double *grand_n)
{
    double saved;
    grand_n[0]=1.0;
    double *gauche=new double[degre];
    double *droite=new double[degre];
    for (int j=1;j<=degre;j++)
    {
        gauche[j-1]= t-knots[inter-j+1];
        droite[j-1]=knots[inter+j]-t;
        saved=0.0;
        for (int r=0;r<j;r++)
        {
            double temp=grand_n[r]/(droite[r]+ gauche[j-r-1]);
            grand_n[r]=saved+droite[r]* temp;
            saved=gauche[j-r-1]*temp;
        }
        grand_n[j]=saved;
    }
    delete [] gauche;
    delete [] droite;
}
 
 
void  ST_B_SPLINE_SURF2::evaluer(double *uv,double *xyz)
{
 
    double u = uv[0];
    double v = uv[1];
 
    if (sens==-1) u=umin+umax-u;
 
#define P(i,j) ptsctr [ (uspan - degre_u + i) * nb_ptsctr_v + (vspan - degre_v + j) ]
 
    int uspan = get_intervalle(nb_ptsctr_u,degre_u,u, knots_u);
 
    int vspan = get_intervalle(nb_ptsctr_v,degre_v,v, knots_v);
 
    double Nu[20];
    get_valeur_fonction(uspan,u,degre_u,knots_u,Nu);
 
    double Nv[20];
    get_valeur_fonction(vspan,v,degre_v,knots_v,Nv);
 
    OT_VECTEUR_4D temp[20];
 
    int l;
    for (l=0;l<=degre_v;l++) {
        temp[l] =0.0 ;
        for (int k=0;k<=degre_u;k++) {
            temp[l] += Nu[k]*P(k,l) ;
        }
    }
    OT_VECTEUR_4D sp(0,0,0,0) ;
    for (l=0;l<=degre_v;l++) {
        sp += Nv[l]*temp[l];
    }
 
    // transform homogeneous coordinates to 3D coordinates
    for (int i=0; i<3; i++)
        xyz[i] = sp[i]/sp.w();
 
#undef P
}
 
void  ST_B_SPLINE_SURF2::deriver_fonction(int inter,double t,int degre,int dd,std::vector<double> &knots,double *f_deriver)
{
#define f_deriver(i,j) (*(f_deriver+(i)*(degre+1)+j))
#define grand_n(i,j) (*(grand_n+(i)*(degre+1)+j))
#define a(i,j) (*(a+(i)*(dd+1)+j))
    double *grand_n=new double[(degre+1)*(degre+1)];
    double saved;
    grand_n(0,0)=1.0;
    double *gauche=new double[degre+1];
    double *droite=new double[degre+1];
    for (int j=1;j<=degre;j++)
    {
        gauche[j]= t-knots[inter-j+1];
        droite[j]=knots[inter+j]-t;
        saved=0.0;
        for (int r=0;r<j;r++)
        {
            grand_n(j,r)=(droite[r+1]+ gauche[j-r]);
            double temp = grand_n(r,j-1)/grand_n(j,r);
 
            grand_n(r,j)= saved+droite[r+1]*temp;
            saved=gauche[j-r]*temp;
        }
        grand_n(j,j)=saved;
    }
    for (int j=0;j<=degre;j++)
    {
        f_deriver(0,j)= grand_n(j,degre);
    }
    double *a=new double[(dd+1)*2];
    for (int r=0;r<=degre;r++)
    {
        int s1=0;
        int s2=1;
        a(0,0)=1.0;
        for (int k=1;k<=dd; k++)
        {
            double d=0.0;
            int rk=r-k;
            int pk=degre-k;
            if (r>=k)
            {
                a(s2,0)=a(s1,0)/grand_n(pk+1,rk);
                d= a(s2,0)* grand_n(rk,pk);
            }
            int j1;
            int j2;
            if (rk>=-1)   j1=1;
            else j1= -rk;
            if (r-1<=pk)  j2=k-1;
            else j2=degre-r;
            for (int j=j1;j<=j2;j++)
            {
                a(s2,j) = (a(s1,j)-a(s1,j-1))/grand_n(pk+1,rk+j);
                d+=a(s2,j)*grand_n(rk+j,pk);
            }
            if (r<=pk)
            {
                a(s2,k) = -a(s1,k-1)/grand_n(pk+1,r);
                d+=a(s2,k)*grand_n(r,pk);
            }
            f_deriver(k,r)=d;
            int j=s1;
            s1=s2;
            s2=j;
        }
    }
    int r=degre;
    for (int k=1;k<=dd;k++)
    {
        for (int j=0;j<=degre;j++)
        {
            f_deriver(k,j)*=r;
        }
        r*=(degre-k);
    }
    delete [] a;
    delete [] grand_n;
    delete [] gauche;
    delete [] droite;
#undef f_deriver
#undef grand_n
#undef a
}
 
void ST_B_SPLINE_SURF2::binomialCoef(double * Bin, int d) {
    int n,k;
    // Setup the first line
    Bin[0] = 1.0 ;
    for (k=d-1;k>0;--k)
        Bin[k] = 0.0 ;
    // Setup the other lines
    for (n=0;n<d-1;n++) {
        Bin[(n+1)*d+0] = 1.0 ;
        for (k=1;k<d;k++)
            if (n+1<k)
                Bin[(n+1)*d+k] = 0.0 ;
            else
                Bin[(n+1)*d+k] = Bin[n*d+k] + Bin[n*d+k-1] ;
    }
}
 
void  ST_B_SPLINE_SURF2::deriver_bs_kieme(int nb_ptsctr_u,int degre_u,std::vector<double> &knots_u,int nb_ptsctr_v,int degre_v,std::vector<double> &knots_v,double u,double v,int d,OT_VECTEUR_4D * skl)
{
#define skl(i,j) skl[(i)*(d+1)+j]
#define Nu(i,j) Nu[(i)*(degre_u+1)+j]
#define Nv(i,j) Nv[(i)*(degre_v+1)+j]
#define P(i,j) ptsctr[(i)*(nb_ptsctr_v)+j]
 
    int i,j,k,l,s,r,dd;
 
    int du = std::min(d,degre_u);
    for ( k=degre_u+1;k<=d;k++)
    {
        for (int l=0;l<=d-k;k++)
        {
            skl(k,l)=0.0;
        }
    }
    int dv = std::min(d,degre_v);
    for ( l=degre_v+1;l<=d;l++)
    {
        for ( k=0;k<=d-l;k++)
        {
            skl(k,l)=0.0;
        }
    }
 
    int  inter_u = get_intervalle(nb_ptsctr_u,degre_u,u, knots_u);
    double Nu [ 256 ];
    deriver_fonction(inter_u,u,degre_u,du,knots_u,Nu);
 
    int  inter_v = get_intervalle(nb_ptsctr_v,degre_v,v, knots_v);
    double Nv [ 256 ];
    deriver_fonction(inter_v,v,degre_v,dv,knots_v,Nv);
 
    OT_VECTEUR_4D temp [ 16 ];
    for ( k=0; k<=du;k++)
    {
        for ( s=0; s<=degre_v;s++)
        {
            temp[s]=0.0;
            for ( r=0; r<=degre_u;r++)
                temp[s]+=P((inter_u-degre_u+r),(inter_v-degre_v+s))*Nu(k,r);
        }
        dd = std::min(d-k,dv);
        for ( l=0; l<=dd;l++)
        {
            skl(k,l) = 0.0;
            for ( s=0; s<=degre_v;s++)
                skl(k,l) += temp[s]*Nv(l,s);
        }
    }
 
#undef skl
#undef f_deriver_u
#undef f_deriver_v
#undef P
}
 
void  ST_B_SPLINE_SURF2::deriver_kieme(double *uv,int d,OT_VECTEUR_4D *skl)
{
#define skl(i,j) (*(skl+(i)*(d+1)+j))
#define ders(i,j) (*(ders+(i)*(d+1)+j))
    double u = uv[0];
    double v = uv[1];
    int i,j,k,l;
    OT_VECTEUR_4D pv,pv2;
 
    OT_VECTEUR_4D ders [256];
 
    double Bin[256];
    int dbin=std::max(degre_u, degre_v);
    binomialCoef(Bin, dbin);
#define Bin(i,j) (*(Bin+(i)*(dbin)+j))
 
    deriver_bs_kieme(nb_ptsctr_u,degre_u,knots_u,nb_ptsctr_v,degre_v,knots_v,u,v,d,ders);
 
    for (k=0;k<=d;++k)
    {
        for (l=0;l<=d-k;++l)
        {
            pv = ders(k,l);
            for (j=1;j<=l;j++)
                pv -= Bin(l,j)*ders(0,j).w()*skl(k,l-j) ;
            for (i=1;i<=k;i++)
            {
                pv -= Bin(k,i)*ders(i,0).w()*skl(k-i,l) ;
                pv2 = 0.0 ;
                for (j=1;j<=l;j++)
                    pv2 += Bin(l,j)*ders(i,j).w()*skl(k-i,l-j) ;
                pv -= Bin(k,i)*pv2 ;
            }
            skl(k,l) = pv;
            skl(k,l) /= ders[0].w();
        }
    }
#undef skl
#undef ders
#undef Bin
}
 
 
void  ST_B_SPLINE_SURF2::deriver(double *uv,double *xyzdu, double *xyzdv)
{
    OT_VECTEUR_4D skl[4];
    double uvl[3];
    uvl[0]=uv[0];
    uvl[1]=uv[1];
    if (sens==-1) uvl[0]=umin+umax-uvl[0];
    deriver_kieme(uvl,1,skl);
#define skl(i,j) skl[(i)*(2)+j]
 
    for (int i=0; i<3; i++)
        xyzdu[i] = sens * skl(1,0)[i];
 
    for (int i=0; i<3; i++)
        xyzdv[i]=skl(0,1)[i];
 
#undef skl
}
 
void  ST_B_SPLINE_SURF2::deriver_seconde(double *uv,double* xyzduu,double* xyzduv,double* xyzdvv,double *xyz, double *xyzdu, double *xyzdv)
{
#define skl(i,j) skl[(i)*(3)+j]
    OT_VECTEUR_4D skl[9];
 
    double uvl[3];
    uvl[0]=uv[0];
    uvl[1]=uv[1];
    if (sens==-1) uvl[0]=umin+umax-uvl[0];
    deriver_kieme(uvl,2,skl);
 
    for (int i=0; i<3; i++)
        xyzduu[i]=skl(2,0)[i];
 
    for (int i=0; i<3; i++)
        xyzduv[i] = sens * skl(1,1)[i];
 
    for (int i=0; i<3; i++)
        xyzdvv[i]=skl(0,2)[i];
 
    if ((xyzdu!=NULL) && (xyzdv!=NULL ) )
    {
        for (int i=0; i<3; i++)
            xyzdu[i] = sens * skl(1,0)[i];
 
        for (int i=0; i<3; i++)
            xyzdv[i]=skl(0,1)[i];
    }
    if (xyz!=NULL)
    {
        for (int i=0; i<3; i++)
            xyz[i]=skl(0,0)[i];
    }
 
    unsigned kk, kkk;
    double LIMITE = 1E99;
    for (kk = 0; kk<3; kk++)
        if (  (xyzduu[kk] > LIMITE ) || (xyzduv[kk] > LIMITE ) || (xyzdvv[kk] > LIMITE ) )
            break;
    if (kk < 3)
    {
        deriver_seconde(uv,xyzduu,xyzduv,xyzdvv,xyz, xyzdu, xyzdv);
        printf("pb");
    }
 
#undef skl
}
 
void  ST_B_SPLINE_SURF2::inverser(double *uv,double *xyz,double precision)
{
    int code;
    int num_point=(nb_ptsctr_u+nb_ptsctr_v)/2;
    do
    {
        code=inverser2(uv,xyz,num_point,precision);
        num_point=num_point*2;
    }
    while (code==0);
}
 
 
int  ST_B_SPLINE_SURF2::inverser2(double *uv,double *xyz,int num_test, double precision)
{
    double uvi[2];
    double xyz1[3];
    double xyzdu[3];
    double xyzdv[3];
    double xyzduu[3];
    double xyzduv[3];
    double xyzdvv[3];
    OT_VECTEUR_3D Pt(xyz[0],xyz[1],xyz[2]);
    double a[4];
    double delta[2];
    double b[9];
    double delta_u;
    double delta_v;
    double ui;
    double vi;
 
    double distance_ref=1e308;
    int refu;
    int refv;
 
    for (int ii=0;ii<num_test+1;ii++)
    {
        double u=umin+ii*1./num_test*(umax-umin);
        uvi[0]=u;
        for (int jj=0;jj<num_test+1;jj++)
        {
            double v=vmin+jj*1./num_test*(vmax-vmin);
            uvi[1]=v;
            evaluer(uvi,xyz1);
            OT_VECTEUR_3D S(xyz1[0],xyz1[1],xyz1[2]);
            OT_VECTEUR_3D Distance = S-Pt;
            double longueur=Distance.get_longueur2();
            if (longueur<distance_ref)
            {
                distance_ref=longueur;
                refu=ii;
                refv=jj;
            }
        }
    }
 
    double uii=umin+refu*1./num_test*(umax-umin);
    double vii=vmin+refv*1./num_test*(vmax-vmin);
    int compteur = 0;
    do
    {
        compteur++;
        ui=uii;
        vi=vii;
        uvi[0]=ui;
        uvi[1]=vi;
        deriver_seconde(uvi,xyzduu,xyzduv,xyzdvv,xyz1,xyzdu,xyzdv);
        OT_VECTEUR_3D S(xyz1[0],xyz1[1],xyz1[2]);
        OT_VECTEUR_3D Su(xyzdu[0],xyzdu[1],xyzdu[2]);
        OT_VECTEUR_3D Sv(xyzdv[0],xyzdv[1],xyzdv[2]);
        OT_VECTEUR_3D Suu(xyzduu[0],xyzduu[1],xyzduu[2]);
        OT_VECTEUR_3D Suv(xyzduv[0],xyzduv[1],xyzduv[2]);
        OT_VECTEUR_3D Svv(xyzdvv[0],xyzdvv[1],xyzdvv[2]);
        OT_VECTEUR_3D Distance = S-Pt;
        a[0]=Su.get_longueur2()+Distance*Suu;
        a[1]=Su*Sv+Distance*Suv;
        a[2]=Su*Sv+Distance*Suv;
        a[3]=Sv.get_longueur2()+Distance*Svv;
        b[0]=Distance*Su;
        b[0]=-b[0];
        b[1]=Distance*Sv;
        b[1]=-b[1];
        double delta=1./(a[0]*a[3]-a[2]*a[1]);
        delta_u=delta*(b[0]*a[3]-b[1]*a[1]);
        delta_v=delta*(a[0]*b[1]-a[2]*b[0]);
        uii=ui+delta_u;
        vii=vi+delta_v;
        if (periodique_u==0)
        {
            if (uii<umin) uii=umin;
            if (uii>umax) uii=umax;
        }
        if (periodique_v==0)
        {
            if (vii<vmin) vii=vmin;
            if (vii>vmax) vii=vmax;
        }
        if (periodique_u==1)
        {
            if (uii<umin) uii=umax - (umin-uii);
            if (uii>umax) uii=umin + (uii-umax);
        }
        if (periodique_v==1)
        {
            if (vii<vmin) vii=vmax - (vmin-vii);
            if (vii>vmax) vii=vmin + (vii-vmax);
        }
        delta_u=uii-ui;
        delta_v=vii-vi;
        if (compteur>500) return 0;
    }
 
    while ((fabs(delta_u)>precision)||(fabs(delta_v)>precision));
    uv[0]=uii;
    uv[1]=vii;
    return 1;
}
 
int ST_B_SPLINE_SURF2::est_periodique_u(void)
{
    return periodique_u;
}
int ST_B_SPLINE_SURF2::est_periodique_v(void)
{
    return periodique_v;
}
double ST_B_SPLINE_SURF2::get_periode_u(void)
{
    return periode_u;
}
double ST_B_SPLINE_SURF2::get_periode_v(void)
{
    return periode_v;
}
double  ST_B_SPLINE_SURF2::get_umin(void)
{
    return umin;
}
double  ST_B_SPLINE_SURF2::get_umax(void)
{
    return umax;
}
double  ST_B_SPLINE_SURF2::get_vmin(void)
{
    return vmin;
}
double  ST_B_SPLINE_SURF2::get_vmax(void)
{
    return vmax;
}
 
int ST_B_SPLINE_SURF2::get_type_geometrique(TPL_LISTE_ENTITE<double> &param)
{
    for (int i=0;i<nb_ptsctr_u-(degre_u+1);i++)
    {
        param.ajouter(knots_u[i]);
    }
    for (int i=0;i<nb_ptsctr_v-(degre_v+1);i++)
    {
        param.ajouter(knots_v[i]);
    }
    double xyz[3];
    for (int i=0;i<nb_point;i++)
    {
        param.ajouter(ptsctr[i].x()/ptsctr[i].w());
        param.ajouter(ptsctr[i].y()/ptsctr[i].w());
        param.ajouter(ptsctr[i].z()/ptsctr[i].w());
    }
    for (int i=0;i<nb_point;i++)
    {
        param.ajouter(ptsctr[i].w());
    }
    param.ajouter(degre_u);
    param.ajouter(degre_v);
    return GEOMETRIE::CONST::Co_BSPLINES;
}
 
void ST_B_SPLINE_SURF2::initialiser(class ST_GESTIONNAIRE* gest)
{
    for (int i=0;i<nb_point;i++)
    {
        ST_POINT* stpoint=gest->lst_point.getid(indexptsctr[i]);
        double xyz[3];
        stpoint->evaluer(xyz);
        double w=1.0;
        ptsctr.push_back(OT_VECTEUR_4D(w*xyz[0],w*xyz[1],w*xyz[2],w));
    }
 
    periodique_u=1;
    for (int i=0; i<nb_ptsctr_v; i++)
    {
        ST_POINT* point1_u=gest->lst_point.getid(indexptsctr[i]);
        ST_POINT* point2_u=gest->lst_point.getid(indexptsctr[nb_ptsctr_v*(nb_ptsctr_u-1)+i]);
        double xyz1[3];
        double xyz2[3];
        point1_u->evaluer(xyz1);
        point2_u->evaluer(xyz2);
        if ((!(OPERATEUR::egal (xyz1[0],xyz2[0],1E-10))) || (!(OPERATEUR::egal (xyz1[1],xyz2[1],1E-10))) || (!(OPERATEUR::egal (xyz1[2],xyz2[2],1E-10))))
        {
            periodique_u=0;
        }
    }
    if (periodique_u==1)
    {
        int i=knots_u.size();
        periode_u=(knots_u[i-1]-knots_u[0]);
    }
    else periode_u=0;
    periodique_v=1;
    for (int j=0; j<nb_ptsctr_u; j++)
    {
        ST_POINT* point1_v=gest->lst_point.getid(indexptsctr[j*nb_ptsctr_v]);
        ST_POINT* point2_v=gest->lst_point.getid(indexptsctr[j*nb_ptsctr_v+nb_ptsctr_v-1]);
        double xyz3[3];
        double xyz4[3];
        point1_v->evaluer(xyz3);
        point2_v->evaluer(xyz4);
        if ((!(OPERATEUR::egal (xyz3[0],xyz4[0],1E-10))) || (!(OPERATEUR::egal (xyz3[1],xyz4[1],1E-10))) || (!(OPERATEUR::egal (xyz3[2],xyz4[2],1E-10))))
        {
            periodique_v=0;
        }
    }
    if (periodique_v==1)
    {
        int j=knots_v.size();
        periode_v=(knots_v[j-1]-knots_v[0]);
    }
    else periode_v=0;
}
 
 
 
void ST_B_SPLINE_SURF2::est_util(ST_GESTIONNAIRE* gest)
{
    util=true;
    for (int i=0;i<nb_point;i++)
        gest->lst_point.getid(indexptsctr[i])->est_util(gest);
}