mtu/src/mg_triangle.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/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       mg_triangle.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:54 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------


#include "gestionversion.h"
#include "mg_triangle.h"
#include "mg_maillage.h"
#include "ot_decalage_parametre.h"

MG_TRIANGLE::MG_TRIANGLE(unsigned long num,MG_ELEMENT_TOPOLOGIQUE* topo,class MG_NOEUD *mgnoeud1,class MG_NOEUD *mgnoeud2,class MG_NOEUD *mgnoeud3,class MG_SEGMENT* mgsegment1,class MG_SEGMENT* mgsegment2,class MG_SEGMENT* mgsegment3,int origine):MG_ELEMENT_MAILLAGE(num,topo,origine),noeud1(mgnoeud1),noeud2(mgnoeud2),noeud3(mgnoeud3),segment1(mgsegment1),segment2(mgsegment2),segment3(mgsegment3)
{
    init_triangle();
}

MG_TRIANGLE::MG_TRIANGLE(MG_ELEMENT_TOPOLOGIQUE* topo,class MG_NOEUD *mgnoeud1,class MG_NOEUD *mgnoeud2,class MG_NOEUD *mgnoeud3,class MG_SEGMENT* mgsegment1,class MG_SEGMENT* mgsegment2,class MG_SEGMENT* mgsegment3,int origine):MG_ELEMENT_MAILLAGE(topo,origine),noeud1(mgnoeud1),noeud2(mgnoeud2),noeud3(mgnoeud3),segment1(mgsegment1),segment2(mgsegment2),segment3(mgsegment3)
{
    init_triangle();
}

MG_TRIANGLE::MG_TRIANGLE(MG_TRIANGLE& mdd):MG_ELEMENT_MAILLAGE(mdd),noeud1(mdd.noeud1),noeud2(mdd.noeud2),noeud3(mdd.noeud3),segment1(mdd.segment1),segment2(mdd.segment2),segment3(mdd.segment3)
{
    init_triangle();
}

MG_TRIANGLE* MG_TRIANGLE::dupliquer(MG_MAILLAGE *mgmai,long decalage)
{
    MG_NOEUD* nd1=mgmai->get_mg_noeudid(noeud1->get_id()+decalage);
    MG_NOEUD* nd2=mgmai->get_mg_noeudid(noeud2->get_id()+decalage);
    MG_NOEUD* nd3=mgmai->get_mg_noeudid(noeud3->get_id()+decalage);
    MG_SEGMENT* seg1=mgmai->get_mg_segmentid(segment1->get_id()+decalage);
    MG_SEGMENT* seg2=mgmai->get_mg_segmentid(segment2->get_id()+decalage);
    MG_SEGMENT* seg3=mgmai->get_mg_segmentid(segment3->get_id()+decalage);
    MG_TRIANGLE* tri=new MG_TRIANGLE(this->get_id()+decalage,liaison_topologique,nd1,nd2,nd3,seg1,seg2,seg3,MAGIC::ORIGINE::DUPLIQUER);
    mgmai->ajouter_mg_triangle(tri);
    return tri;
}


MG_TRIANGLE::~MG_TRIANGLE()
{
    if (noeud1!=NULL) noeud1->get_lien_triangle()->supprimer(this);
    if (noeud2!=NULL) noeud2->get_lien_triangle()->supprimer(this);
    if (noeud3!=NULL) noeud3->get_lien_triangle()->supprimer(this);
    unsigned long noeudminid=std::min(noeud1->get_id(),noeud2->get_id());
    noeudminid=std::min(noeudminid,noeud3->get_id());
    if (noeud1!=NULL)
        if (noeud1->get_id()==noeudminid) noeud1->get_lien_petit_triangle()->supprimer(this);
    if (noeud2!=NULL)
        if (noeud2->get_id()==noeudminid) noeud2->get_lien_petit_triangle()->supprimer(this);
    if (noeud3!=NULL)
        if (noeud3->get_id()==noeudminid) noeud3->get_lien_petit_triangle()->supprimer(this);
    if (segment1!=NULL) {
        segment1->decrementer();
        segment1->get_lien_triangle()->supprimer(this);
    }
    if (segment2!=NULL) {
        segment2->decrementer();
        segment2->get_lien_triangle()->supprimer(this);
    }
    if (segment3!=NULL) {
        segment3->decrementer();
        segment3->get_lien_triangle()->supprimer(this);
    }
    if (liaison_topologique!=NULL) 
      if (liaison_topologique->get_dimension()==2) liaison_topologique->get_lien_maillage()->supprimer(this);
}

