reconstruction/src/sq_branche.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/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       sq_branche.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:56 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#include "sq_branche.h"


SQ_BRANCHE::SQ_BRANCHE(std::vector<SQ_NOEUD*> bran)
{
    Branche=bran;
        if(Branche.size()>1)
                calcul_longueur();
}


SQ_BRANCHE::SQ_BRANCHE()
{
}


SQ_BRANCHE::SQ_BRANCHE(SQ_BRANCHE& mdd)
{
    Branche=mdd.Branche;
        BrancheGuide=mdd.BrancheGuide;
        Longueur=mdd.Longueur;
        RayonMax=mdd.RayonMax;
    LstSections=mdd.LstSections;
        LstSections2=mdd.LstSections2;
    LstGuides=mdd.LstGuides;
        BrancheValide=mdd.BrancheValide;
}


SQ_BRANCHE::~SQ_BRANCHE()
{
}


std::vector<SQ_NOEUD*> SQ_BRANCHE::get_branche()
{
    return Branche;
}


std::vector<SQ_NOEUD*> SQ_BRANCHE::get_branche_guide()
{
        return BrancheGuide;
}


double SQ_BRANCHE::get_longueur()
{
        return Longueur;
}


double SQ_BRANCHE::get_rayon_max()
{
        return RayonMax;
}


std::vector<MG_NOEUD*> SQ_BRANCHE::get_section(int i)
{
    return LstSections[i].second;
}


std::vector<MG_NOEUD*> SQ_BRANCHE::get_section2(int i)
{
    return LstSections2[i].second;
}


SQ_NOEUD* SQ_BRANCHE::get_no_central_section(int i)
{
        return LstSections[i].first;
}


SQ_NOEUD* SQ_BRANCHE::get_no_central_section2(int i)
{
        return LstSections2[i].first;
}


int SQ_BRANCHE::get_nb_sections()
{
    return LstSections.size();
}


int SQ_BRANCHE::get_nb_sections2()
{
    return LstSections2.size();
}


std::vector<MG_NOEUD*> SQ_BRANCHE::get_guide(int i)
{
    return LstGuides[i];
}


int SQ_BRANCHE::get_nb_guides()
{
    return LstGuides.size();
}


bool SQ_BRANCHE::get_validite()
{
        return BrancheValide;
}


SQ_JONCTION* SQ_BRANCHE::get_jonction1()
{
        return Jonction1;
}


SQ_JONCTION* SQ_BRANCHE::get_jonction2()
{
        return Jonction2;
}


TopoDS_Shape SQ_BRANCHE::get_branche_solide()
{
        return BrancheSolide;
}


void SQ_BRANCHE::change_branche(std::vector<SQ_NOEUD*> Bran)
{
    Branche=Bran;
        if(Branche.size()>1)
                calcul_longueur();
}


void SQ_BRANCHE::change_branche_guide(std::vector<SQ_NOEUD*> BranGuide)
{
        BrancheGuide=BranGuide;
}


void SQ_BRANCHE::calcul_longueur()
{
        Longueur=0.;
        for(int i=0;i<Branche.size()-1;i++)
        {
                OT_VECTEUR_3D V(Branche[i]->get_coord(),Branche[i+1]->get_coord());
                Longueur+=V.get_longueur();
        }
}


void SQ_BRANCHE::change_rayon_max(double Rmax)
{
        RayonMax=Rmax;
}


void SQ_BRANCHE::ajouter_section(SQ_NOEUD* NoCentral,std::vector<MG_NOEUD*> Section)
{
    LstSections.push_back(std::make_pair(NoCentral,Section));
}


void SQ_BRANCHE::ajouter_section2(SQ_NOEUD* NoCentral,std::vector<MG_NOEUD*> Section)
{
    LstSections2.push_back(std::make_pair(NoCentral,Section));
}


void SQ_BRANCHE::ajouter_guide(std::vector<MG_NOEUD*> Guide)
{
    LstGuides.push_back(Guide);
}


void SQ_BRANCHE::change_validite(bool Validite)
{
        BrancheValide=Validite;
}


void SQ_BRANCHE::change_jonction1(SQ_JONCTION* Jonc1)
{
        Jonction1=Jonc1;
}


void SQ_BRANCHE::change_jonction2(SQ_JONCTION* Jonc2)
{
        Jonction2=Jonc2;
}


