geometrie/src/CAD4FE_PolySurface.cpp

//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
// include MAGIC Headers
#include "gestionversion.h"
#include "mg_geometrie.h"
#include "mg_arete.h"
#include "tpl_fonction.h"

//---------------------------------------------------------------------------
// include STL headers
//---------------------------------------------------------------------------
#include <map>
#include <ostream>
#include <string>
#include <vector>
//---------------------------------------------------------------------------


#pragma hdrstop

#include "CAD4FE_PolySurface.h"
#include "CAD4FE_MCVertex.h"
#include "ot_mathematique.h"
#include "math.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)

#ifdef __BORLANDC__
#pragma warn -8012
#endif

using namespace CAD4FE;

//---------------------------------------------------------------------------
PolySurface::PolySurface(MG_FACE * __refFace)
{
    // Add the reference face in the list of faces
    _lst_ref_faces.insert(__refFace);
}
//---------------------------------------------------------------------------

void PolySurface::InsertSurface(MG_FACE *__refFace)
{
    // Add the reference face in the list of faces
    _lst_ref_faces.insert(__refFace);
}
//---------------------------------------------------------------------------

void PolySurface::Merge( PolySurface & __polySurface )
{
    // Add the reference faces in the list of faces
    std::set<MG_FACE*> & r = __polySurface._lst_ref_faces;

    for (std::set<MG_FACE*>::iterator itRefFace = r.begin();
            itRefFace != r.end();
            itRefFace++)
        _lst_ref_faces.insert(*itRefFace);
}

//---------------------------------------------------------------------------

void PolySurface::evaluer(double *uv,double *xyz)
{

}

//---------------------------------------------------------------------------

void PolySurface::deriver(double *uv,double *xyzdu, double *xyzdv)
{

}


//---------------------------------------------------------------------------
void PolySurface::deriver_seconde(double *uv,double* xyzduu,double* xyzduv,double* xyzdvv,double *xyz, double *xyzdu, double *xyzdv)
{

}


//---------------------------------------------------------------------------
void PolySurface::inverser(double *uv,double *xyz,double precision)
{

}

//---------------------------------------------------------------------------

int PolySurface::est_periodique_u(void)
{

    return 0;
}


//---------------------------------------------------------------------------
int PolySurface::est_periodique_v(void)
{

    return 0;
}


//---------------------------------------------------------------------------
double PolySurface::get_periode_u(void)
{

    return 0;
}

//---------------------------------------------------------------------------

double PolySurface::get_periode_v(void)
{
    return 0;

}


//---------------------------------------------------------------------------

void PolySurface::enregistrer(std::ostream& o,double version)
{
// %ID=CAD4FE_POLYSURFACE(MG_FACE_1,MG_FACE_2,...,MG_FACE_N)
    unsigned int i;

    o << "%" << get_id()
    << "=CAD4FE_POLYSURFACE(" << GetRefFaceCount() << ",(";

    for (i=0; i < GetRefFaceCount(); i++)
    {
        if ( i ) o <<",";
        o << "$" << GetRefFace(i)->get_id();
    }

    o << "));" << std::endl;;
}


//---------------------------------------------------------------------------
int PolySurface::get_type_geometrique(TPL_LISTE_ENTITE<double> &param)
{
    return 0;
}
//---------------------------------------------------------------------------

bool PolySurface::Contains(MG_ARETE * __refEdge)
{
    int nb_coedge = __refEdge->get_nb_mg_coarete();
    for (int i=0; i<nb_coedge; i++)
    {
        MG_FACE * f = __refEdge->get_mg_coarete(i)->get_boucle()->get_mg_face();
        if (Contains(f))
            return true;
    }
    return false;
}
//---------------------------------------------------------------------------

bool PolySurface::Contains(MG_FACE * __refFace)
{
    return ( _lst_ref_faces.find(__refFace) != _lst_ref_faces.end());
}
//---------------------------------------------------------------------------

MG_FACE * PolySurface::GetRefFace(unsigned int __index)
{
    std::set<MG_FACE*>::iterator itFace = _lst_ref_faces.begin();
    std::advance (itFace, __index);
    return *itFace;
}
//---------------------------------------------------------------------------

