geometrie/src/CAD4FE_MCFace.cpp

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

#pragma hdrstop

#include "CAD4FE_MCFace.h"
#include "CAD4FE_PolySurface.h"
#include "CAD4FE_MCEdge.h"
#include "CAD4FE_MCVertex.h"
#include "ot_algorithme_geometrique.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)

#ifdef __BORLANDC__
#pragma warn -8012
#pragma warn -8037
#endif

using namespace CAD4FE;

MCFace::MCFace(MG_FACE * __mgFace)
  : MG_FACE (std::string("MC")+std::string(__mgFace->get_idoriginal()), new PolySurface(__mgFace), 1)
{
        time = 0;
        copie_ccf(*__mgFace);
}

MCFace::MCFace( MCFace & __src)  : MG_FACE(*this)
{
        time = 0;
}


MCFace::MCFace( std::string & __idOriginal, PolySurface * __polySurface)
: MG_FACE(std::string(__idOriginal), __polySurface, 1)
{                 
        time = 0;
}


MCFace::MCFace(MCFace & __a,  MCFace & __b)
: MG_FACE(std::string(__a.get_idoriginal())+std::string("+")+std::string(__b.get_idoriginal()), new PolySurface(), 1)
{                 
        time = 0;

        GetPolySurface()->Merge(*__a.GetPolySurface());
        GetPolySurface()->Merge(*__b.GetPolySurface());
        
        _CopyMeshLink (__a);
        _CopyMeshLink (__b);
        
        copie_ccf(__a);
        copie_ccf(__b);
}

void MCFace::_CopyMeshLink( MCFace & __mcFace)
{
    unsigned i,j,k;

    //this->get_lien_maillage()->ajouter(*(__mcFace.get_lien_maillage()));
    TPL_SET<MG_ELEMENT_MAILLAGE*> * lien_maillage  = __mcFace.get_lien_maillage();
    TPL_SET<MG_ELEMENT_MAILLAGE*>::ITERATEUR it;
    for (MG_ELEMENT_MAILLAGE* element = lien_maillage->get_premier(it); element != NULL; element = lien_maillage->get_suivant(it))
    {
            element->change_lien_topologie2(this);
            this->get_lien_maillage()->ajouter(element);

            MG_TRIANGLE * triangle = (MG_TRIANGLE *)element;
            MG_SEGMENT * segs[3]={0,0,0};
            segs[0] = triangle->get_segment1();                
            segs[1] = triangle->get_segment2();
            segs[2] = triangle->get_segment3();
            MG_NOEUD * nodes[3]={0,0,0};
            nodes[0] = triangle->get_noeud1();
            nodes[1] = triangle->get_noeud2();
            nodes[2] = triangle->get_noeud3();
            for (i=0; i<3; i++)
            {
                if (!segs[i]->get_lien_topologie() || segs[i]->get_lien_topologie()->get_dimension() >= 2)
                {
                    segs[i]->change_lien_topologie2(this);
                }
                if (!nodes[i]->get_lien_topologie() || nodes[i]->get_lien_topologie()->get_dimension() >= 2)
                {
                    nodes[i]->change_lien_topologie2(this);
                }
            }
    }
}

MCFace::~MCFace()
{
}

PolySurface * MCFace::GetPolySurface ()
{
        return (PolySurface*)get_surface();
}

void MCFace::enregistrer(std::ostream& o,double version)
{
   o << "%" << get_id() << "=CAD4FE_MCFACE("<< get_idoriginal() << ",$" << get_surface()->get_id() << ",(";
   for (unsigned int i=0;i<get_nb_mg_boucle();i++)
      {
         o << "$" << get_mg_boucle(i)->get_id();
         if (i!=get_nb_mg_boucle()-1) o << ","; else o << ")";
      }
   int nb=get_nb_ccf();
   o << "," << get_orientation() << "," << nb;
   if (nb!=0)
        {
        o << ",(";
        for (int i=0;i<nb;i++)
                {
                char nom[3];
                get_type_ccf(i,nom);
                o << "(" <<  nom << "," << get_valeur_ccf(i) << ")";
                if (i!=nb-1) o << "," ;
                }
        o << ")";
        }
   o <<   ");" << std::endl;
}

void MCFace::calcul_normale_unitaire(MG_SOMMET *v, double __n[3], int * __nbRefFace)
{
    GetPolySurface()->calcul_normale_unitaire(v,__n,__nbRefFace);
}

void MCFace::calcul_normale_unitaire(MCVertex * __mcVertex, double __n[3], int *__nbRefFace)
{
    GetPolySurface()->calcul_normale_unitaire(__mcVertex,__n,__nbRefFace);
}

void MCFace::calcul_normale_unitaire(const std::map<MG_FACE *, OT_VECTEUR_3D > & __tabRefFaceUV, double __n[3], int *__nbRefFace)
{
    GetPolySurface()->calcul_normale_unitaire(__tabRefFaceUV,__n,__nbRefFace);
}

