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)
{
   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:	569
Committed:	Thu Oct 16 14:36:31 2014 UTC (10 years, 10 months ago) by foucault
File size:	4166 byte(s)
Log Message:	Mise à jour pour CAD4FE (Gilles) : operation 1 (tentative)
#	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			void MCFace::enregistrer(std::ostream& o)
100			{
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