std::set<MG_FACE*> & PolySurface::GetRefFaces()
{
    return _lst_ref_faces;
}
//---------------------------------------------------------------------------

unsigned int PolySurface::GetRefFaceCount()
{
    return _lst_ref_faces.size();
}
//---------------------------------------------------------------------------
void PolySurface::calcul_normale_unitaire(MG_SOMMET *v, double __normal[3], int * __nbRefFace)
{
    double angleTot=0;
    OT_VECTEUR_3D normalTriangle(0,0,0);

    MG_NOEUD * refNode = 0;
    TPL_SET < MG_ELEMENT_MAILLAGE * > * refNodeMesh = v->get_lien_maillage();
    TPL_SET < MG_ELEMENT_MAILLAGE * >::ITERATEUR it;
    refNode = (MG_NOEUD *)refNodeMesh->get_premier(it);
    TPL_LISTE_ENTITE<MG_TRIANGLE*>* adjacentTriangles = refNode->get_lien_triangle();
    unsigned itTriang;
    for (itTriang=0;itTriang <adjacentTriangles->get_nb(); itTriang++)
    {
        MG_TRIANGLE* t = adjacentTriangles->get(itTriang);
        MG_FACE * refFace = (MG_FACE*) t->get_lien_topologie();
        if ( Contains(refFace) == false)
            continue;
        int id=-1;
        MG_NOEUD * nos[3]={t->get_noeud1(),t->get_noeud2(),t->get_noeud3()};
        for (int j=0;j<3;j++)
            if (nos[j] == refNode)
            {
                id = j;
                break;
            }
        OT_VECTEUR_3D x[3];
        for (int j=0;j<3;j++)
            x[j]=OT_VECTEUR_3D(nos[j]->get_coord());
        OT_VECTEUR_3D x1x2 = x[id]-x[(id+2)%3];
        x1x2.norme();
        OT_VECTEUR_3D x2x3 = x[(id+1)%3]-x[id];
        x2x3.norme();
        OT_VECTEUR_3D normal = x1x2&x2x3;
        double angle = acos(-(x1x2*x2x3));
        normal *= angle;
        angleTot += angle;
        normalTriangle += normal;
    }
    if (angleTot != 0)
    {
        normalTriangle /= angleTot;
        for (int j=0;j<3;j++)
            __normal[j]=normalTriangle[j];
    }
    else
    {
        for (int j=0;j<3;j++)
            __normal[j]=0;
    }
    *__nbRefFace = ceil(angleTot);
}
//---------------------------------------------------------------------------

void PolySurface::calcul_normale_unitaire(MCVertex * __mcVertex, double __n[3], int *__nbRefFace)
{
    // normal = 1/n * sum_i=1,n ( normal(ref face) )
    // where n is the number of reference faces adjacent to reference vertex and contained in the MC Face

    OT_VECTEUR_3D tmpNormal(0,0,0);
    MG_SOMMET * v =  __mcVertex->GetRefVertex();
    int nbRefFace=0;
    calcul_normale_unitaire(v, __n, &nbRefFace);
    std::map <unsigned long, MG_SOMMET *> & mergedVertices = __mcVertex->GetMergedRefVertices();
    for (std::map <unsigned long, MG_SOMMET *>::iterator itRefVertex=mergedVertices.begin();
            itRefVertex != mergedVertices.end();
            itRefVertex++)
    {
        v = itRefVertex->second;
        int tmpnbRefFace;
        calcul_normale_unitaire(v, tmpNormal, &tmpnbRefFace);
        for (int i=0;i<3;i++) __n[i]+=tmpNormal[i];
        nbRefFace += tmpnbRefFace;
    }
    *__nbRefFace = nbRefFace;
}
//---------------------------------------------------------------------------