void MG_TRIANGLE::init_triangle(void)
{
    if (noeud1!=NULL) noeud1->get_lien_triangle()->ajouter(this);
    if (noeud2!=NULL) noeud2->get_lien_triangle()->ajouter(this);
    if (noeud3!=NULL) noeud3->get_lien_triangle()->ajouter(this);
    unsigned long noeudminid=std::min(noeud1->get_id(),noeud2->get_id());
    noeudminid=std::min(noeudminid,noeud3->get_id());
    if (noeud1!=NULL)
        if (noeud1->get_id()==noeudminid) noeud1->get_lien_petit_triangle()->ajouter(this);
    if (noeud2!=NULL)
        if (noeud2->get_id()==noeudminid) noeud2->get_lien_petit_triangle()->ajouter(this);
    if (noeud3!=NULL)
        if (noeud3->get_id()==noeudminid) noeud3->get_lien_petit_triangle()->ajouter(this);
    if (segment1!=NULL) {
        segment1->incrementer();
        segment1->get_lien_triangle()->ajouter(this);
    }
    if (segment2!=NULL) {
        segment2->incrementer();
        segment2->get_lien_triangle()->ajouter(this);
    }
    if (segment3!=NULL) {
        segment3->incrementer();
        segment3->get_lien_triangle()->ajouter(this);
    }
    if ( (segment1!=NULL) &&  (segment2!=NULL)&& (segment3!=NULL) )longueur=0.3333333333333333*(segment1->get_longueur()+segment2->get_longueur()+segment3->get_longueur());
    if (liaison_topologique==NULL) return;
    if (liaison_topologique->get_dimension()==2) liaison_topologique->get_lien_maillage()->ajouter(this);
}


int MG_TRIANGLE::get_type_entite(void)
{
    return MAGIC::TYPE_ENTITE::IDMG_TRIANGLE;
}


MG_NOEUD* MG_TRIANGLE::get_noeud1(void)
{
    return noeud1;
}

MG_NOEUD* MG_TRIANGLE::get_noeud2(void)
{
    return noeud2;
}


MG_NOEUD* MG_TRIANGLE::get_noeud3(void)
{
    return noeud3;
}

MG_SEGMENT* MG_TRIANGLE::get_segment1(void)
{
    return segment1;
}

MG_SEGMENT* MG_TRIANGLE::get_segment2(void)
{
    return segment2;
}

MG_SEGMENT* MG_TRIANGLE::get_segment3(void)
{
    return segment3;
}

void MG_TRIANGLE::inverse_sens(void)
{
MG_NOEUD* noeud=noeud2;
noeud2=noeud3;
noeud3=noeud;
MG_SEGMENT* segment=segment3;
segment3=segment1;
segment1=segment;
}

int MG_TRIANGLE::get_dimension(void)
{
    return 2;
}

double MG_TRIANGLE::get_longueur(void)
{
    return longueur;
}

TPL_LISTE_ENTITE<class MG_TETRA*>* MG_TRIANGLE::get_lien_tetra(void)
{
    return &tetra;
}

TPL_LISTE_ENTITE<class MG_PENTA*>* MG_TRIANGLE::get_lien_penta(void)
{
    return &penta;
}

TPL_LISTE_ENTITE<class MG_PYRAMIDE*>* MG_TRIANGLE::get_lien_pyramide(void)
{
    return &pyramide;
}