Revision:	763
Committed:	Wed Dec 2 19:55:53 2015 UTC (9 years, 5 months ago) by francois
File size:	4181 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	foucault	27	//---------------------------------------------------------------------------
2
3			#pragma hdrstop
4
5	foucault	569	#include "CAD4FE_MCFace.h"
6			#include "CAD4FE_PolySurface.h"
7			#include "CAD4FE_MCEdge.h"
8			#include "CAD4FE_MCVertex.h"
9	foucault	27	#include "ot_algorithme_geometrique.h"
10			//---------------------------------------------------------------------------
11			#pragma package(smart_init)
12
13			#ifdef __BORLANDC__
14			#pragma warn -8012
15			#pragma warn -8037
16			#endif
17
18			using namespace CAD4FE;
19
20			MCFace::MCFace(MG_FACE * __mgFace)
21	foucault	569	: MG_FACE (std::string("MC")+std::string(__mgFace->get_idoriginal()), new PolySurface(__mgFace), 1)
22	foucault	27	{
23	foucault	569	time = 0;
24			copie_ccf(*__mgFace);
25	foucault	27	}
26
27			MCFace::MCFace( MCFace & __src) : MG_FACE(*this)
28			{
29	foucault	569	time = 0;
30	foucault	27	}
31
32
33			MCFace::MCFace( std::string & __idOriginal, PolySurface * __polySurface)
34	foucault	569	: MG_FACE(std::string(__idOriginal), __polySurface, 1)
35			{
36			time = 0;
37	foucault	27	}
38
39
40			MCFace::MCFace(MCFace & __a, MCFace & __b)
41	foucault	569	: MG_FACE(std::string(__a.get_idoriginal())+std::string("+")+std::string(__b.get_idoriginal()), new PolySurface(), 1)
42			{
43			time = 0;
44	foucault	27
45	foucault	569	GetPolySurface()->Merge(*__a.GetPolySurface());
46			GetPolySurface()->Merge(*__b.GetPolySurface());
47
48			_CopyMeshLink (__a);
49			_CopyMeshLink (__b);
50
51			copie_ccf(__a);
52			copie_ccf(__b);
53	foucault	27	}
54
55			void MCFace::_CopyMeshLink( MCFace & __mcFace)
56			{
57			unsigned i,j,k;
58
59			//this->get_lien_maillage()->ajouter(*(__mcFace.get_lien_maillage()));
60			TPL_SET<MG_ELEMENT_MAILLAGE> lien_maillage = __mcFace.get_lien_maillage();
61			TPL_SET<MG_ELEMENT_MAILLAGE*>::ITERATEUR it;
62			for (MG_ELEMENT_MAILLAGE* element = lien_maillage->get_premier(it); element != NULL; element = lien_maillage->get_suivant(it))
63			{
64	foucault	569	element->change_lien_topologie2(this);
65			this->get_lien_maillage()->ajouter(element);
66	foucault	27
67	foucault	569	MG_TRIANGLE * triangle = (MG_TRIANGLE *)element;
68			MG_SEGMENT * segs[3]={0,0,0};
69			segs[0] = triangle->get_segment1();
70			segs[1] = triangle->get_segment2();
71			segs[2] = triangle->get_segment3();
72			MG_NOEUD * nodes[3]={0,0,0};
73			nodes[0] = triangle->get_noeud1();
74			nodes[1] = triangle->get_noeud2();
75			nodes[2] = triangle->get_noeud3();
76			for (i=0; i<3; i++)
77	foucault	27	{
78	foucault	569	if (!segs[i]->get_lien_topologie() \|\| segs[i]->get_lien_topologie()->get_dimension() >= 2)
79			{
80			segs[i]->change_lien_topologie2(this);
81			}
82			if (!nodes[i]->get_lien_topologie() \|\| nodes[i]->get_lien_topologie()->get_dimension() >= 2)
83			{
84			nodes[i]->change_lien_topologie2(this);
85			}
86	foucault	27	}
87			}
88			}
89
90			MCFace::~MCFace()
91			{
92			}
93
94			PolySurface * MCFace::GetPolySurface ()
95			{
96	foucault	569	return (PolySurface*)get_surface();
97	foucault	27	}
98
99	francois	763	void MCFace::enregistrer(std::ostream& o,double version)
100	foucault	27	{
101	foucault	569	o << "%" << get_id() << "=CAD4FE_MCFACE("<< get_idoriginal() << ",$" << get_surface()->get_id() << ",(";
102			for (unsigned int i=0;i<get_nb_mg_boucle();i++)
103			{
104			o << "$" << get_mg_boucle(i)->get_id();
105			if (i!=get_nb_mg_boucle()-1) o << ","; else o << ")";
106			}
107			int nb=get_nb_ccf();
108			o << "," << get_orientation() << "," << nb;
109			if (nb!=0)
110			{
111	foucault	27	o << ",(";
112			for (int i=0;i<nb;i++)
113	foucault	569	{
114			char nom[3];
115			get_type_ccf(i,nom);
116			o << "(" << nom << "," << get_valeur_ccf(i) << ")";
117			if (i!=nb-1) o << "," ;
118			}
119			o << ")";
120	francois	283	}
121	foucault	569	o << ");" << std::endl;
122	foucault	27	}
123
124			void MCFace::calcul_normale_unitaire(MG_SOMMET v, double __n[3], int __nbRefFace)
125			{
126			GetPolySurface()->calcul_normale_unitaire(v,__n,__nbRefFace);
127			}
128
129			void MCFace::calcul_normale_unitaire(MCVertex * __mcVertex, double __n[3], int *__nbRefFace)
130			{
131			GetPolySurface()->calcul_normale_unitaire(__mcVertex,__n,__nbRefFace);
132			}
133
134			void MCFace::calcul_normale_unitaire(const std::map<MG_FACE , OT_VECTEUR_3D > & __tabRefFaceUV, double __n[3], int __nbRefFace)
135			{
136			GetPolySurface()->calcul_normale_unitaire(__tabRefFaceUV,__n,__nbRefFace);
137			}
138