mtu/src/vct_surface.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/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       vct_surface.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:53 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#include "gestionversion.h"


#pragma hdrstop
#include<math.h>
#include "vct_surface.h"
#include "mg_surface.h"
#include <iomanip>
#include "vct_outils.h"
#include "constantegeo.h"

#pragma package(smart_init)


VCT_SURFACE::VCT_SURFACE(MG_SURFACE* elemgeo):VCT_ELEMENT_GEOMETRIQUE(elemgeo)
{
    int  indx_premier_ptctr;
    TPL_LISTE_ENTITE<double> nurbs_params;
    TPL_LISTE_ENTITE<double> param_surf;
    elem_geo->get_param_NURBS(indx_premier_ptctr,nurbs_params);
    int nb_points=1/4.*(nurbs_params.get_nb()-indx_premier_ptctr);
    int nb_u=nurbs_params.get(3);
    int nb_v=nurbs_params.get(4);

    for (int pt=0;pt< nb_points;pt++)
    {
        OT_VECTEUR_4DD V1;
        V1[0]=nurbs_params.get( indx_premier_ptctr+  4 * pt);
        V1[1]=nurbs_params.get( indx_premier_ptctr+  4 * pt + 1);
        V1[2]=nurbs_params.get( indx_premier_ptctr+  4 * pt + 2);
        V1[3]=nurbs_params.get( indx_premier_ptctr+  4 * pt + 3);
        lst_points.insert(lst_points.end(),V1);
    }

    for (int j=0;j<nb_v-1;j++)
        for (int i=0;i<nb_u-1;i++)
        {
            OT_VECTEUR_4DD P1=lst_points[j*nb_u+i];
            OT_VECTEUR_4DD P2=lst_points[j*nb_u+i+1];
            OT_VECTEUR_4DD P3=lst_points[(j+1)*nb_u+i];
            OT_VECTEUR_4DD V1=P2-P1;
            if (!V1.est_nul_3d())
              {
              V1=V1.vecteur_norme_3d();
              lst_vecteurs.insert(lst_vecteurs.end(),V1);
              }
            
            OT_VECTEUR_4DD V2=P3-P1;
            if (!V2.est_nul_3d())
              {
              V2=V2.vecteur_norme_3d();
              lst_vecteurs.insert(lst_vecteurs.end(),V2);
              }
        }
    for (int i=0;i<nb_u-1;i++)
    {
        OT_VECTEUR_4DD P1=lst_points[(nb_v-1)*nb_u+i];
        OT_VECTEUR_4DD P2=lst_points[(nb_v-1)*nb_u+i+1];
        OT_VECTEUR_4DD V1=P2-P1;
        if (V1.est_nul_3d()) continue;
        V1=V1.vecteur_norme_3d();
        lst_vecteurs.insert(lst_vecteurs.end(),V1);
    }
    for (int i=0;i<nb_v-1;i++)
    {
        OT_VECTEUR_4DD P1=lst_points[i*nb_u+nb_u-1];
        OT_VECTEUR_4DD P2=lst_points[(i+1)*nb_u+nb_u-1];
        OT_VECTEUR_4DD V1=P2-P1;
        if (V1.est_nul_3d()) continue;
        V1=V1.vecteur_norme_3d();
        lst_vecteurs.insert(lst_vecteurs.end(),V1);
    }

    /*double2 ZERO=0.;
    double2 INF=1e6;
    OT_VECTEUR_4DD VCT_NUL(0.,0.,0.,0.);
    int type=0;
    if(((MG_SURFACE*)elem_geo)->get_type_geometrique(param_surf)==MGCo_PLAN)
    {
     type=1;
    }
    if(((MG_SURFACE*)elem_geo)->get_type_geometrique(param_surf)==MGCo_CYLINDRE)
    {
     type=2;
    }

    OT_VECTEUR_4DD V1,V2,V;

    for(int pt=0;pt< nb_points;pt++)
    {
               V1[0]=nurbs_params.get( indx_premier_ptctr+  4 * pt);
               V1[1]=nurbs_params.get( indx_premier_ptctr+  4 * pt + 1);
               V1[2]=nurbs_params.get( indx_premier_ptctr+  4 * pt + 2);
               V1[3]=nurbs_params.get( indx_premier_ptctr+  4 * pt + 3);
               //if (pt==0) lst_points.insert(lst_points.end(),V1);

               lst_points.insert(lst_points.end(),V1);
                              if(type==2)
                               {
                                 if (pt==0|| pt==3||pt==7|| pt==10)
                                  {
                                   lst_points_axes.insert(lst_points_axes.end(),V1);
                                  }
                               }
                              if(!type||type==1)
                              {
                              lst_points_axes.insert(lst_points_axes.end(),V1);

                              }
    }


    if(!type||type==1)
      for(int r=0;r<nb_v;r++)
        {
         for(int s=0;s<nb_u-1;s++)
           {

               V1[0]=nurbs_params.get( indx_premier_ptctr+ r *4 * nb_u + 4 * s);
               V1[1]=nurbs_params.get( indx_premier_ptctr+ r *4 * nb_u + 4 * s + 1);
               V1[2]=nurbs_params.get( indx_premier_ptctr+ r *4 * nb_u + 4 * s + 2);
               V1[3]=nurbs_params.get( indx_premier_ptctr+ r *4 * nb_u + 4 * s + 3);


               V2[0]=nurbs_params.get( indx_premier_ptctr+ r *4 * nb_u + 4 * (s + 1));
               V2[1]=nurbs_params.get( indx_premier_ptctr+ r *4 * nb_u + 4 * (s + 1) + 1);
               V2[2]=nurbs_params.get( indx_premier_ptctr+ r *4 * nb_u + 4 * (s + 1) + 2);
               V2[3]=nurbs_params.get( indx_premier_ptctr+ r *4 * nb_u + 4 * (s + 1) + 3);


               V=V2-V1;

               double2 norm_au_carre=(V[0]*V[0])+(V[1]*V[1])+(V[2]*V[2])+(V[3]*V[3]);
               double2 norm=norm_au_carre^0.5;

               if(V==VCT_NUL)   {
                   lst_vecteurs.insert(lst_vecteurs.end(),VCT_NUL);
                   if(!type||type==1)
                   lst_vecteurs_axes.insert(lst_vecteurs_axes.end(),VCT_NUL);
                   }

               if(norm!=ZERO){
               V=1./norm*V;
               lst_vecteurs.insert(lst_vecteurs.end(),V);
               if(!type||type==1)
               lst_vecteurs_axes.insert(lst_vecteurs_axes.end(),V);
               }

            }
           }

         for(int r=0;r<nb_v-1;r++)
           {
          for(int s=0;s<nb_u;s++)
           {
               V1[0]=nurbs_params.get(indx_premier_ptctr+ r * 4 * nb_u + 4 * s);
               V1[1]=nurbs_params.get(indx_premier_ptctr+ r * 4 * nb_u + 4 * s + 1);
               V1[2]=nurbs_params.get(indx_premier_ptctr+ r * 4 * nb_u + 4 * s + 2);
               V1[3]=nurbs_params.get(indx_premier_ptctr+ r * 4 * nb_u + 4 * s + 3);


               V2[0]=nurbs_params.get(indx_premier_ptctr+ (r+1) *4 *  nb_u + 4 * s);
               V2[1]=nurbs_params.get(indx_premier_ptctr+ (r+1) *4 *  nb_u + 4 * s + 1);
               V2[2]=nurbs_params.get(indx_premier_ptctr+ (r+1) *4 *  nb_u + 4 * s + 2);
               V2[3]=nurbs_params.get(indx_premier_ptctr+ (r+1) *4 *  nb_u + 4 * s + 3);


               V=V2-V1;

               double2 norm_au_carre=(V[0]*V[0])+(V[1]*V[1])+(V[2]*V[2])+(V[3]*V[3]);
               double2 norm=norm_au_carre^0.5;

               if(V==VCT_NUL) {
                   lst_vecteurs.insert(lst_vecteurs.end(),VCT_NUL);
                   if(!type||type==1)
                   lst_vecteurs_axes.insert(lst_vecteurs_axes.end(),VCT_NUL);
                   }

               if (norm!=ZERO){
               V=1./norm*V;
               lst_vecteurs.insert(lst_vecteurs.end(),V);
               if(!type||type==1)
               lst_vecteurs_axes.insert(lst_vecteurs_axes.end(),V);

               }
               }
             }

       if(type==2)
         {
               vector<OT_VECTEUR_4DD> lst_pts;
               lst_pts.insert(lst_pts.end(),lst_points_axes[0] ) ;
               lst_pts.insert(lst_pts.end(),lst_points_axes[1] ) ;
               lst_pts.insert(lst_pts.end(),lst_points_axes[3] ) ;
               lst_pts.insert(lst_pts.end(),lst_points_axes[2] ) ;
                  for(int r=0;r<lst_pts.size();r++)
                     {     OT_VECTEUR_4DD V;
                           if(r<lst_pts.size()-1)
                             V=lst_pts[r+1]-lst_pts[r];
                           if(r==lst_pts.size()-1)
                             V=lst_pts[0]-lst_pts[r];
                            double2 norm_au_carre=(V[0]*V[0])+(V[1]*V[1])+(V[2]*V[2])+(V[3]*V[3]);
                            double2 norm=norm_au_carre^0.5;
                             if(V==VCT_NUL)
                               lst_vecteurs.insert(lst_vecteurs.end(),VCT_NUL);
                             if(norm!=ZERO)
                               {
                               V=1./norm*V;
                               lst_vecteurs_axes.insert(lst_vecteurs_axes.end(),V);
                               }
                     }

                     OT_VECTEUR_4DD V=lst_vecteurs_axes[1];
                     lst_vecteurs_axes[1]=lst_vecteurs_axes[2];
                     lst_vecteurs_axes[2]=V;

         }

    */
    construire_forme_tensorielle();
}