BOITE_2D MG_TRIANGLE::get_boite_2D(double periodeu,double periodev)
{
    OT_DECALAGE_PARAMETRE decalage(periodeu,periodev);

    double coouv1[2];
    double coouv2[2];
    double coouv3[2];
    coouv1[0]=noeud1->get_u();
    coouv1[1]=noeud1->get_v();
    coouv2[0]=noeud2->get_u();
    coouv2[1]=noeud2->get_v();
    coouv3[0]=noeud3->get_u();
    coouv3[1]=noeud3->get_v();
    double coouvd1[2];
    double coouvd2[2];
    double coouvd3[2];
    double du=decalage.calcul_decalage_parametre_u(coouv1[0]);
    double dv=decalage.calcul_decalage_parametre_v(coouv1[1]);
    coouvd1[0]=decalage.decalage_parametre_u(coouv1[0],du);
    coouvd1[1]=decalage.decalage_parametre_v(coouv1[1],dv);
    coouvd2[0]=decalage.decalage_parametre_u(coouv2[0],du);
    coouvd2[1]=decalage.decalage_parametre_v(coouv2[1],dv);
    coouvd3[0]=decalage.decalage_parametre_u(coouv3[0],du);
    coouvd3[1]=decalage.decalage_parametre_v(coouv3[1],dv);
    double umin,vmin,umax,vmax;
    umin=std::min(coouvd1[0],coouvd2[0]);
    umin=std::min(umin,coouvd3[0]);
    umax=std::max(coouvd1[0],coouvd2[0]);
    umax=std::max(umax,coouvd3[0]);
    vmin=std::min(coouvd1[1],coouvd2[1]);
    vmin=std::min(vmin,coouvd3[1]);
    vmax=std::max(coouv1[1],coouvd2[1]);
    vmax=std::max(vmax,coouvd3[1]);
    umin=umin-du;
    umax=umax-du;
    vmin=vmin-dv;
    vmax=vmax-dv;
    BOITE_2D boite(umin,vmin,umax,vmax);
    return boite;
}

BOITE_3D MG_TRIANGLE::get_boite_3D(void)
{
    double coo1[3];
    double coo2[3];
    double coo3[3];
    coo1[0]=noeud1->get_x();
    coo1[1]=noeud1->get_y();
    coo1[2]=noeud1->get_z();
    coo2[0]=noeud2->get_x();
    coo2[1]=noeud2->get_y();
    coo2[2]=noeud2->get_z();
    coo3[0]=noeud3->get_x();
    coo3[1]=noeud3->get_y();
    coo3[2]=noeud3->get_z();
    double xmin,ymin,zmin,xmax,ymax,zmax;
    xmin=std::min(coo1[0],coo2[0]);
    xmin=std::min(xmin,coo3[0]);
    xmax=std::max(coo1[0],coo2[0]);
    xmax=std::max(xmax,coo3[0]);
    ymin=std::min(coo1[1],coo2[1]);
    ymin=std::min(ymin,coo3[1]);
    ymax=std::max(coo1[1],coo2[1]);
    ymax=std::max(ymax,coo3[1]);
    zmin=std::min(coo1[2],coo2[2]);
    zmin=std::min(zmin,coo3[2]);
    zmax=std::max(coo1[2],coo2[2]);
    zmax=std::max(zmax,coo3[2]);
    BOITE_3D boite(xmin,ymin,zmin,xmax,ymax,zmax);
    return boite;
}
void MG_TRIANGLE::extrapoler_solution_noeud(void)
{
    for (int j=0;j<MAX_TYPE_SOLUTION;j++)
      {
      noeud1->change_solution(solution[j],j);
      noeud2->change_solution(solution[j],j);
      noeud3->change_solution(solution[j],j);
      }
}