void SQ_BRANCHE::change_branche_solide(TopoDS_Shape BranSolid)
{
        BrancheSolide=BranSolid;
}
Revision:	1158
Committed:	Thu Jun 13 22:18:49 2024 UTC (11 months, 1 week ago) by francois
File size:	4030 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			//####// sq_branche.cpp
15			//####//
16			//####//------------------------------------------------------------
17			//####//------------------------------------------------------------
18			//####// COPYRIGHT 2000-2024
19			//####// jeu 13 jun 2024 11:58:56 EDT
20			//####//------------------------------------------------------------
21			//####//------------------------------------------------------------
22	amroune	1003	#include "sq_branche.h"
23
24	amroune	1015
25	amroune	1003	SQ_BRANCHE::SQ_BRANCHE(std::vector<SQ_NOEUD*> bran)
26			{
27	amroune	1089	Branche=bran;
28			if(Branche.size()>1)
29	amroune	1004	calcul_longueur();
30	amroune	1003	}
31
32
33
34	amroune	1004	SQ_BRANCHE::SQ_BRANCHE()
35	amroune	1003	{
36			}
37
38
39
40			SQ_BRANCHE::SQ_BRANCHE(SQ_BRANCHE& mdd)
41			{
42	amroune	1089	Branche=mdd.Branche;
43			BrancheGuide=mdd.BrancheGuide;
44			Longueur=mdd.Longueur;
45			RayonMax=mdd.RayonMax;
46	amroune	1003	LstSections=mdd.LstSections;
47	amroune	1089	LstSections2=mdd.LstSections2;
48	amroune	1003	LstGuides=mdd.LstGuides;
49	amroune	1089	BrancheValide=mdd.BrancheValide;
50	amroune	1003	}
51
52
53
54			SQ_BRANCHE::~SQ_BRANCHE()
55			{
56			}
57
58
59
60			std::vector<SQ_NOEUD*> SQ_BRANCHE::get_branche()
61			{
62	amroune	1089	return Branche;
63	amroune	1003	}
64
65
66
67	amroune	1089	std::vector<SQ_NOEUD*> SQ_BRANCHE::get_branche_guide()
68			{
69			return BrancheGuide;
70			}
71
72
73
74	amroune	1004	double SQ_BRANCHE::get_longueur()
75			{
76	amroune	1089	return Longueur;
77	amroune	1004	}
78
79
80
81	amroune	1005	double SQ_BRANCHE::get_rayon_max()
82			{
83	amroune	1089	return RayonMax;
84	amroune	1005	}
85
86
87
88	amroune	1003	std::vector<MG_NOEUD*> SQ_BRANCHE::get_section(int i)
89			{
90	amroune	1005	return LstSections[i].second;
91	amroune	1003	}
92
93
94
95	amroune	1089	std::vector<MG_NOEUD*> SQ_BRANCHE::get_section2(int i)
96			{
97			return LstSections2[i].second;
98			}
99
100
101
102	amroune	1005	SQ_NOEUD* SQ_BRANCHE::get_no_central_section(int i)
103			{
104			return LstSections[i].first;
105			}
106
107
108
109	amroune	1089	SQ_NOEUD* SQ_BRANCHE::get_no_central_section2(int i)
110			{
111			return LstSections2[i].first;
112			}
113
114
115
116	amroune	1004	int SQ_BRANCHE::get_nb_sections()
117	amroune	1003	{
118			return LstSections.size();
119			}
120	amroune	1089
121
122
123			int SQ_BRANCHE::get_nb_sections2()
124			{
125			return LstSections2.size();
126			}
127
128
129
130	amroune	1003	std::vector<MG_NOEUD*> SQ_BRANCHE::get_guide(int i)
131			{
132			return LstGuides[i];
133			}
134
135
136
137	amroune	1004	int SQ_BRANCHE::get_nb_guides()
138	amroune	1003	{
139			return LstGuides.size();
140			}
141
142
143
144	amroune	1004	bool SQ_BRANCHE::get_validite()
145			{
146	amroune	1089	return BrancheValide;
147	amroune	1004	}
148
149
150
151	amroune	1089	SQ_JONCTION* SQ_BRANCHE::get_jonction1()
152	amroune	1003	{
153	amroune	1089	return Jonction1;
154			}
155
156
157
158			SQ_JONCTION* SQ_BRANCHE::get_jonction2()
159			{
160			return Jonction2;
161			}
162
163
164
165			TopoDS_Shape SQ_BRANCHE::get_branche_solide()
166			{
167			return BrancheSolide;
168			}
169
170
171
172			void SQ_BRANCHE::change_branche(std::vector<SQ_NOEUD*> Bran)
173			{
174			Branche=Bran;
175			if(Branche.size()>1)
176	amroune	1004	calcul_longueur();
177	amroune	1003	}
178
179
180
181	amroune	1089	void SQ_BRANCHE::change_branche_guide(std::vector<SQ_NOEUD*> BranGuide)
182			{
183			BrancheGuide=BranGuide;
184			}
185
186
187
188	amroune	1004	void SQ_BRANCHE::calcul_longueur()
189			{
190	amroune	1089	Longueur=0.;
191			for(int i=0;i<Branche.size()-1;i++)
192	amroune	1004	{
193	amroune	1089	OT_VECTEUR_3D V(Branche[i]->get_coord(),Branche[i+1]->get_coord());
194			Longueur+=V.get_longueur();
195	amroune	1004	}
196			}
197
198
199
200	amroune	1005	void SQ_BRANCHE::change_rayon_max(double Rmax)
201	amroune	1003	{
202	amroune	1089	RayonMax=Rmax;
203	amroune	1003	}
204
205
206
207	amroune	1089	void SQ_BRANCHE::ajouter_section(SQ_NOEUD* NoCentral,std::vector<MG_NOEUD*> Section)
208	amroune	1005	{
209	amroune	1089	LstSections.push_back(std::make_pair(NoCentral,Section));
210	amroune	1005	}
211
212
213
214	amroune	1089	void SQ_BRANCHE::ajouter_section2(SQ_NOEUD* NoCentral,std::vector<MG_NOEUD*> Section)
215	amroune	1003	{
216	amroune	1089	LstSections2.push_back(std::make_pair(NoCentral,Section));
217	amroune	1003	}
218	amroune	1004
219
220
221	amroune	1089	void SQ_BRANCHE::ajouter_guide(std::vector<MG_NOEUD*> Guide)
222	amroune	1004	{
223	amroune	1089	LstGuides.push_back(Guide);
224			}
225
226
227
228			void SQ_BRANCHE::change_validite(bool Validite)
229			{
230			BrancheValide=Validite;
231			}
232
233
234
235			void SQ_BRANCHE::change_jonction1(SQ_JONCTION* Jonc1)
236			{
237			Jonction1=Jonc1;
238			}
239
240
241
242			void SQ_BRANCHE::change_jonction2(SQ_JONCTION* Jonc2)
243			{
244			Jonction2=Jonc2;
245			}
246
247
248
249			void SQ_BRANCHE::change_branche_solide(TopoDS_Shape BranSolid)
250			{
251			BrancheSolide=BranSolid;
252	francois	1158	}