void PolySurface::calcul_normale_unitaire(const std::map<MG_FACE *, OT_VECTEUR_3D > & __tabRefFaceUV, double __n[3], int *__nbRefFace)
{
    (*__nbRefFace) = 0;
    OT_VECTEUR_3D n(0,0,0);

    for (std::map<MG_FACE *, OT_VECTEUR_3D >::const_iterator itF = __tabRefFaceUV.begin();
            itF != __tabRefFaceUV.end(); itF++)
    {
        MG_FACE * refFace = itF->first;

        if ( _lst_ref_faces.find(refFace) == _lst_ref_faces.end() )
            continue;

        OT_VECTEUR_3D refFaceNormal;
        OT_VECTEUR_3D refFaceUV=itF->second;
        refFace->calcul_normale_unitaire(refFaceUV,refFaceNormal);

        n += refFaceNormal;

        (*__nbRefFace)++;
    }

    if ((*__nbRefFace)==0)
        return;

    n /= (*__nbRefFace);

    double inv_n_norm = 1/n.get_longueur();
    for (int i=0; i<3; i++)
        __n[i]=n[i]*inv_n_norm;
}

void PolySurface::get_param_NURBS(int& indx_premier_ptctr, TPL_LISTE_ENTITE<double> &param)
{
    return;
}