void MG_TRIANGLE::normal(double *n)
{
    double *xyz1=noeud1->get_coord();
    double *xyz2=noeud2->get_coord();
    double *xyz3=noeud3->get_coord();
    OT_VECTEUR_3D vec1(xyz1,xyz2);
    OT_VECTEUR_3D vec2(xyz1,xyz3);
    OT_VECTEUR_3D nor=vec1&vec2;
    nor.norme();
    n[0]=nor.get_x();
    n[1]=nor.get_y();
    n[2]=nor.get_z();
}
    
void MG_TRIANGLE::enregistrer(std::ostream& o,double version)
{
    if ((liaison_topologique==NULL) && (MG_MAILLAGE::DIMENSIONMAILLAGESANSTOPO!=2)) return;
    if (liaison_topologique==NULL) o << "%" << get_id() << "=TRIANGLE(NULL,$" << noeud1->get_id() << ",$" << noeud2->get_id() << ",$" << noeud3->get_id()  << "," << origine_creation << ");" << std::endl;
    else if (liaison_topologique->get_dimension()==2)  o << "%" << get_id() << "=TRIANGLE($"<< get_lien_topologie()->get_id() << ",$" << noeud1->get_id() << ",$" << noeud2->get_id() << ",$" << noeud3->get_id()  << "," << origine_creation << ");" << std::endl;
}