VCT_SURFACE::VCT_SURFACE(VCT_SURFACE& mdd):VCT_ELEMENT_GEOMETRIQUE(mdd.elem_geo)
{

}


VCT_SURFACE::~VCT_SURFACE()
{
}


Revision:	1158
Committed:	Thu Jun 13 22:18:49 2024 UTC (11 months, 1 week ago) by francois
File size:	9097 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			//####// vct_surface.cpp
15			//####//
16			//####//------------------------------------------------------------
17			//####//------------------------------------------------------------
18			//####// COPYRIGHT 2000-2024
19			//####// jeu 13 jun 2024 11:58:53 EDT
20			//####//------------------------------------------------------------
21			//####//------------------------------------------------------------
22	francois	283	#include "gestionversion.h"
23
24
25
26			#pragma hdrstop
27			#include<math.h>
28			#include "vct_surface.h"
29			#include "mg_surface.h"
30			#include <iomanip>
31			#include "vct_outils.h"
32			#include "constantegeo.h"
33
34			#pragma package(smart_init)
35
36
37			VCT_SURFACE::VCT_SURFACE(MG_SURFACE* elemgeo):VCT_ELEMENT_GEOMETRIQUE(elemgeo)
38			{
39			int indx_premier_ptctr;
40			TPL_LISTE_ENTITE<double> nurbs_params;
41			TPL_LISTE_ENTITE<double> param_surf;
42			elem_geo->get_param_NURBS(indx_premier_ptctr,nurbs_params);
43			int nb_points=1/4.*(nurbs_params.get_nb()-indx_premier_ptctr);
44			int nb_u=nurbs_params.get(3);
45			int nb_v=nurbs_params.get(4);
46
47			for (int pt=0;pt< nb_points;pt++)
48			{
49			OT_VECTEUR_4DD V1;
50			V1[0]=nurbs_params.get( indx_premier_ptctr+ 4 * pt);
51			V1[1]=nurbs_params.get( indx_premier_ptctr+ 4 * pt + 1);
52			V1[2]=nurbs_params.get( indx_premier_ptctr+ 4 * pt + 2);
53			V1[3]=nurbs_params.get( indx_premier_ptctr+ 4 * pt + 3);
54			lst_points.insert(lst_points.end(),V1);
55			}
56
57			for (int j=0;j<nb_v-1;j++)
58			for (int i=0;i<nb_u-1;i++)
59			{
60			OT_VECTEUR_4DD P1=lst_points[j*nb_u+i];
61			OT_VECTEUR_4DD P2=lst_points[j*nb_u+i+1];
62			OT_VECTEUR_4DD P3=lst_points[(j+1)*nb_u+i];
63			OT_VECTEUR_4DD V1=P2-P1;
64	francois	743	if (!V1.est_nul_3d())
65			{
66			V1=V1.vecteur_norme_3d();
67			lst_vecteurs.insert(lst_vecteurs.end(),V1);
68			}
69
70	francois	283	OT_VECTEUR_4DD V2=P3-P1;
71	francois	743	if (!V2.est_nul_3d())
72			{
73			V2=V2.vecteur_norme_3d();
74			lst_vecteurs.insert(lst_vecteurs.end(),V2);
75			}
76	francois	283	}
77			for (int i=0;i<nb_u-1;i++)
78			{
79			OT_VECTEUR_4DD P1=lst_points[(nb_v-1)*nb_u+i];
80			OT_VECTEUR_4DD P2=lst_points[(nb_v-1)*nb_u+i+1];
81			OT_VECTEUR_4DD V1=P2-P1;
82	francois	743	if (V1.est_nul_3d()) continue;
83			V1=V1.vecteur_norme_3d();
84	francois	283	lst_vecteurs.insert(lst_vecteurs.end(),V1);
85			}
86			for (int i=0;i<nb_v-1;i++)
87			{
88			OT_VECTEUR_4DD P1=lst_points[i*nb_u+nb_u-1];
89			OT_VECTEUR_4DD P2=lst_points[(i+1)*nb_u+nb_u-1];
90			OT_VECTEUR_4DD V1=P2-P1;
91	francois	743	if (V1.est_nul_3d()) continue;
92	francois	363	V1=V1.vecteur_norme_3d();
93	francois	283	lst_vecteurs.insert(lst_vecteurs.end(),V1);
94			}
95
96			/*double2 ZERO=0.;
97			double2 INF=1e6;
98			OT_VECTEUR_4DD VCT_NUL(0.,0.,0.,0.);
99			int type=0;
100			if(((MG_SURFACE*)elem_geo)->get_type_geometrique(param_surf)==MGCo_PLAN)
101			{
102			type=1;
103			}
104			if(((MG_SURFACE*)elem_geo)->get_type_geometrique(param_surf)==MGCo_CYLINDRE)
105			{
106			type=2;
107			}
108
109			OT_VECTEUR_4DD V1,V2,V;
110
111			for(int pt=0;pt< nb_points;pt++)
112			{
113			V1[0]=nurbs_params.get( indx_premier_ptctr+ 4 * pt);
114			V1[1]=nurbs_params.get( indx_premier_ptctr+ 4 * pt + 1);
115			V1[2]=nurbs_params.get( indx_premier_ptctr+ 4 * pt + 2);
116			V1[3]=nurbs_params.get( indx_premier_ptctr+ 4 * pt + 3);
117			//if (pt==0) lst_points.insert(lst_points.end(),V1);
118
119			lst_points.insert(lst_points.end(),V1);
120			if(type==2)
121			{
122			if (pt==0\|\| pt==3\|\|pt==7\|\| pt==10)
123			{
124			lst_points_axes.insert(lst_points_axes.end(),V1);
125			}
126			}
127			if(!type\|\|type==1)
128			{
129			lst_points_axes.insert(lst_points_axes.end(),V1);
130
131			}
132			}
133
134
135
136			if(!type\|\|type==1)
137			for(int r=0;r<nb_v;r++)
138			{
139			for(int s=0;s<nb_u-1;s++)
140			{
141
142			V1[0]=nurbs_params.get( indx_premier_ptctr+ r 4 nb_u + 4 * s);
143			V1[1]=nurbs_params.get( indx_premier_ptctr+ r 4 nb_u + 4 * s + 1);
144			V1[2]=nurbs_params.get( indx_premier_ptctr+ r 4 nb_u + 4 * s + 2);
145			V1[3]=nurbs_params.get( indx_premier_ptctr+ r 4 nb_u + 4 * s + 3);
146
147
148
149			V2[0]=nurbs_params.get( indx_premier_ptctr+ r 4 nb_u + 4 * (s + 1));
150			V2[1]=nurbs_params.get( indx_premier_ptctr+ r 4 nb_u + 4 * (s + 1) + 1);
151			V2[2]=nurbs_params.get( indx_premier_ptctr+ r 4 nb_u + 4 * (s + 1) + 2);
152			V2[3]=nurbs_params.get( indx_premier_ptctr+ r 4 nb_u + 4 * (s + 1) + 3);
153
154
155
156			V=V2-V1;
157
158			double2 norm_au_carre=(V[0]V[0])+(V[1]V[1])+(V[2]V[2])+(V[3]V[3]);
159			double2 norm=norm_au_carre^0.5;
160
161			if(V==VCT_NUL) {
162			lst_vecteurs.insert(lst_vecteurs.end(),VCT_NUL);
163			if(!type\|\|type==1)
164			lst_vecteurs_axes.insert(lst_vecteurs_axes.end(),VCT_NUL);
165			}
166
167			if(norm!=ZERO){
168			V=1./norm*V;
169			lst_vecteurs.insert(lst_vecteurs.end(),V);
170			if(!type\|\|type==1)
171			lst_vecteurs_axes.insert(lst_vecteurs_axes.end(),V);
172			}
173
174			}
175			}
176
177			for(int r=0;r<nb_v-1;r++)
178			{
179			for(int s=0;s<nb_u;s++)
180			{
181			V1[0]=nurbs_params.get(indx_premier_ptctr+ r * 4 * nb_u + 4 * s);
182			V1[1]=nurbs_params.get(indx_premier_ptctr+ r * 4 * nb_u + 4 * s + 1);
183			V1[2]=nurbs_params.get(indx_premier_ptctr+ r * 4 * nb_u + 4 * s + 2);
184			V1[3]=nurbs_params.get(indx_premier_ptctr+ r * 4 * nb_u + 4 * s + 3);
185
186
187
188			V2[0]=nurbs_params.get(indx_premier_ptctr+ (r+1) 4 nb_u + 4 * s);
189			V2[1]=nurbs_params.get(indx_premier_ptctr+ (r+1) 4 nb_u + 4 * s + 1);
190			V2[2]=nurbs_params.get(indx_premier_ptctr+ (r+1) 4 nb_u + 4 * s + 2);
191			V2[3]=nurbs_params.get(indx_premier_ptctr+ (r+1) 4 nb_u + 4 * s + 3);
192
193
194			V=V2-V1;
195
196			double2 norm_au_carre=(V[0]V[0])+(V[1]V[1])+(V[2]V[2])+(V[3]V[3]);
197			double2 norm=norm_au_carre^0.5;
198
199			if(V==VCT_NUL) {
200			lst_vecteurs.insert(lst_vecteurs.end(),VCT_NUL);
201			if(!type\|\|type==1)
202			lst_vecteurs_axes.insert(lst_vecteurs_axes.end(),VCT_NUL);
203			}
204
205			if (norm!=ZERO){
206			V=1./norm*V;
207			lst_vecteurs.insert(lst_vecteurs.end(),V);
208			if(!type\|\|type==1)
209			lst_vecteurs_axes.insert(lst_vecteurs_axes.end(),V);
210
211			}
212			}
213			}
214
215			if(type==2)
216			{
217			vector<OT_VECTEUR_4DD> lst_pts;
218			lst_pts.insert(lst_pts.end(),lst_points_axes[0] ) ;
219			lst_pts.insert(lst_pts.end(),lst_points_axes[1] ) ;
220			lst_pts.insert(lst_pts.end(),lst_points_axes[3] ) ;
221			lst_pts.insert(lst_pts.end(),lst_points_axes[2] ) ;
222			for(int r=0;r<lst_pts.size();r++)
223			{ OT_VECTEUR_4DD V;
224			if(r<lst_pts.size()-1)
225			V=lst_pts[r+1]-lst_pts[r];
226			if(r==lst_pts.size()-1)
227			V=lst_pts[0]-lst_pts[r];
228			double2 norm_au_carre=(V[0]V[0])+(V[1]V[1])+(V[2]V[2])+(V[3]V[3]);
229			double2 norm=norm_au_carre^0.5;
230			if(V==VCT_NUL)
231			lst_vecteurs.insert(lst_vecteurs.end(),VCT_NUL);
232			if(norm!=ZERO)
233			{
234			V=1./norm*V;
235			lst_vecteurs_axes.insert(lst_vecteurs_axes.end(),V);
236			}
237			}
238
239			OT_VECTEUR_4DD V=lst_vecteurs_axes[1];
240			lst_vecteurs_axes[1]=lst_vecteurs_axes[2];
241			lst_vecteurs_axes[2]=V;
242
243			}
244
245			*/
246			construire_forme_tensorielle();
247			}
248
249
250
251
252
253
254			VCT_SURFACE::VCT_SURFACE(VCT_SURFACE& mdd):VCT_ELEMENT_GEOMETRIQUE(mdd.elem_geo)
255			{
256
257			}
258
259
260			VCT_SURFACE::~VCT_SURFACE()
261			{
262			}
263
264