0024510: Remove unused local variables
[occt.git] / src / TopOpeBRepBuild / TopOpeBRepBuild_FuseFace.cxx
CommitLineData
b311480e 1// Created on: 1998-07-28
2// Created by: LECLERE Florence
3// Copyright (c) 1998-1999 Matra Datavision
973c2be1 4// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e 5//
973c2be1 6// This file is part of Open CASCADE Technology software library.
b311480e 7//
973c2be1 8// This library is free software; you can redistribute it and / or modify it
9// under the terms of the GNU Lesser General Public version 2.1 as published
10// by the Free Software Foundation, with special exception defined in the file
11// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12// distribution for complete text of the license and disclaimer of any warranty.
b311480e 13//
973c2be1 14// Alternatively, this file may be used under the terms of Open CASCADE
15// commercial license or contractual agreement.
7fd59977 16
17#include <TopOpeBRepBuild_FuseFace.hxx>
18
19#include <TopTools_ListOfShape.hxx>
20#include <TopTools_ListIteratorOfListOfShape.hxx>
21#include <TopTools_MapOfShape.hxx>
22
23#include <TopTools_DataMapOfShapeListOfShape.hxx>
24#include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
25#include <TopTools_DataMapOfShapeInteger.hxx>
26#include <TopTools_DataMapIteratorOfDataMapOfShapeInteger.hxx>
27
28#include <TopExp_Explorer.hxx>
29
30#include <TopoDS.hxx>
31#include <TopoDS_Face.hxx>
32#include <TopoDS_Wire.hxx>
33#include <TopoDS_Edge.hxx>
34
35#include <BRepLib_MakeWire.hxx>
36#include <BRepLib_MakeFace.hxx>
37#include <BRepLib_MakeEdge.hxx>
38
39#include <BRep_Builder.hxx>
40#include <BRep_Tool.hxx>
41#include <BRepCheck_Analyzer.hxx>
42
43#include <Geom_Surface.hxx>
44#include <Geom_RectangularTrimmedSurface.hxx>
45#include <Geom_Curve.hxx>
46#include <Geom_TrimmedCurve.hxx>
47#include <Geom_Line.hxx>
48#include <Geom_Circle.hxx>
49#include <Geom_Ellipse.hxx>
50#include <Geom_BSplineCurve.hxx>
51#include <Geom_BezierCurve.hxx>
52#include <TColgp_Array1OfPnt.hxx>
53#include <TColStd_Array1OfReal.hxx>
54#include <TColStd_Array1OfInteger.hxx>
55#include <ElCLib.hxx>
56#include <Precision.hxx>
57
58#ifdef DEB
1d0a9d4d 59extern Standard_Boolean TopOpeBRepBuild_GettraceFUFA();
7fd59977 60#endif
61
62static void GroupShape(TopTools_ListOfShape&,
63 Standard_Boolean,
64 TopTools_DataMapOfShapeListOfShape&);
65
66static void GroupEdge(TopTools_DataMapOfShapeListOfShape&,
67 TopTools_DataMapOfShapeListOfShape&);
68
69static void MakeEdge(TopTools_DataMapOfShapeListOfShape&);
70
71static Standard_Boolean SameSupport(const TopoDS_Edge&,
72 const TopoDS_Edge&);
73
74//=======================================================================
75//function : Init
76//purpose :
77//=======================================================================
78void TopOpeBRepBuild_FuseFace::Init(const TopTools_ListOfShape& LIF,
79 const TopTools_ListOfShape& LRF,
80 const Standard_Integer CXM)
81{
82#ifdef DEB
83 Standard_Boolean trc = TopOpeBRepBuild_GettraceFUFA();
84 if (trc) cout << "TopOpeBRepBuild_FuseFace::Init" << endl;
85#endif
86 myLIF = LIF;
87 myLRF = LRF;
88 if(CXM == 1) {
89 myInternal = Standard_False;
90 }
91 else if(CXM == 2) {
92 myInternal = Standard_True;
93 } // CXM
94#ifdef DEB
95 if (trc) {
96 if (myInternal) {
97 cout << " TopOpeBRepBuild_FuseFace::Init : Keep internal connections" << endl;
98 } else {
99 cout << " TopOpeBRepBuild_FuseFace::Init : Suppress internal connections" << endl;
100 }
101 }
102#endif
103
104 myLFF.Clear();
105
106 myLIE.Clear();
107 myLEE.Clear();
108 myLME.Clear();
109
110 myLIV.Clear();
111 myLEV.Clear();
112 myLMV.Clear();
113
114 myModified = Standard_False;
115 myDone = Standard_False;
116
117}
118
119//=======================================================================
120//function : PerformFace
121//purpose : fusion des faces cosurfaciques, connexes par une ou
122//plusieurs aretes
123//=======================================================================
124
125void TopOpeBRepBuild_FuseFace::PerformFace()
126{
127#ifdef DEB
128 Standard_Boolean trc = TopOpeBRepBuild_GettraceFUFA();
129 if (trc) cout << "TopOpeBRepBuild_FuseFace::PerformFace()" << endl;
130#endif
131
132 myModified = Standard_False;
133 myLFF.Clear();
134 if (myLRF.IsEmpty()) {
135#ifdef DEB
136 if (trc) cout<<" TopOpeBRepBuild_FuseFace::PerformFace : Empty list of reconstructed faces"<<endl;
137#endif
138 myModified = Standard_False;
139 myDone = Standard_True;
140 myLFF = myLRF;
141 return;
142 }
143
144 Standard_Integer number = myLRF.Extent();
145 if (number == 1) {
146#ifdef DEB
147 if (trc) cout<<" TopOpeBRepBuild_FuseFace::PerformFace : only 1 reconstructed face"<<endl;
148#endif
149 myModified = Standard_False;
150 myDone = Standard_True;
151 myLFF = myLRF;
152 return;
153 }
154
155 TopTools_ListIteratorOfListOfShape it2,it3,it4;
156 TopTools_DataMapIteratorOfDataMapOfShapeListOfShape itt1,itt2,itt3;
96a95605 157 TopAbs_Orientation ori1;
7fd59977 158
159 Standard_Boolean Ori3dReversed = Standard_False;
160 Standard_Boolean Ori3dForward = Standard_False;
161 TopTools_ListOfShape mylist;
162 for(it2.Initialize(myLRF); it2.More(); it2.Next()) {
163 TopoDS_Shape fac = it2.Value();
164 ori1 = fac.Orientation();
165 if (ori1 == TopAbs_FORWARD) {
166 Ori3dForward = Standard_True;
167 }
168 if (ori1 == TopAbs_REVERSED) {
169 Ori3dReversed = Standard_True;
170 }
171 BRepCheck_Analyzer ana(fac);
172 if (!ana.IsValid(fac)) {
173// if (!BRepCheck_Analyzer::IsValid(fac)) {
174#ifdef DEB
175 if (trc) cout<<" TopOpeBRepBuild_FuseFace::PerformFace : Invalid reconstructed face"<<endl;
176#endif
177 myModified = Standard_False;
178 myDone = Standard_True;
179 myLFF = myLRF;
180 return;
181 }
182 fac.Orientation(TopAbs_FORWARD);
183 mylist.Append(fac);
184 }
185
186// Orientation 3d de l'espace limite par la face
187 if (Ori3dForward && Ori3dReversed) {
188#ifdef DEB
189 if (trc) cout<<" TopOpeBRepBuild_FuseFace::PerformFace : Bad faces 3d orientation"<<endl;
190#endif
191 myModified = Standard_False;
192 myDone = Standard_True;
193 myLFF = myLRF;
194 return;
195 }
196
197// listes de faces avec edges communes.
198 Standard_Boolean Keep_Edge;
199 Keep_Edge = Standard_False;
200 TopTools_DataMapOfShapeListOfShape mapFacLFac;
201 GroupShape(mylist,Keep_Edge,mapFacLFac);
202 if (mapFacLFac.IsEmpty()) {
203#ifdef DEB
204 if (trc) cout<<" TopOpeBRepBuild_FuseFace::PerformFace : Empty list of faces"<<endl;
205#endif
206 myModified = Standard_False;
207 myDone = Standard_True;
208 myLFF = myLRF;
209 return;
210 }
211 Standard_Integer n1 = myLRF.Extent();
212 Standard_Integer n2 = mapFacLFac.Extent();
213 if (n1 == n2) {
214#ifdef DEB
215 if (trc) cout<<" TopOpeBRepBuild_FuseFace::PerformFace : No connection"<<endl;
216#endif
217 myModified = Standard_False;
218 myDone = Standard_True;
219 myLFF = myLRF;
220 return;
221 }
222
223
224//boucle sur les listes des faces de 1 face de LRF
225
226 for (itt1.Initialize(mapFacLFac); itt1.More(); itt1.Next()) {
227 const TopoDS_Shape& fac = itt1.Key();
228 TopoDS_Face facref = TopoDS::Face(fac);
229 const TopTools_ListOfShape& LFac = mapFacLFac.Find(fac);
230
231 Standard_Integer n11 = LFac.Extent();
232 if (n11 != 1) {
233 TopTools_ListOfShape LWir;
234 for(it2.Initialize(LFac); it2.More(); it2.Next()) {
235 const TopoDS_Shape& fac1 = it2.Value();
236
237 TopExp_Explorer exp;
238 for (exp.Init(fac1,TopAbs_WIRE); exp.More(); exp.Next()) {
239 const TopoDS_Shape& wir = exp.Current();
240 LWir.Append(wir);
241 }
242 } // LFac
243 // listes des wires avec edges communes.
244 Keep_Edge = Standard_False;
245 TopTools_DataMapOfShapeListOfShape mapWirLWir;
246 GroupShape(LWir,Keep_Edge,mapWirLWir);
247 if (mapWirLWir.IsEmpty()) {
248#ifdef DEB
249 if (trc) cout<<" TopOpeBRepBuild_FuseFace::PerformFace : Empty list of wires"<<endl;
250#endif
251 myModified = Standard_False;
252 myDone = Standard_True;
253 myLFF = myLRF;
254 return;
255 }
256
257// boucle sur les listes des wires de 1 face de LRF
258 TopTools_ListOfShape myFaceLIE,myFaceLEE,myFaceLME,myFaceLW;
259 for (itt2.Initialize(mapWirLWir); itt2.More(); itt2.Next()) {
260 const TopoDS_Shape& wir = itt2.Key();
261 const TopTools_ListOfShape& LWir1 = mapWirLWir.Find(wir);
262
263 Standard_Integer n22 = LWir1.Extent();
264 if (n22 != 1) {
265// boucle sur 1 liste des wires avec edges communes.
266 TopTools_ListOfShape LEdg;
267 for(it3.Initialize(LWir1); it3.More(); it3.Next()) {
268 const TopoDS_Shape& wir1 = it3.Value();
269
270 TopExp_Explorer exp;
271 for (exp.Init(wir1,TopAbs_EDGE); exp.More(); exp.Next()) {
272 const TopoDS_Shape& edg = exp.Current();
273 LEdg.Append(edg);
274 }
275 } // LWir1
276// listes des edges avec edges communes.
277 Keep_Edge = Standard_True;
278 TopTools_DataMapOfShapeListOfShape mapEdgLEdg;
279 GroupShape(LEdg,Keep_Edge,mapEdgLEdg);
280 if (mapEdgLEdg.IsEmpty()) {
281#ifdef DEB
282 if (trc) cout<<" TopOpeBRepBuild_FuseFace::PerformFace : Empty list of edges"<<endl;
283#endif
284 myModified = Standard_False;
285 myDone = Standard_True;
286 myLFF = myLRF;
287 return;
288 }
289
290// Elimination selon logique pure
291// boucle sur les listes des egdes de 1 wire de 1 face de LRF
292 TopTools_ListOfShape myWireLE;
293 for (itt3.Initialize(mapEdgLEdg); itt3.More(); itt3.Next()) {
294 const TopoDS_Shape& edg = itt3.Key();
7fd59977 295 const TopTools_ListOfShape& LEdg1 = mapEdgLEdg.Find(edg);
296 Standard_Boolean OriReversed = Standard_False;
297 Standard_Boolean OriForward = Standard_False;
298 Standard_Boolean OriInternal = Standard_False;
299 Standard_Boolean OriExternal = Standard_False;
300 for(it4.Initialize(LEdg1); it4.More(); it4.Next()) {
301 const TopoDS_Shape& edg1 = it4.Value();
302 ori1 = edg1.Orientation();
303 if (ori1 == TopAbs_REVERSED) {
304 if (OriReversed) {
305#ifdef DEB
306 if (trc) cout<<" TopOpeBRepBuild_FuseFace::PerformFace : Bad faces orientation"<<endl;
307#endif
308 myModified = Standard_False;
309 myDone = Standard_True;
310 myLFF = myLRF;
311 return;
312 }
313 OriReversed = Standard_True;
314 }
315 else if (ori1 == TopAbs_FORWARD) {
316 if (OriForward) {
317#ifdef DEB
318 if (trc) cout<<" TopOpeBRepBuild_FuseFace::PerformFace : Bad faces orientation"<<endl;
319#endif
320 myModified = Standard_False;
321 myDone = Standard_True;
322 myLFF = myLRF;
323 return;
324 }
325 OriForward = Standard_True;
326 }
327 else if (ori1 == TopAbs_INTERNAL) {
328 OriInternal = Standard_True;
329 }
330 else if (ori1 == TopAbs_EXTERNAL) {
331 OriExternal = Standard_True;
332 }
333 } // LEdg1
334
335// - Traitement edge selon orientation
336// On privilegie orientation selon 1) reversed ou forward
337// 2) internal
338// 3) external
339// pour traiter cas ou l'on a au moins 2 orientations differentes parmi
340// forward et reversed - interne - externe
341
342 if (OriReversed || OriForward) {
343 if (OriReversed && OriForward) {
344// TopoDS_Shape& edg1 = edg.Oriented(TopAbs_INTERNAL);
345 const TopoDS_Shape& edg1 = edg.Oriented(TopAbs_INTERNAL);
346 myLME.Append(edg1);
347 myFaceLME.Append(edg1);
348 } else if (OriReversed) {
349// TopoDS_Shape& edg1 = edg.Oriented(TopAbs_REVERSED);
350 const TopoDS_Shape& edg1 = edg.Oriented(TopAbs_REVERSED);
351 myWireLE.Append(edg1);
352 } else {
353// TopoDS_Shape& edg1 = edg.Oriented(TopAbs_FORWARD);
354 const TopoDS_Shape& edg1 = edg.Oriented(TopAbs_FORWARD);
355 myWireLE.Append(edg1);
356 }
357 }
358 else if (OriInternal) {
359// TopoDS_Shape& edg1 = edg.Oriented(TopAbs_INTERNAL);
360 const TopoDS_Shape& edg1 = edg.Oriented(TopAbs_INTERNAL);
361 myLIE.Append(edg1);
362 myFaceLIE.Append(edg1);
363 }
364 else if (OriExternal) {
365// TopoDS_Shape& edg1 = edg.Oriented(TopAbs_EXTERNAL);
366 const TopoDS_Shape& edg1 = edg.Oriented(TopAbs_EXTERNAL);
367 myLEE.Append(edg1);
368 myFaceLEE.Append(edg1);
369 } // Ori
370 } // mapEdgLEdg
371
372// Reconstrution de 1 wire de 1 face de LRF
373// Attention cas ou une liste de wire connectes conduit a plusieurs Wires
374 Standard_Integer number1 = myWireLE.Extent();
375 while (number1 > 0) {
376 BRepLib_MakeWire MW;
377 MW.Add(myWireLE);
378 if (!MW.IsDone()) {
379#ifdef DEB
380 if (trc) cout<<" TopOpeBRepBuild_FuseFace::PerformFace : Failure in making wire"<<endl;
381#endif
382 myModified = Standard_False;
383 myDone = Standard_True;
384 myLFF = myLRF;
385 return;
386 }
387
388// Astuce pour contourner Wire Not Closed
389 TopoDS_Wire W = MW.Wire();
390 BRepLib_MakeWire MW1(W);
391 W = MW1.Wire();
392
393 myFaceLW.Append(W);
394
395 TopExp_Explorer exp;
396 TopTools_MapOfShape M;
397 Standard_Integer nb = 0;
398 for (exp.Init(W,TopAbs_EDGE); exp.More(); exp.Next()) {
399 const TopoDS_Shape& edg3 = exp.Current();
400 M.Add(edg3);
401 nb++;
402 }
403
404 if (nb == number1) {
405 number1 = 0 ;
406 }
407 else {
408 TopTools_ListOfShape ListEdge;
409 for(it3.Initialize(myWireLE); it3.More(); it3.Next()) {
410 const TopoDS_Shape& edg2 = it3.Value();
411 if (M.Add(edg2)) {
412 ListEdge.Append(edg2);
413 }
414 }
415 myWireLE.Assign(ListEdge);
416 number1 = myWireLE.Extent();
417 } // nb
418 } // number
419 }
420 else {
421 myFaceLW.Append(wir);
422 } // n2 =1
423 } // mapWirLWir
424
425// Reconstrution de 1 face de LRF
426 Handle(Geom_Surface) S = BRep_Tool::Surface(facref);
427 if (S->DynamicType() ==
428 STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
429 S = Handle(Geom_RectangularTrimmedSurface)::
430 DownCast(S)->BasisSurface();
431 }
1c72dff6 432 BRepLib_MakeFace MF(S, Precision::Confusion());
7fd59977 433
434 for(it2.Initialize(myFaceLW); it2.More(); it2.Next()) {
435 const TopoDS_Wire& wir1 = TopoDS::Wire(it2.Value());
436 MF.Add(wir1);
437 }
438
439// Ajout des Edges Internes
440// Externes
441// Modifiees
442 for (it2.Initialize(myFaceLIE); it2.More(); it2.Next()) {
443 const TopoDS_Edge& edg1 = TopoDS::Edge(it2.Value());
444 BRepLib_MakeWire MW(edg1);
445// MW.Add(edg1);
446 const TopoDS_Wire& W = MW.Wire();
447 MF.Add(W);
448 }
449 for (it2.Initialize(myFaceLEE); it2.More(); it2.Next()) {
450 const TopoDS_Edge& edg1 = TopoDS::Edge(it2.Value());
451 BRepLib_MakeWire MW(edg1);
452// MW.Add(edg1);
453 const TopoDS_Wire& W = MW.Wire();
454 MF.Add(W);
455 }
456 if (myInternal) {
457 for (it2.Initialize(myFaceLME); it2.More(); it2.Next()) {
458 const TopoDS_Edge& edg1 = TopoDS::Edge(it2.Value());
459 BRepLib_MakeWire MW(edg1);
460// MW.Add(edg1);
461 const TopoDS_Wire& W = MW.Wire();
462 MF.Add(W);
463 }
464 }
465
466 if (!MF.IsDone()) {
467#ifdef DEB
468 if (trc) cout<<" TopOpeBRepBuild_FuseFace::PerformFace : Failure in making face"<<endl;
469#endif
470 myModified = Standard_False;
471 myDone = Standard_True;
472 myLFF = myLRF;
473 return;
474 }
475 TopoDS_Face F = MF.Face();
476 if (Ori3dReversed) {
477 F.Reverse();
478 }
479 myLFF.Append(F);
480 }
481 else {
482 myLFF.Append(facref);
483 } // n1 = 1
484 } // mapFacLFac
485
486 if (myLFF.IsEmpty()) {
487#ifdef DEB
488 if (trc) cout<<" TopOpeBRepBuild_FuseFace::PerformFace : Empty list of fusionned faces"<<endl;
489#endif
490 myModified = Standard_False;
491 myDone = Standard_True;
492 myLFF = myLRF;
493 return;
494 }
495
496 myModified = Standard_True;
497 myDone = Standard_True;
498
499#ifdef DEB
500 if (trc) cout << " TopOpeBRepBuild_FuseFace::PerformFace() : Done" << endl;
501#endif
502}
503
504//=======================================================================
505//function : PerformEdge
506//purpose : fusion des edges cosurfaciques, connexes par une ou
507//plusieurs aretes
508//=======================================================================
509
510void TopOpeBRepBuild_FuseFace::PerformEdge()
511{
512#ifdef DEB
513 Standard_Boolean trc = TopOpeBRepBuild_GettraceFUFA();
514 if (trc) cout << "TopOpeBRepBuild_FuseFace::PerformEdge()" << endl;
515#endif
516 TopTools_DataMapOfShapeListOfShape mapVerLEdg,mapTampon;
517
518 TopTools_ListIteratorOfListOfShape it1;
519 TopTools_DataMapIteratorOfDataMapOfShapeListOfShape itt1;
520// TopAbs_Orientation ori,ori1;
521
522//Niveau 1
523//boucle sur les listes des faces de 1 face de LRF
524
525 for (it1.Initialize(myLFF); it1.More(); it1.Next()) {
526 const TopoDS_Shape& fac = it1.Value();
527
528 TopExp_Explorer expw;
529 for (expw.Init(fac,TopAbs_WIRE); expw.More(); expw.Next()) {
530 const TopoDS_Shape& wir = expw.Current();
531
532 TopExp_Explorer expe;
533 for (expe.Init(wir,TopAbs_EDGE); expe.More(); expe.Next()) {
534 const TopoDS_Shape& edg = expe.Current();
535
536 TopExp_Explorer expv;
537 for (expv.Init(edg,TopAbs_VERTEX); expv.More(); expv.Next()) {
538 const TopoDS_Shape& ver = expv.Current();
539 if (!mapVerLEdg.IsBound(ver)) {
540 TopTools_ListOfShape LmapEdg;
541 LmapEdg.Append(edg);
542 mapVerLEdg.Bind(ver,LmapEdg);
543 }
544 else {
545 TopTools_ListOfShape& LmapEdg = mapVerLEdg.ChangeFind(ver);
546 LmapEdg.Append(edg);
547 }
548 }
549 }
550 }
551 }
552
553//nettoyage du tableau mapVerLSh : shap1 : shap1 shap2 shap3
554//On ne garde que les vertex qui appartiennent a - exactement 2 edges
555// - de meme support geometrique
556 mapTampon = mapVerLEdg;
557 mapVerLEdg.Clear();
558
559 for (itt1.Initialize(mapTampon); itt1.More(); itt1.Next()) {
560 const TopoDS_Shape& ver = itt1.Key();
561 const TopTools_ListOfShape& LmapEdg = mapTampon.Find(ver);
562 Standard_Integer number = LmapEdg.Extent();
563 if (number == 2){
564 it1.Initialize(LmapEdg);
565 const TopoDS_Edge& edg1 = TopoDS::Edge(it1.Value());
566 it1.Next();
567 const TopoDS_Edge& edg2 = TopoDS::Edge(it1.Value());
568 if (SameSupport(edg1,edg2)) {
569 mapVerLEdg.Bind(ver,LmapEdg);
570 }
571 }
572 }
573
574//On regroupe ensemble tous les edges consecutifs et SameSupport
575 TopTools_DataMapOfShapeListOfShape mapEdgLEdg;
576 GroupEdge(mapVerLEdg,mapEdgLEdg);
577
578//On construit les edges somme des edges consecutifs et SameSupport
579 MakeEdge(mapEdgLEdg);
580
581 myModified = Standard_True;
582 myDone = Standard_True;
583
584#ifdef DEB
585 if (trc) cout << " TopOpeBRepBuild_FuseFace::PerformEdge() : Done" << endl;
586#endif
587}
588
589//=======================================================================
590//function : ClearEdge
591//purpose : Nettoyage des Faces : Suppression des edges internes et externes
592//=======================================================================
593
594void TopOpeBRepBuild_FuseFace::ClearEdge()
595{
596#ifdef DEB
597 Standard_Boolean trc = TopOpeBRepBuild_GettraceFUFA();
598 if (trc) cout << "TopOpeBRepBuild_FuseFace::ClearEdge()" << endl;
599#endif
600
601 TopTools_ListIteratorOfListOfShape it1,it2;
602 TopAbs_Orientation ori;
603 TopTools_ListOfShape myLFFnew;
604
605//Niveau 1
606//boucle sur les listes des faces de 1 face de LRF
607
608 for (it1.Initialize(myLFF); it1.More(); it1.Next()) {
609 const TopoDS_Shape& fac = it1.Value();
610
611 TopTools_ListOfShape myFaceLW;
612 TopExp_Explorer expw;
613 for (expw.Init(fac,TopAbs_WIRE); expw.More(); expw.Next()) {
614 const TopoDS_Shape& wir = expw.Current();
615
616 TopTools_ListOfShape myWireLE;
617 TopExp_Explorer expe;
618 for (expe.Init(wir,TopAbs_EDGE); expe.More(); expe.Next()) {
619 const TopoDS_Shape& edg = expe.Current();
620
621// Elimination selon des edges interne et externe
622
623 ori = edg.Orientation();
624 if (ori == TopAbs_INTERNAL) {
625 myLIE.Append(edg);
626 }
627 else if (ori == TopAbs_EXTERNAL) {
628 myLEE.Append(edg);
629 }
630 else {
631 myWireLE.Append(edg);
632 }
633 }
634// Fin Niveau 3
635// Reconstrution de 1 wire de 1 face de LRF
636 if (!myWireLE.IsEmpty()) {
637 BRepLib_MakeWire MW;
638 MW.Add(myWireLE);
639 if (!MW.IsDone()) {
640#ifdef DEB
641 if (trc) cout<<" TopOpeBRepBuild_FuseFace::ClearEdge : Failure in making wire"<<endl;
642#endif
643 myModified = Standard_False;
644 myDone = Standard_True;
645 myLFF = myLRF;
646 return;
647 }
648
649 // Astuce pour contourner Wire Not Closed
650 TopoDS_Wire W = MW.Wire();
651 BRepLib_MakeWire MW1(W);
652 W = MW1.Wire();
653
654 myFaceLW.Append(W);
655 }
656 }
657// Fin Niveau 2
658// Reconstrution de 1 face de LRF
659 if (myFaceLW.IsEmpty()) {
660#ifdef DEB
661 if (trc) cout<<" TopOpeBRepBuild_FuseFace::ClearEdge : Empty list of wires"<<endl;
662#endif
663 myModified = Standard_False;
664 myDone = Standard_True;
665 myLFF = myLRF;
666 return;
667 }
668 it2.Initialize(myFaceLW);
669 const TopoDS_Wire& wir = TopoDS::Wire(it2.Value());
670 const Standard_Boolean OnlyPlane = Standard_False;
671 BRepLib_MakeFace MF(wir,OnlyPlane);
672
673 it2.Next();
674 for( ; it2.More(); it2.Next()) {
675 const TopoDS_Wire& wir1 = TopoDS::Wire(it2.Value());
676 MF.Add(wir1);
677 }
678 if (!MF.IsDone()) {
679#ifdef DEB
680 if (trc) cout<<" TopOpeBRepBuild_FuseFace::ClearEdge : Failure in making face"<<endl;
681#endif
682 myModified = Standard_False;
683 myDone = Standard_True;
684 myLFF = myLRF;
685 return;
686 }
687 const TopoDS_Face& F = MF.Face();
688 myLFFnew.Append(F);
689 }
690//Fin Niveau 1
691 if (myLFFnew.IsEmpty()) {
692#ifdef DEB
693 if (trc) cout<<" TopOpeBRepBuild_FuseFace::ClearEdge : Empty list of fusionned faces"<<endl;
694#endif
695 myModified = Standard_False;
696 myDone = Standard_True;
697 myLFF = myLRF;
698 return;
699 }
700 myLFF = myLFFnew;
701
702 myModified = Standard_True;
703 myDone = Standard_True;
704
705#ifdef DEB
706 if (trc) cout << " TopOpeBRepBuild_FuseFace::ClearEdge() : Done" << endl;
707#endif
708}
709
710//=======================================================================
711//function : ClearVertex
712//purpose : Nettoyage des Faces : Suppression des vertex internes et externes
713//=======================================================================
714
715void TopOpeBRepBuild_FuseFace::ClearVertex()
716{
717#ifdef DEB
718 Standard_Boolean trc = TopOpeBRepBuild_GettraceFUFA();
719 if (trc) cout << "TopOpeBRepBuild_FuseFace::ClearVertex()" << endl;
720#endif
721
722#ifdef DEB
723 if (trc) cout << " TopOpeBRepBuild_FuseFace::ClearVertex() : Done" << endl;
724#endif
725}
726
727//=======================================================================
728//function : GroupShape
729//purpose :
730//=======================================================================
731
732static void GroupShape(TopTools_ListOfShape& mylist,Standard_Boolean Keep_Edge, TopTools_DataMapOfShapeListOfShape& mymapShLSh)
733{
734 TopTools_ListIteratorOfListOfShape it,it1,it2;
735 TopTools_DataMapOfShapeListOfShape mapEdgLSh,mapShLSh;
736 TopTools_ListOfShape LmapSh4;
737 TopAbs_Orientation ori;
738
739// construction du tableau C=locmapEdgLSh : egde1 - shap1 shap2 shap3
740// construction du tableau locmapShLSh : shap1 - shap1 shap2 shap3
741 LmapSh4.Clear();
742 for(it.Initialize(mylist); it.More(); it.Next()) {
743 const TopoDS_Shape& shap1 = it.Value();
744 TopTools_ListOfShape LmapSh;
745 LmapSh.Append(shap1);
746
747 mapShLSh.Bind(shap1,LmapSh);
748
749 TopExp_Explorer expe;
750 for (expe.Init(shap1,TopAbs_EDGE); expe.More(); expe.Next()) {
751 const TopoDS_Shape& edg1 = expe.Current();
752// verification si Edge a prendre en compte
753 ori = edg1.Orientation();
754 Standard_Boolean Edge_OK = Standard_True;
755 if (ori == TopAbs_INTERNAL || ori == TopAbs_EXTERNAL) {
756 Edge_OK = Standard_False;
757 }
758 if (Edge_OK || Keep_Edge) {
759 if (!mapEdgLSh.IsBound(edg1)) {
760 TopTools_ListOfShape LmapEdg;
761 LmapEdg.Append(shap1);
762 mapEdgLSh.Bind(edg1,LmapEdg);
763 }
764 else {
765 TopTools_ListOfShape& LmapEdg = mapEdgLSh.ChangeFind(edg1);
766 LmapEdg.Append(shap1);
767
768 if (!Keep_Edge) {
769
770// Recuperation premier shape de liste liee a edg1
771 it1.Initialize(LmapEdg);
772 const TopoDS_Shape& shap2 = it1.Value();
773
774// Controle si premier shape et shape courant sont deja lies
775 TopTools_ListOfShape LmapSh1;
776 LmapSh1 = mapShLSh.Find(shap2);
777 for(it1.Initialize(LmapSh1); it1.More(); it1.Next()) {
778 const TopoDS_Shape& shap = it1.Value();
779 if (shap.IsSame(shap1)) {
780 break;
781 }
782 }
783// Premier shape et Shape courant ne sont pas deja lies
784 if (!it1.More()){
785 const TopTools_ListOfShape& LmapSh11 = mapShLSh.Find(shap1);
786 const TopTools_ListOfShape& LmapSh2 = mapShLSh.Find(shap2);
787 TopTools_ListOfShape Lmap1;
788 TopTools_ListOfShape Lmap2;
789 Lmap1.Assign(LmapSh11);
790 Lmap2.Assign(LmapSh2);
791
792 for(it2.Initialize(Lmap1); it2.More(); it2.Next()) {
793 const TopoDS_Shape& shap = it2.Value();
794 TopTools_ListOfShape& Lmap = mapShLSh.ChangeFind(shap);
795 TopTools_ListOfShape Lmap3;
796 Lmap3.Assign(Lmap2);
797 Lmap.Append(Lmap3);
798 }
799 for(it2.Initialize(Lmap2); it2.More(); it2.Next()) {
800 const TopoDS_Shape& shap = it2.Value();
801 TopTools_ListOfShape& Lmap = mapShLSh.ChangeFind(shap);
802 TopTools_ListOfShape Lmap3;
803 Lmap3.Assign(Lmap1);
804 Lmap.Append(Lmap3);
805 }
806 }
807 }
808 }
809 }
810 }
811 }
812
813// nettoyage du tableau mapShLSh : shap1 : shap1 shap2 shap3
814 mymapShLSh.Clear();
815
816 TopTools_DataMapIteratorOfDataMapOfShapeListOfShape itt;
817 if (!Keep_Edge) {
818 TopTools_MapOfShape M;
819 for (itt.Initialize(mapShLSh); itt.More(); itt.Next()) {
820 const TopoDS_Shape& shap1 = itt.Key();
821 if (M.Add(shap1)) {
822 const TopTools_ListOfShape& LmapSh = mapShLSh.Find(shap1);
823 mymapShLSh.Bind(shap1,LmapSh);
824
825 for(it1.Initialize(LmapSh); it1.More(); it1.Next()) {
826 const TopoDS_Shape& shap2 = it1.Value();
827 M.Add(shap2);
828 }
829 }
830 }
831 }
832 else {
833 mymapShLSh = mapEdgLSh;
834 }
835}
836
837//=======================================================================
838//function : GroupEdge
839//purpose :
840//=======================================================================
841
842static void GroupEdge(TopTools_DataMapOfShapeListOfShape& mymapVerLEdg, TopTools_DataMapOfShapeListOfShape& mymapEdgLEdg)
843{
844 TopTools_ListIteratorOfListOfShape it1,it2;
845 TopTools_DataMapIteratorOfDataMapOfShapeListOfShape itt;
846 TopTools_DataMapOfShapeListOfShape mapEdgLEdg;
847
848// construction du tableau C=locmapEdgLSh : egde1 - shap1 shap2 shap3
849// construction du tableau locmapShLSh : shap1 - shap1 shap2 shap3
850 for(itt.Initialize(mymapVerLEdg); itt.More(); itt.Next()) {
851 const TopoDS_Shape& ver1 = itt.Key();
852 TopTools_ListOfShape LmapEdg;
853 LmapEdg = mymapVerLEdg.Find(ver1);
854
855 it1.Initialize(LmapEdg);
856 const TopoDS_Edge& edg1 = TopoDS::Edge(it1.Value());
857 it1.Next();
858 const TopoDS_Edge& edg2 = TopoDS::Edge(it1.Value());
859
860 Standard_Boolean Edge1Add,Edge2Add;
861 TopoDS_Edge edgold,edgnew;
862 if (mapEdgLEdg.IsBound(edg1)) {
863 Edge1Add = Standard_False;
864 edgold = edg1;
865 } else {
866 Edge1Add = Standard_True;
867 edgnew = edg1;
868 }
869 if (mapEdgLEdg.IsBound(edg2)) {
870 Edge2Add = Standard_False;
871 edgold = edg2;
872 } else {
873 Edge2Add = Standard_True;
874 edgnew = edg2;
875 }
876
877 if (!(Edge1Add || Edge2Add)) {
878 continue;
879 }
880 else if (Edge1Add && Edge2Add) {
881 mapEdgLEdg.Bind(edg1,LmapEdg);
882 mapEdgLEdg.Bind(edg2,LmapEdg);
883 }
884 else {
885
886
887// Recuperation premier shape de liste liee a edg1 et mise a jour
888
889 TopTools_ListOfShape LmapEdg11;
890 LmapEdg11.Append(edgnew);
891 mapEdgLEdg.Bind(edgnew,LmapEdg11);
892
893 TopTools_ListOfShape LmapEdg1;
894 LmapEdg1 = mapEdgLEdg.Find(edgold);
895
896 for(it2.Initialize(LmapEdg1); it2.More(); it2.Next()) {
897 const TopoDS_Shape& edg22 = it2.Value();
898 TopTools_ListOfShape& LmapEdg2 = mapEdgLEdg.ChangeFind(edgnew);
899 LmapEdg2.Append(edg22);
900 TopTools_ListOfShape& LmapEdg3 = mapEdgLEdg.ChangeFind(edg22);
901 LmapEdg3.Append(edgnew);
902 }
903 }
904 }
905
906// nettoyage du tableau mapEdgLedg : edg1 : edg1 edg2 edg3
907
908 TopTools_MapOfShape M;
909
910 for (itt.Initialize(mapEdgLEdg); itt.More(); itt.Next()) {
911 const TopoDS_Shape& edg1 = itt.Key();
912 if (M.Add(edg1)) {
913 const TopTools_ListOfShape& LmapEdg = mapEdgLEdg.Find(edg1);
914 mymapEdgLEdg.Bind(edg1,LmapEdg);
915
916 for(it1.Initialize(LmapEdg); it1.More(); it1.Next()) {
917 const TopoDS_Shape& edg2 = it1.Value();
918 M.Add(edg2);
919 }
920 }
921 }
922}
923
924//=======================================================================
925//function : MakeEdge
926//purpose :
927//=======================================================================
928
929static void MakeEdge(TopTools_DataMapOfShapeListOfShape& mymapEdgLEdg)
930{
931#ifdef DEB
932 Standard_Boolean trc = TopOpeBRepBuild_GettraceFUFA();
933#endif
934
935 TopTools_ListIteratorOfListOfShape it;
936 TopTools_DataMapIteratorOfDataMapOfShapeListOfShape itt1;
937 TopTools_DataMapIteratorOfDataMapOfShapeInteger itt2;
938 TopTools_DataMapOfShapeListOfShape mapEdgLEdg;
939
940// construction du tableau C=locmapEdgLSh : egde1 - shap1 shap2 shap3
941// construction du tableau locmapShLSh : shap1 - shap1 shap2 shap3
942 for(itt1.Initialize(mymapEdgLEdg); itt1.More(); itt1.Next()) {
943 const TopoDS_Shape& edg1 = itt1.Key();
944 TopTools_ListOfShape LmapEdg;
945 LmapEdg = mymapEdgLEdg.Find(edg1);
946 TopTools_DataMapOfShapeInteger mapVerInt;
947
948 Standard_Integer VertexExtrem;
949 TopoDS_Vertex V1,V2;
950 for(it.Initialize(LmapEdg); it.More(); it.Next()) {
951 const TopoDS_Edge& edg2 = TopoDS::Edge(it.Value());
952
953 TopExp_Explorer expv;
954 for (expv.Init(edg2,TopAbs_VERTEX); expv.More(); expv.Next()) {
955 const TopoDS_Shape& ver = expv.Current();
956
957 VertexExtrem = 1;
958 if (mapVerInt.IsBound(ver)) {
959 VertexExtrem = 0;
960 }
961 mapVerInt.Bind(ver,VertexExtrem);
962
963 }
964 }
965
966 TopTools_ListOfShape myEdgeLV,myEdgeLMV;
967 for(itt2.Initialize(mapVerInt); itt2.More(); itt2.Next()) {
968 const TopoDS_Shape& ver = itt2.Key();
969 VertexExtrem = mapVerInt.Find(ver);
970 if (VertexExtrem == 1) {
971 myEdgeLV.Append(ver);
972 }
973 else {
974// TopoDS_Shape& ver1 = ver.Oriented(TopAbs_INTERNAL);
975 const TopoDS_Shape& ver1 = ver.Oriented(TopAbs_INTERNAL);
976 myEdgeLMV.Append(ver1);
977 }
978 }
979 Standard_Integer number = myEdgeLV.Extent();
980 if (!(number == 2)){
981#ifdef DEB
982 if (trc) cout<<" TopOpeBRepBuild_FuseFace::MakeEdge : Failure in reconstructing new edge"<<endl;
983#endif
984 return;
985 }
986 it.Initialize(myEdgeLV);
987 const TopoDS_Vertex& ver1 = TopoDS::Vertex(it.Value());
988// TopoDS_Shape& verf = ver1.Oriented(TopAbs_FORWARD);
989 const TopoDS_Shape& verf = ver1.Oriented(TopAbs_FORWARD);
990 it.Next();
991 const TopoDS_Vertex& ver2 = TopoDS::Vertex(it.Value());
992// TopoDS_Shape& verl = ver2.Oriented(TopAbs_FORWARD);
993 const TopoDS_Shape& verl = ver2.Oriented(TopAbs_FORWARD);
994
995 Handle(Geom_Curve) curv;
996 const TopoDS_Edge& edg = TopoDS::Edge(edg1);
997 TopLoc_Location loc;
998 Standard_Real first,last;
999 curv = BRep_Tool::Curve(edg,loc,first,last);
1000
1001 BRepLib_MakeEdge ME(curv,TopoDS::Vertex(verf),TopoDS::Vertex(verl));
1002 const TopoDS_Edge& edgnew = ME.Edge();
1003
1004// if (myInternal) {
1005// for (it.Initialize(myEdgeLMV); it.More(); it.Next()) {
1006// const TopoDS_Vertex& ver1 = TopoDS::Vertex(it.Value());
1007// BRep_Builder B;
1008// B.MakeEdge(edgnew);
1009// B.Add(edgnew,ver1);
1010// }
1011// }
1012 mapEdgLEdg.Bind(edgnew,LmapEdg);
1013
1014 }
1015 mymapEdgLEdg = mapEdgLEdg;
1016}
1017
1018//=======================================================================
1019//function : SameSupport
1020//purpose : Edges SameSupport ou pas
1021//=======================================================================
1022
1023Standard_Boolean SameSupport(const TopoDS_Edge& E1,
1024 const TopoDS_Edge& E2)
1025{
1026#ifdef DEB
1027 Standard_Boolean trc = TopOpeBRepBuild_GettraceFUFA();
1028#endif
1029
1030 if (E1.IsNull() || E2.IsNull()) {
1031 return Standard_False;
1032 }
1033
1034
1035 Handle(Geom_Curve) C1,C2;
1036 TopLoc_Location loc;
1037 Standard_Real f1,l1,f2,l2;
1038 Handle(Standard_Type) typC1,typC2;
1039
1040 C1 = BRep_Tool::Curve(E1,loc,f1,l1);
1041 if (!loc.IsIdentity()) {
1042 Handle(Geom_Geometry) GG1 = C1->Transformed(loc.Transformation());
1043 C1 = *((Handle(Geom_Curve)*)&GG1);
1044 }
1045 C2 = BRep_Tool::Curve(E2,loc,f2,l2);
1046 if (!loc.IsIdentity()) {
1047 Handle(Geom_Geometry) GG2 = C2->Transformed(loc.Transformation());
1048 C2 = *((Handle(Geom_Curve)*)&GG2);
1049 }
1050
1051 typC1 = C1->DynamicType();
1052 typC2 = C2->DynamicType();
1053
1054 if (typC1 == STANDARD_TYPE(Geom_TrimmedCurve)) {
1055 C1 = (*((Handle(Geom_TrimmedCurve)*)&C1))->BasisCurve();
1056 typC1 = C1->DynamicType();
1057 }
1058
1059 if (typC2 == STANDARD_TYPE(Geom_TrimmedCurve)) {
1060 C2 = (*((Handle(Geom_TrimmedCurve)*)&C2))->BasisCurve();
1061 typC2 = C2->DynamicType();
1062 }
1063
1064 if (typC1 != typC2) {
1065 return Standard_False;
1066 }
1067
1068 if (typC1 != STANDARD_TYPE(Geom_Line) &&
1069 typC1 != STANDARD_TYPE(Geom_Circle) &&
1070 typC1 != STANDARD_TYPE(Geom_Ellipse) &&
1071 typC1 != STANDARD_TYPE(Geom_BSplineCurve) &&
1072 typC1 != STANDARD_TYPE(Geom_BezierCurve)) {
1073#ifdef DEB
1074 if (trc) cout << " TopOpeBRepBuild_FuseFace : Type de Support non traite" << endl;
1075#endif
1076 return Standard_False;
1077 }
1078
1079 // On a presomption de confusion
1080 const Standard_Real tollin = Precision::Confusion();
1081 const Standard_Real tolang = Precision::Angular();
1082 if (typC1 == STANDARD_TYPE(Geom_Line)) {
1083 gp_Lin li1( (*((Handle(Geom_Line)*)&C1))->Lin());
1084 gp_Lin li2( (*((Handle(Geom_Line)*)&C2))->Lin());
1085
1086 if (Abs(li1.Angle(li2)) <= tolang &&
1087 li1.Location().SquareDistance(li2.Location()) <= tollin*tollin) {
1088 return Standard_True;
1089 }
1090 return Standard_False;
1091 }
1092 else if (typC1 == STANDARD_TYPE(Geom_Circle)) {
1093 gp_Circ ci1 = (*((Handle(Geom_Circle)*)&C1))->Circ();
1094 gp_Circ ci2 = (*((Handle(Geom_Circle)*)&C2))->Circ();
1095 if (Abs(ci1.Radius()-ci2.Radius()) <= tollin &&
1096 ci1.Location().SquareDistance(ci2.Location()) <= tollin*tollin) {
1097 // Point debut, calage dans periode, et detection meme sens
1098 return Standard_True;
1099 }
1100 return Standard_False;
1101 }
1102 else if (typC1 == STANDARD_TYPE(Geom_Ellipse)) {
1103 gp_Elips ci1 = (*((Handle(Geom_Ellipse)*)&C1))->Elips();
1104 gp_Elips ci2 = (*((Handle(Geom_Ellipse)*)&C2))->Elips();
1105
1106 if (Abs(ci1.MajorRadius()-ci2.MajorRadius()) <= tollin &&
1107 Abs(ci1.MinorRadius()-ci2.MinorRadius()) <= tollin &&
1108 ci1.Location().SquareDistance(ci2.Location()) <= tollin*tollin) {
1109 // Point debut, calage dans periode, et detection meme sens
1110 return Standard_True;
1111 }
1112 return Standard_False;
1113 }
1114 else if (typC1 == STANDARD_TYPE(Geom_BSplineCurve)) {
1115 Handle(Geom_BSplineCurve) B1 = *((Handle(Geom_BSplineCurve)*)&C1);
1116 Handle(Geom_BSplineCurve) B2 = *((Handle(Geom_BSplineCurve)*)&C2);
1117
1118 Standard_Integer nbpoles = B1->NbPoles();
1119 if (nbpoles != B2->NbPoles()) {
1120 return Standard_False;
1121 }
1122
1123 Standard_Integer nbknots = B1->NbKnots();
1124 if (nbknots != B2->NbKnots()) {
1125 return Standard_False;
1126 }
1127
1128 TColgp_Array1OfPnt P1(1, nbpoles), P2(1, nbpoles);
1129 B1->Poles(P1);
1130 B2->Poles(P2);
1131
1132 Standard_Real tol3d = BRep_Tool::Tolerance(E1);
1133 for (Standard_Integer p = 1; p <= nbpoles; p++) {
1134 if ( (P1(p)).Distance(P2(p)) > tol3d) {
1135 return Standard_False;
1136 }
1137 }
1138
1139 TColStd_Array1OfReal K1(1, nbknots), K2(1, nbknots);
1140 B1->Knots(K1);
1141 B2->Knots(K2);
1142
1143 TColStd_Array1OfInteger M1(1, nbknots), M2(1, nbknots);
1144 B1->Multiplicities(M1);
1145 B2->Multiplicities(M2);
1146
1147 for (Standard_Integer k = 1; k <= nbknots; k++) {
1148 if ((K1(k)-K2(k)) > tollin) {
1149 return Standard_False;
1150 }
1151 if (Abs(M1(k)-M2(k)) > tollin) {
1152 return Standard_False;
1153 }
1154 }
1155
1156 if (!B1->IsRational()) {
1157 if (B2->IsRational()) {
1158 return Standard_False;
1159 }
1160 }
1161 else {
1162 if (!B2->IsRational()) {
1163 return Standard_False;
1164 }
1165 }
1166
1167 if (B1->IsRational()) {
1168 TColStd_Array1OfReal W1(1, nbpoles), W2(1, nbpoles);
1169 B1->Weights(W1);
1170 B2->Weights(W2);
1171
1172 for (Standard_Integer w = 1; w <= nbpoles; w++) {
1173 if (Abs(W1(w)-W2(w)) > tollin) {
1174 return Standard_False;
1175 }
1176 }
1177 }
1178 return Standard_True;
1179 }
1180 else if (typC1 == STANDARD_TYPE(Geom_BezierCurve)) {
1181 Handle(Geom_BezierCurve) B1 = *((Handle(Geom_BezierCurve)*)&C1);
1182 Handle(Geom_BezierCurve) B2 = *((Handle(Geom_BezierCurve)*)&C2);
1183
1184 Standard_Integer nbpoles = B1->NbPoles();
1185 if (nbpoles != B2->NbPoles()) {
1186 return Standard_False;
1187 }
1188
1189 TColgp_Array1OfPnt P1(1, nbpoles), P2(1, nbpoles);
1190 B1->Poles(P1);
1191 B2->Poles(P2);
1192
1193 for (Standard_Integer p = 1; p <= nbpoles; p++) {
1194 if ( (P1(p)).Distance(P2(p)) > tollin) {
1195 return Standard_False;
1196 }
1197 }
1198
1199 if (!B1->IsRational()) {
1200 if (B2->IsRational()) {
1201 return Standard_False;
1202 }
1203 }
1204 else {
1205 if (!B2->IsRational()) {
1206 return Standard_False;
1207 }
1208 }
1209
1210 if (B1->IsRational()) {
1211 TColStd_Array1OfReal W1(1, nbpoles), W2(1, nbpoles);
1212 B1->Weights(W1);
1213 B2->Weights(W2);
1214
1215 for (Standard_Integer w = 1; w <= nbpoles; w++) {
1216 if (Abs(W1(w)-W2(w)) > tollin) {
1217 return Standard_False;
1218 }
1219 }
1220 }
1221 return Standard_True;
1222 }
1223 return Standard_False;
1224}