Revision:	1158
Committed:	Thu Jun 13 22:18:49 2024 UTC (11 months, 1 week ago) by francois
File size:	10140 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			//####// mg_triangle.cpp
15			//####//
16			//####//------------------------------------------------------------
17			//####//------------------------------------------------------------
18			//####// COPYRIGHT 2000-2024
19			//####// jeu 13 jun 2024 11:58:54 EDT
20			//####//------------------------------------------------------------
21			//####//------------------------------------------------------------
22	francois	283
23
24			#include "gestionversion.h"
25			#include "mg_triangle.h"
26			#include "mg_maillage.h"
27			#include "ot_decalage_parametre.h"
28
29			MG_TRIANGLE::MG_TRIANGLE(unsigned long num,MG_ELEMENT_TOPOLOGIQUE* topo,class MG_NOEUD mgnoeud1,class MG_NOEUD mgnoeud2,class MG_NOEUD mgnoeud3,class MG_SEGMENT mgsegment1,class MG_SEGMENT* mgsegment2,class MG_SEGMENT* mgsegment3,int origine):MG_ELEMENT_MAILLAGE(num,topo,origine),noeud1(mgnoeud1),noeud2(mgnoeud2),noeud3(mgnoeud3),segment1(mgsegment1),segment2(mgsegment2),segment3(mgsegment3)
30			{
31			init_triangle();
32			}
33
34			MG_TRIANGLE::MG_TRIANGLE(MG_ELEMENT_TOPOLOGIQUE* topo,class MG_NOEUD mgnoeud1,class MG_NOEUD mgnoeud2,class MG_NOEUD mgnoeud3,class MG_SEGMENT mgsegment1,class MG_SEGMENT* mgsegment2,class MG_SEGMENT* mgsegment3,int origine):MG_ELEMENT_MAILLAGE(topo,origine),noeud1(mgnoeud1),noeud2(mgnoeud2),noeud3(mgnoeud3),segment1(mgsegment1),segment2(mgsegment2),segment3(mgsegment3)
35			{
36			init_triangle();
37			}
38
39			MG_TRIANGLE::MG_TRIANGLE(MG_TRIANGLE& mdd):MG_ELEMENT_MAILLAGE(mdd),noeud1(mdd.noeud1),noeud2(mdd.noeud2),noeud3(mdd.noeud3),segment1(mdd.segment1),segment2(mdd.segment2),segment3(mdd.segment3)
40			{
41			init_triangle();
42			}
43
44			MG_TRIANGLE* MG_TRIANGLE::dupliquer(MG_MAILLAGE *mgmai,long decalage)
45			{
46			MG_NOEUD* nd1=mgmai->get_mg_noeudid(noeud1->get_id()+decalage);
47			MG_NOEUD* nd2=mgmai->get_mg_noeudid(noeud2->get_id()+decalage);
48			MG_NOEUD* nd3=mgmai->get_mg_noeudid(noeud3->get_id()+decalage);
49			MG_SEGMENT* seg1=mgmai->get_mg_segmentid(segment1->get_id()+decalage);
50			MG_SEGMENT* seg2=mgmai->get_mg_segmentid(segment2->get_id()+decalage);
51			MG_SEGMENT* seg3=mgmai->get_mg_segmentid(segment3->get_id()+decalage);
52	francois	791	MG_TRIANGLE* tri=new MG_TRIANGLE(this->get_id()+decalage,liaison_topologique,nd1,nd2,nd3,seg1,seg2,seg3,MAGIC::ORIGINE::DUPLIQUER);
53	francois	283	mgmai->ajouter_mg_triangle(tri);
54			return tri;
55			}
56
57
58
59			MG_TRIANGLE::~MG_TRIANGLE()
60			{
61			if (noeud1!=NULL) noeud1->get_lien_triangle()->supprimer(this);
62			if (noeud2!=NULL) noeud2->get_lien_triangle()->supprimer(this);
63			if (noeud3!=NULL) noeud3->get_lien_triangle()->supprimer(this);
64			unsigned long noeudminid=std::min(noeud1->get_id(),noeud2->get_id());
65			noeudminid=std::min(noeudminid,noeud3->get_id());
66			if (noeud1!=NULL)
67			if (noeud1->get_id()==noeudminid) noeud1->get_lien_petit_triangle()->supprimer(this);
68			if (noeud2!=NULL)
69			if (noeud2->get_id()==noeudminid) noeud2->get_lien_petit_triangle()->supprimer(this);
70			if (noeud3!=NULL)
71			if (noeud3->get_id()==noeudminid) noeud3->get_lien_petit_triangle()->supprimer(this);
72			if (segment1!=NULL) {
73			segment1->decrementer();
74			segment1->get_lien_triangle()->supprimer(this);
75			}
76			if (segment2!=NULL) {
77			segment2->decrementer();
78			segment2->get_lien_triangle()->supprimer(this);
79			}
80			if (segment3!=NULL) {
81			segment3->decrementer();
82			segment3->get_lien_triangle()->supprimer(this);
83			}
84	francois	663	if (liaison_topologique!=NULL)
85			if (liaison_topologique->get_dimension()==2) liaison_topologique->get_lien_maillage()->supprimer(this);
86	francois	283	}
87
88			void MG_TRIANGLE::init_triangle(void)
89			{
90			if (noeud1!=NULL) noeud1->get_lien_triangle()->ajouter(this);
91			if (noeud2!=NULL) noeud2->get_lien_triangle()->ajouter(this);
92			if (noeud3!=NULL) noeud3->get_lien_triangle()->ajouter(this);
93			unsigned long noeudminid=std::min(noeud1->get_id(),noeud2->get_id());
94			noeudminid=std::min(noeudminid,noeud3->get_id());
95			if (noeud1!=NULL)
96			if (noeud1->get_id()==noeudminid) noeud1->get_lien_petit_triangle()->ajouter(this);
97			if (noeud2!=NULL)
98			if (noeud2->get_id()==noeudminid) noeud2->get_lien_petit_triangle()->ajouter(this);
99			if (noeud3!=NULL)
100			if (noeud3->get_id()==noeudminid) noeud3->get_lien_petit_triangle()->ajouter(this);
101			if (segment1!=NULL) {
102			segment1->incrementer();
103			segment1->get_lien_triangle()->ajouter(this);
104			}
105			if (segment2!=NULL) {
106			segment2->incrementer();
107			segment2->get_lien_triangle()->ajouter(this);
108			}
109			if (segment3!=NULL) {
110			segment3->incrementer();
111			segment3->get_lien_triangle()->ajouter(this);
112			}
113			if ( (segment1!=NULL) && (segment2!=NULL)&& (segment3!=NULL) )longueur=0.3333333333333333*(segment1->get_longueur()+segment2->get_longueur()+segment3->get_longueur());
114			if (liaison_topologique==NULL) return;
115			if (liaison_topologique->get_dimension()==2) liaison_topologique->get_lien_maillage()->ajouter(this);
116			}
117
118
119			int MG_TRIANGLE::get_type_entite(void)
120			{
121	francois	1150	return MAGIC::TYPE_ENTITE::IDMG_TRIANGLE;
122	francois	283	}
123
124
125
126			MG_NOEUD* MG_TRIANGLE::get_noeud1(void)
127			{
128			return noeud1;
129			}
130
131			MG_NOEUD* MG_TRIANGLE::get_noeud2(void)
132			{
133			return noeud2;
134			}
135
136
137			MG_NOEUD* MG_TRIANGLE::get_noeud3(void)
138			{
139			return noeud3;
140			}
141
142			MG_SEGMENT* MG_TRIANGLE::get_segment1(void)
143			{
144			return segment1;
145			}
146
147			MG_SEGMENT* MG_TRIANGLE::get_segment2(void)
148			{
149			return segment2;
150			}
151
152			MG_SEGMENT* MG_TRIANGLE::get_segment3(void)
153			{
154			return segment3;
155			}
156
157	francois	702	void MG_TRIANGLE::inverse_sens(void)
158			{
159			MG_NOEUD* noeud=noeud2;
160			noeud2=noeud3;
161			noeud3=noeud;
162			MG_SEGMENT* segment=segment3;
163	francois	1082	segment3=segment1;
164			segment1=segment;
165	francois	702	}
166	francois	283
167			int MG_TRIANGLE::get_dimension(void)
168			{
169			return 2;
170			}
171
172			double MG_TRIANGLE::get_longueur(void)
173			{
174			return longueur;
175			}
176
177			TPL_LISTE_ENTITE<class MG_TETRA> MG_TRIANGLE::get_lien_tetra(void)
178			{
179			return &tetra;
180			}
181
182	francois	876	TPL_LISTE_ENTITE<class MG_PENTA> MG_TRIANGLE::get_lien_penta(void)
183			{
184			return &penta;
185			}
186
187	francois	1123	TPL_LISTE_ENTITE<class MG_PYRAMIDE> MG_TRIANGLE::get_lien_pyramide(void)
188			{
189			return &pyramide;
190			}
191
192	francois	283	BOITE_2D MG_TRIANGLE::get_boite_2D(double periodeu,double periodev)
193			{
194			OT_DECALAGE_PARAMETRE decalage(periodeu,periodev);
195
196			double coouv1[2];
197			double coouv2[2];
198			double coouv3[2];
199			coouv1[0]=noeud1->get_u();
200			coouv1[1]=noeud1->get_v();
201			coouv2[0]=noeud2->get_u();
202			coouv2[1]=noeud2->get_v();
203			coouv3[0]=noeud3->get_u();
204			coouv3[1]=noeud3->get_v();
205			double coouvd1[2];
206			double coouvd2[2];
207			double coouvd3[2];
208			double du=decalage.calcul_decalage_parametre_u(coouv1[0]);
209			double dv=decalage.calcul_decalage_parametre_v(coouv1[1]);
210			coouvd1[0]=decalage.decalage_parametre_u(coouv1[0],du);
211			coouvd1[1]=decalage.decalage_parametre_v(coouv1[1],dv);
212			coouvd2[0]=decalage.decalage_parametre_u(coouv2[0],du);
213			coouvd2[1]=decalage.decalage_parametre_v(coouv2[1],dv);
214			coouvd3[0]=decalage.decalage_parametre_u(coouv3[0],du);
215			coouvd3[1]=decalage.decalage_parametre_v(coouv3[1],dv);
216			double umin,vmin,umax,vmax;
217			umin=std::min(coouvd1[0],coouvd2[0]);
218			umin=std::min(umin,coouvd3[0]);
219			umax=std::max(coouvd1[0],coouvd2[0]);
220			umax=std::max(umax,coouvd3[0]);
221			vmin=std::min(coouvd1[1],coouvd2[1]);
222			vmin=std::min(vmin,coouvd3[1]);
223			vmax=std::max(coouv1[1],coouvd2[1]);
224			vmax=std::max(vmax,coouvd3[1]);
225			umin=umin-du;
226			umax=umax-du;
227			vmin=vmin-dv;
228			vmax=vmax-dv;
229			BOITE_2D boite(umin,vmin,umax,vmax);
230			return boite;
231			}
232
233			BOITE_3D MG_TRIANGLE::get_boite_3D(void)
234			{
235			double coo1[3];
236			double coo2[3];
237			double coo3[3];
238			coo1[0]=noeud1->get_x();
239			coo1[1]=noeud1->get_y();
240			coo1[2]=noeud1->get_z();
241			coo2[0]=noeud2->get_x();
242			coo2[1]=noeud2->get_y();
243			coo2[2]=noeud2->get_z();
244			coo3[0]=noeud3->get_x();
245			coo3[1]=noeud3->get_y();
246			coo3[2]=noeud3->get_z();
247			double xmin,ymin,zmin,xmax,ymax,zmax;
248			xmin=std::min(coo1[0],coo2[0]);
249			xmin=std::min(xmin,coo3[0]);
250			xmax=std::max(coo1[0],coo2[0]);
251			xmax=std::max(xmax,coo3[0]);
252			ymin=std::min(coo1[1],coo2[1]);
253			ymin=std::min(ymin,coo3[1]);
254			ymax=std::max(coo1[1],coo2[1]);
255			ymax=std::max(ymax,coo3[1]);
256			zmin=std::min(coo1[2],coo2[2]);
257			zmin=std::min(zmin,coo3[2]);
258			zmax=std::max(coo1[2],coo2[2]);
259			zmax=std::max(zmax,coo3[2]);
260			BOITE_3D boite(xmin,ymin,zmin,xmax,ymax,zmax);
261			return boite;
262			}
263			void MG_TRIANGLE::extrapoler_solution_noeud(void)
264			{
265	francois	377	for (int j=0;j<MAX_TYPE_SOLUTION;j++)
266			{
267			noeud1->change_solution(solution[j],j);
268			noeud2->change_solution(solution[j],j);
269			noeud3->change_solution(solution[j],j);
270			}
271	francois	283	}
272
273
274	francois	1036	void MG_TRIANGLE::normal(double *n)
275			{
276			double *xyz1=noeud1->get_coord();
277			double *xyz2=noeud2->get_coord();
278			double *xyz3=noeud3->get_coord();
279			OT_VECTEUR_3D vec1(xyz1,xyz2);
280			OT_VECTEUR_3D vec2(xyz1,xyz3);
281			OT_VECTEUR_3D nor=vec1&vec2;
282			nor.norme();
283			n[0]=nor.get_x();
284			n[1]=nor.get_y();
285			n[2]=nor.get_z();
286			}
287
288	francois	763	void MG_TRIANGLE::enregistrer(std::ostream& o,double version)
289	francois	283	{
290			if ((liaison_topologique==NULL) && (MG_MAILLAGE::DIMENSIONMAILLAGESANSTOPO!=2)) return;
291			if (liaison_topologique==NULL) o << "%" << get_id() << "=TRIANGLE(NULL,$" << noeud1->get_id() << ",$" << noeud2->get_id() << ",$" << noeud3->get_id() << "," << origine_creation << ");" << std::endl;
292			else if (liaison_topologique->get_dimension()==2) o << "%" << get_id() << "=TRIANGLE($"<< get_lien_topologie()->get_id() << ",$" << noeud1->get_id() << ",$" << noeud2->get_id() << ",$" << noeud3->get_id() << "," << origine_creation << ");" << std::endl;
293			}
294
295
296
297
298
299