Revision:	763
Committed:	Wed Dec 2 19:55:53 2015 UTC (9 years, 5 months ago) by francois
File size:	8596 byte(s)
Log Message:	Le fichier MAGiC est maintenant versionné. LA version actuelle est 2.0. L'ancienne version est 1.0. Tout est transparent pour l'utilisateur. Les vieilles versions sont lisibles mais les nouveaux enregistrements sont dans la version la plus récente. Changement des conditions aux limites : ajout d'un parametre pour dire si la condition numerique est une valeur ou une formule ou un lien vers une autre entité magic. Les parametres pour saisir sont maintenant -ccf -ccfi -ccff -ccft -ccfit -ccfft
#	User	Rev	Content
1	francois	283	//---------------------------------------------------------------------------
2
3			//---------------------------------------------------------------------------
4			// include MAGIC Headers
5			#include "gestionversion.h"
6			#include "mg_geometrie.h"
7			#include "mg_arete.h"
8			#include "tpl_fonction.h"
9
10			//---------------------------------------------------------------------------
11			// include STL headers
12			//---------------------------------------------------------------------------
13			#include <map>
14			#include <ostream>
15			#include <string>
16			#include <vector>
17			//---------------------------------------------------------------------------
18
19
20			#pragma hdrstop
21
22	foucault	569	#include "CAD4FE_PolySurface.h"
23			#include "CAD4FE_MCVertex.h"
24	francois	283	#include "ot_mathematique.h"
25			#include "math.h"
26
27			//---------------------------------------------------------------------------
28
29			#pragma package(smart_init)
30
31			#ifdef __BORLANDC__
32			#pragma warn -8012
33			#endif
34
35			using namespace CAD4FE;
36
37			//---------------------------------------------------------------------------
38			PolySurface::PolySurface(MG_FACE * __refFace)
39			{
40			// Add the reference face in the list of faces
41			_lst_ref_faces.insert(__refFace);
42			}
43			//---------------------------------------------------------------------------
44
45			void PolySurface::InsertSurface(MG_FACE *__refFace)
46			{
47			// Add the reference face in the list of faces
48			_lst_ref_faces.insert(__refFace);
49			}
50			//---------------------------------------------------------------------------
51
52			void PolySurface::Merge( PolySurface & __polySurface )
53			{
54			// Add the reference faces in the list of faces
55			std::set<MG_FACE*> & r = __polySurface._lst_ref_faces;
56
57			for (std::set<MG_FACE*>::iterator itRefFace = r.begin();
58			itRefFace != r.end();
59			itRefFace++)
60			_lst_ref_faces.insert(*itRefFace);
61			}
62
63			//---------------------------------------------------------------------------
64
65			void PolySurface::evaluer(double uv,double xyz)
66			{
67
68			}
69
70			//---------------------------------------------------------------------------
71
72			void PolySurface::deriver(double uv,double xyzdu, double *xyzdv)
73			{
74
75			}
76
77
78			//---------------------------------------------------------------------------
79			void PolySurface::deriver_seconde(double uv,double xyzduu,double* xyzduv,double* xyzdvv,double xyz, double xyzdu, double *xyzdv)
80			{
81
82			}
83
84
85			//---------------------------------------------------------------------------
86			void PolySurface::inverser(double uv,double xyz,double precision)
87			{
88
89			}
90
91			//---------------------------------------------------------------------------
92
93			int PolySurface::est_periodique_u(void)
94			{
95
96			return 0;
97			}
98
99
100			//---------------------------------------------------------------------------
101			int PolySurface::est_periodique_v(void)
102			{
103
104			return 0;
105			}
106
107
108			//---------------------------------------------------------------------------
109			double PolySurface::get_periode_u(void)
110			{
111
112			return 0;
113			}
114
115			//---------------------------------------------------------------------------
116
117			double PolySurface::get_periode_v(void)
118			{
119			return 0;
120
121			}
122
123
124			//---------------------------------------------------------------------------
125
126	francois	763	void PolySurface::enregistrer(std::ostream& o,double version)
127	francois	283	{
128			// %ID=CAD4FE_POLYSURFACE(MG_FACE_1,MG_FACE_2,...,MG_FACE_N)
129			unsigned int i;
130
131			o << "%" << get_id()
132			<< "=CAD4FE_POLYSURFACE(" << GetRefFaceCount() << ",(";
133
134			for (i=0; i < GetRefFaceCount(); i++)
135			{
136			if ( i ) o <<",";
137			o << "$" << GetRefFace(i)->get_id();
138			}
139
140			o << "));" << std::endl;;
141			}
142
143
144			//---------------------------------------------------------------------------
145			int PolySurface::get_type_geometrique(TPL_LISTE_ENTITE<double> &param)
146			{
147			return 0;
148			}
149			//---------------------------------------------------------------------------
150
151			bool PolySurface::Contains(MG_ARETE * __refEdge)
152			{
153			int nb_coedge = __refEdge->get_nb_mg_coarete();
154			for (int i=0; i<nb_coedge; i++)
155			{
156			MG_FACE * f = __refEdge->get_mg_coarete(i)->get_boucle()->get_mg_face();
157			if (Contains(f))
158			return true;
159			}
160			return false;
161			}
162			//---------------------------------------------------------------------------
163
164			bool PolySurface::Contains(MG_FACE * __refFace)
165			{
166			return ( _lst_ref_faces.find(__refFace) != _lst_ref_faces.end());
167			}
168			//---------------------------------------------------------------------------
169
170			MG_FACE * PolySurface::GetRefFace(unsigned int __index)
171			{
172			std::set<MG_FACE*>::iterator itFace = _lst_ref_faces.begin();
173			std::advance (itFace, __index);
174			return *itFace;
175			}
176			//---------------------------------------------------------------------------
177
178			std::set<MG_FACE*> & PolySurface::GetRefFaces()
179			{
180			return _lst_ref_faces;
181			}
182			//---------------------------------------------------------------------------
183
184			unsigned int PolySurface::GetRefFaceCount()
185			{
186			return _lst_ref_faces.size();
187			}
188			//---------------------------------------------------------------------------
189			void PolySurface::calcul_normale_unitaire(MG_SOMMET v, double __normal[3], int __nbRefFace)
190			{
191			double angleTot=0;
192			OT_VECTEUR_3D normalTriangle(0,0,0);
193
194			MG_NOEUD * refNode = 0;
195			TPL_SET < MG_ELEMENT_MAILLAGE * > * refNodeMesh = v->get_lien_maillage();
196			TPL_SET < MG_ELEMENT_MAILLAGE * >::ITERATEUR it;
197			refNode = (MG_NOEUD *)refNodeMesh->get_premier(it);
198			TPL_LISTE_ENTITE<MG_TRIANGLE> adjacentTriangles = refNode->get_lien_triangle();
199			unsigned itTriang;
200			for (itTriang=0;itTriang <adjacentTriangles->get_nb(); itTriang++)
201			{
202			MG_TRIANGLE* t = adjacentTriangles->get(itTriang);
203			MG_FACE * refFace = (MG_FACE*) t->get_lien_topologie();
204			if ( Contains(refFace) == false)
205			continue;
206			int id=-1;
207			MG_NOEUD * nos[3]={t->get_noeud1(),t->get_noeud2(),t->get_noeud3()};
208			for (int j=0;j<3;j++)
209			if (nos[j] == refNode)
210			{
211			id = j;
212			break;
213			}
214			OT_VECTEUR_3D x[3];
215			for (int j=0;j<3;j++)
216			x[j]=OT_VECTEUR_3D(nos[j]->get_coord());
217			OT_VECTEUR_3D x1x2 = x[id]-x[(id+2)%3];
218			x1x2.norme();
219			OT_VECTEUR_3D x2x3 = x[(id+1)%3]-x[id];
220			x2x3.norme();
221			OT_VECTEUR_3D normal = x1x2&x2x3;
222			double angle = acos(-(x1x2*x2x3));
223			normal *= angle;
224			angleTot += angle;
225			normalTriangle += normal;
226			}
227			if (angleTot != 0)
228			{
229			normalTriangle /= angleTot;
230			for (int j=0;j<3;j++)
231			__normal[j]=normalTriangle[j];
232			}
233			else
234			{
235			for (int j=0;j<3;j++)
236			__normal[j]=0;
237			}
238			*__nbRefFace = ceil(angleTot);
239			}
240			//---------------------------------------------------------------------------
241
242			void PolySurface::calcul_normale_unitaire(MCVertex * __mcVertex, double __n[3], int *__nbRefFace)
243			{
244			// normal = 1/n * sum_i=1,n ( normal(ref face) )
245			// where n is the number of reference faces adjacent to reference vertex and contained in the MC Face
246
247			OT_VECTEUR_3D tmpNormal(0,0,0);
248			MG_SOMMET * v = __mcVertex->GetRefVertex();
249			int nbRefFace=0;
250			calcul_normale_unitaire(v, __n, &nbRefFace);
251			std::map <unsigned long, MG_SOMMET *> & mergedVertices = __mcVertex->GetMergedRefVertices();
252			for (std::map <unsigned long, MG_SOMMET *>::iterator itRefVertex=mergedVertices.begin();
253			itRefVertex != mergedVertices.end();
254			itRefVertex++)
255			{
256			v = itRefVertex->second;
257			int tmpnbRefFace;
258			calcul_normale_unitaire(v, tmpNormal, &tmpnbRefFace);
259			for (int i=0;i<3;i++) __n[i]+=tmpNormal[i];
260			nbRefFace += tmpnbRefFace;
261			}
262			*__nbRefFace = nbRefFace;
263			}
264			//---------------------------------------------------------------------------
265
266			void PolySurface::calcul_normale_unitaire(const std::map<MG_FACE , OT_VECTEUR_3D > & __tabRefFaceUV, double __n[3], int __nbRefFace)
267			{
268			(*__nbRefFace) = 0;
269			OT_VECTEUR_3D n(0,0,0);
270
271			for (std::map<MG_FACE *, OT_VECTEUR_3D >::const_iterator itF = __tabRefFaceUV.begin();
272			itF != __tabRefFaceUV.end(); itF++)
273			{
274			MG_FACE * refFace = itF->first;
275
276			if ( _lst_ref_faces.find(refFace) == _lst_ref_faces.end() )
277			continue;
278
279			OT_VECTEUR_3D refFaceNormal;
280			OT_VECTEUR_3D refFaceUV=itF->second;
281			refFace->calcul_normale_unitaire(refFaceUV,refFaceNormal);
282
283			n += refFaceNormal;
284
285			(*__nbRefFace)++;
286			}
287
288			if ((*__nbRefFace)==0)
289			return;
290
291			n /= (*__nbRefFace);
292
293			double inv_n_norm = 1/n.get_longueur();
294			for (int i=0; i<3; i++)
295			__n[i]=n[i]*inv_n_norm;
296			}
297
298			void PolySurface::get_param_NURBS(int& indx_premier_ptctr, TPL_LISTE_ENTITE<double> &param)
299			{
300			return;
301			}
302