projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
0024166: Unable to create file with "Save" menu of voxeldemo Qt sample
[occt.git] / src / BRepFill / BRepFill_TrimShellCorner.cxx
CommitLineData
b311480e 1// Created on: 2003-10-21
2// Created by: Mikhail KLOKOV
3// Copyright (c) 2003-2012 OPEN CASCADE SAS
4//
5// The content of this file is subject to the Open CASCADE Technology Public
6// License Version 6.5 (the "License"). You may not use the content of this file
7// except in compliance with the License. Please obtain a copy of the License
8// at http://www.opencascade.org and read it completely before using this file.
9//
10// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
11// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
12//
13// The Original Code and all software distributed under the License is
14// distributed on an "AS IS" basis, without warranty of any kind, and the
15// Initial Developer hereby disclaims all such warranties, including without
16// limitation, any warranties of merchantability, fitness for a particular
17// purpose or non-infringement. Please see the License for the specific terms
18// and conditions governing the rights and limitations under the License.
19
7fd59977 20
21#include <BRepFill_TrimShellCorner.ixx>
22
23#include <BRepAlgoAPI_Section.hxx>
24#include <BRep_Builder.hxx>
25#include <BRep_Tool.hxx>
26#include <BRepLib_MakeEdge.hxx>
27#include <BRepTools_ReShape.hxx>
28#include <TopoDS.hxx>
29#include <TopoDS_Shell.hxx>
30#include <TopoDS_Compound.hxx>
31
32#include <IntTools_BeanFaceIntersector.hxx>
4e57c75e 33#include <BOPInt_Context.hxx>
7fd59977 34#include <IntTools_Range.hxx>
35
7fd59977 36#include <Geom_Curve.hxx>
37#include <Geom2d_Curve.hxx>
38#include <gp_Pnt2d.hxx>
39
40#include <TopLoc_Location.hxx>
41#include <TopExp.hxx>
42#include <TopExp_Explorer.hxx>
43#include <TopTools_MapOfShape.hxx>
44#include <TopTools_ListOfShape.hxx>
45#include <TopTools_Array1OfListOfShape.hxx>
46#include <TopTools_ListIteratorOfListOfShape.hxx>
47#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
4e57c75e 48#include <TopTools_DataMapOfShapeListOfShape.hxx>
49#include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
7fd59977 50
51#include <gp_Pln.hxx>
52#include <TopoDS_Iterator.hxx>
53#include <TColgp_Array1OfPnt.hxx>
54#include <TColgp_Array2OfPnt.hxx>
55#include <TColgp_Array1OfDir.hxx>
56#include <TColStd_ListOfInteger.hxx>
57#include <TColStd_ListIteratorOfListOfInteger.hxx>
58#include <GCPnts_UniformAbscissa.hxx>
59#include <GeomLib.hxx>
60#include <BRepLib_MakeWire.hxx>
61#include <TopTools_SequenceOfShape.hxx>
62#include <TColStd_Array1OfBoolean.hxx>
63#include <TColgp_SequenceOfPnt.hxx>
64#include <gce_MakeLin.hxx>
65
4e57c75e 66#include <BOPInt_Tools.hxx>
67#include <BOPAlgo_PaveFiller.hxx>
68#include <BOPDS_DS.hxx>
69#include <BOPAlgo_BOP.hxx>
70
71#include <BOPCol_DataMapOfShapeListOfShape.hxx>
72#include <BOPCol_ListOfShape.hxx>
73
4e57c75e 74static Standard_Boolean FindCommonVertex(const BOPDS_PDS& theDS,
75 const Standard_Integer theEIndex1,
76 const Standard_Integer theEIndex2,
77 TopoDS_Vertex& theCommonVertex,
78 Standard_Real& theParamOnE1,
79 Standard_Real& theParamOnE2);
7fd59977 80
81static Standard_Boolean MakeFacesNonSec(const Standard_Integer theIndex,
4e57c75e 82 const Handle(TopTools_HArray2OfShape)& theUEdges,
83 const Handle(TopTools_HArray2OfShape)& theBounds,
84 const BOPDS_PDS& theDS,
85 const Standard_Integer theFaceIndex1,
86 const Standard_Integer theFaceIndex2,
87 TopTools_DataMapOfShapeListOfShape& theHistMap);
7fd59977 88
89static Standard_Boolean MakeFacesSec(const Standard_Integer theIndex,
4e57c75e 90 const Handle(TopTools_HArray2OfShape)& theUEdges,
91 const Handle(TopTools_HArray2OfShape)& theBounds,
92 const BOPDS_PDS& theDS,
93 const Standard_Integer theFaceIndex1,
94 const Standard_Integer theFaceIndex2,
95 const Standard_Integer theSSInterfIndex,
96 const gp_Ax2& AxeOfBisPlane,
97 TopTools_DataMapOfShapeListOfShape& theHistMap);
7fd59977 98
99static Standard_Boolean SplitUEdges(const Handle(TopTools_HArray2OfShape)& theUEdges,
4e57c75e 100 const BOPDS_PDS& theDS,
101 TopTools_DataMapOfShapeListOfShape& theHistMap);
7fd59977 102
103static void FindFreeVertices(const TopoDS_Shape& theShape,
4e57c75e 104 const TopTools_MapOfShape& theVerticesToAvoid,
105 TopTools_ListOfShape& theListOfVertex);
7fd59977 106
107static Standard_Boolean CheckAndOrientEdges(const TopTools_ListOfShape& theOrderedList,
4e57c75e 108 const gp_Pnt2d& theFirstPoint,
109 const gp_Pnt2d& theLastPoint,
110 const TopoDS_Face& theFace,
111 TopTools_ListOfShape& theOrientedList);
7fd59977 112
113static Standard_Boolean FillGap(const TopoDS_Vertex& theFirstVertex,
4e57c75e 114 const TopoDS_Vertex& theLastVertex,
115 const gp_Pnt2d& theFirstPoint,
116 const gp_Pnt2d& theLastPoint,
117 const TopoDS_Face& theFace,
118 const TopoDS_Compound& theSectionEdges,
119 TopTools_ListOfShape& theOrderedList);
7fd59977 120
121static Standard_Boolean FindNextEdge(const TopoDS_Vertex& theFirstVertex,
4e57c75e 122 const TopoDS_Vertex& theLastVertex,
123 const TopTools_IndexedDataMapOfShapeListOfShape& theMapVE,
124 const TopTools_MapOfShape& theMapToAvoid,
125 TopTools_ListOfShape& theOrderedList);
7fd59977 126
127static Standard_Boolean FindVertex(const TopoDS_Edge& theEdge,
4e57c75e 128 const Standard_Integer theRank,
129 const BOPDS_PDS& theDS,
130 const TopTools_DataMapOfShapeListOfShape& theHistMap,
131 TopoDS_Vertex& theVertex,
132 BOPDS_Pave& thePave);
7fd59977 133
134static Standard_Boolean FindNextVertex(const Standard_Integer theEdgeIndex,
4e57c75e 135 const BOPDS_Pave& thePrevPave,
136 const BOPDS_PDS& theDS,
137 TopoDS_Vertex& theNextVertex,
138 BOPDS_Pave& thePave);
7fd59977 139
4e57c75e 140static Standard_Boolean GetPave(const Standard_Integer theEdgeIndex,
141 const Standard_Boolean isFirst,
142 const BOPDS_PDS& theDS,
143 BOPDS_Pave& thePave);
7fd59977 144
145static Standard_Boolean FindFromUEdge(const TopoDS_Edge& theUE1Old,
4e57c75e 146 const TopoDS_Edge& theUE2Old,
147 const TopoDS_Edge& theUE1New,
148 const TopoDS_Edge& theUE2New,
149 const TopoDS_Face& theFace,
150 const TopoDS_Compound& theSecEdges,
151 const Standard_Integer theRank,
152 const TopoDS_Edge& theBoundEdge,
153 const Standard_Integer theBoundEdgeIndex,
154 const BOPDS_PDS& theDS,
155 const TopTools_DataMapOfShapeListOfShape& theHistMap,
156 TopoDS_Compound& theSecEdgesNew,
157 TopTools_ListOfShape& theListOfWireEdges,
158 BOPDS_Pave& theFoundPave,
159 Standard_Boolean& isOnUEdge);
160
161static Standard_Boolean FindFromVEdge(const BOPDS_Pave& thePrevPave,
162 const Standard_Boolean& isOnUEdge,
163 const TopoDS_Edge& theUE1Old,
164 const TopoDS_Edge& theUE2Old,
165 const TopoDS_Face& theFace,
166 const TopoDS_Compound& theSecEdges,
167 const Standard_Integer theRank,
168 const TopoDS_Edge& theBoundEdge,
169 const Standard_Integer theBoundEdgeIndex,
170 const BOPDS_PDS& theDS,
171 const TopTools_DataMapOfShapeListOfShape& theHistMap,
172 TopTools_ListOfShape& theListOfWireEdges,
173 Standard_Boolean& isSectionFound);
7fd59977 174
175static void RemoveEdges(const TopoDS_Compound& theSourceComp,
4e57c75e 176 const TopTools_ListOfShape& theListToRemove,
177 TopoDS_Compound& theResultComp);
7fd59977 178
4e57c75e 179static Standard_Boolean FilterSectionEdges(const BOPDS_VectorOfCurve& theBCurves,
180 const TopoDS_Face& theSecPlane,
181 const BOPDS_PDS& theDS,
182 TopoDS_Compound& theResult);
7fd59977 183
184static Standard_Boolean GetUEdges(const Standard_Integer theIndex,
4e57c75e 185 const Standard_Integer theRank,
186 const Handle(TopTools_HArray2OfShape)& theUEdges,
187 const TopoDS_Edge& theBoundEdge,
188 const TopoDS_Face& theFace,
189 TopoDS_Edge& theFirstUEdge,
190 TopoDS_Edge& theSecondUEdge);
7fd59977 191
192static Standard_Real ComputeAveragePlaneAndMaxDeviation(const TopoDS_Shape& aWire,
4e57c75e 193 gp_Pln& thePlane,
194 Standard_Boolean& IsSingular);
7fd59977 195
196static Standard_Boolean ChooseSection(const TopoDS_Shape& Comp,
4e57c75e 197 const gp_Ax2& bis,
198 TopoDS_Shape& resWire,
199 gp_Pln& resPlane,
200 Standard_Boolean& IsSingular);
7fd59977 201
7fd59977 202// ===========================================================================================
203// function: Constructor
204// purpose:
205// ===========================================================================================
206BRepFill_TrimShellCorner::BRepFill_TrimShellCorner(const Handle(TopTools_HArray2OfShape)& theFaces,
4e57c75e 207 const gp_Ax2& theAxeOfBisPlane,
208 const TopoDS_Face& theSecPlane) :
7fd59977 209myAxeOfBisPlane(theAxeOfBisPlane),
210myDone(Standard_False),
211myHasSection(Standard_False)
212{
213 myFaces = new TopTools_HArray2OfShape(theFaces->LowerRow(), theFaces->UpperRow(),
4e57c75e 214 theFaces->LowerCol(), theFaces->UpperCol());
7fd59977 215 myFaces->ChangeArray2() = theFaces->Array2();
216 mySecPln = theSecPlane;
217}
218
219// ===========================================================================================
220// function: Constructor
221// purpose:
222// ===========================================================================================
223BRepFill_TrimShellCorner::BRepFill_TrimShellCorner(const Handle(TopTools_HArray2OfShape)& theFaces,
4e57c75e 224 const gp_Ax2& theAxeOfBisPlane,
225 const TopoDS_Wire& theSpine,
226 const TopoDS_Face& theSecPlane):
7fd59977 227myAxeOfBisPlane(theAxeOfBisPlane),
228myDone(Standard_False),
229myHasSection(Standard_False)
230{
231 myFaces = new TopTools_HArray2OfShape(theFaces->LowerRow(), theFaces->UpperRow(),
4e57c75e 232 theFaces->LowerCol(), theFaces->UpperCol());
7fd59977 233 myFaces->ChangeArray2() = theFaces->Array2();
234 mySpine = theSpine;
235 mySecPln = theSecPlane;
236}
237
238// ===========================================================================================
239// function: SetSpine
240// purpose:
241// ===========================================================================================
242void BRepFill_TrimShellCorner::SetSpine(const TopoDS_Wire& theSpine)
243{
244 mySpine = theSpine;
245}
246
247// ===========================================================================================
248// function: AddBounds
249// purpose:
250// ===========================================================================================
251void BRepFill_TrimShellCorner::AddBounds(const Handle(TopTools_HArray2OfShape)& theBounds)
252{
253 myBounds = new TopTools_HArray2OfShape(theBounds->LowerRow(), theBounds->UpperRow(),
4e57c75e 254 theBounds->LowerCol(), theBounds->UpperCol());
7fd59977 255 myBounds->ChangeArray2() = theBounds->Array2();
256}
257
258// ===========================================================================================
259// function: AddUEdges
260// purpose:
261// ===========================================================================================
262void BRepFill_TrimShellCorner::AddUEdges(const Handle(TopTools_HArray2OfShape)& theUEdges)
263{
264 myUEdges = new TopTools_HArray2OfShape(theUEdges->LowerRow(), theUEdges->UpperRow(),
4e57c75e 265 theUEdges->LowerCol(), theUEdges->UpperCol());
7fd59977 266 myUEdges->ChangeArray2() = theUEdges->Array2();
267}
268
269// ===========================================================================================
270// function: Perform
271// purpose:
272// ===========================================================================================
273void BRepFill_TrimShellCorner::Perform()
274{
4e57c75e 275 Standard_Integer anIndex1, anIndex2, nF1, nF2, i, j, aNbP, aNbC;
276 Standard_Boolean bhassec;
277
7fd59977 278 myDone = Standard_False;
279 myHistMap.Clear();
280
281 if(myFaces->RowLength() != 2)
282 return;
283 Standard_Integer ii = 0, jj = 0;
284 BRep_Builder aBB;
285
286 for(jj = myFaces->LowerCol(); jj <= myFaces->UpperCol(); jj++) {
287 TopoDS_Shell aShell;
288 aBB.MakeShell(aShell);
289
290 for(ii = myFaces->LowerRow(); ii <= myFaces->UpperRow(); ii++) {
291 aBB.Add(aShell, myFaces->Value(ii, jj));
292 }
293
294 if(jj == myFaces->LowerCol()) {
295 myShape1 = aShell;
296 }
297 else {
298 myShape2 = aShell;
299 }
300 }
4e57c75e 301
302 BOPAlgo_PaveFiller aPF;
303 BOPCol_ListOfShape aLS;
304 aLS.Append(myShape1);
305 aLS.Append(myShape2);
306 aPF.SetArguments(aLS);
307 //
308 aPF.Perform();
309 if (aPF.ErrorStatus()) {
7fd59977 310 return;
311 }
4e57c75e 312 //
313 const BOPDS_PDS& theDS = aPF.PDS();
314 //
315 BOPDS_VectorOfInterfFF& aFFs = theDS->InterfFF();
7fd59977 316 Standard_Integer aNbFFs = aFFs.Extent();
317
4e57c75e 318 if(!SplitUEdges(myUEdges, theDS, myHistMap)) {
7fd59977 319 return;
320 }
321
322 for(ii = myFaces->LowerRow(); ii <= myFaces->UpperRow(); ii++) {
323 TopoDS_Shape aF1 = myFaces->Value(ii, myFaces->LowerCol());
324 TopoDS_Shape aF2 = myFaces->Value(ii, myFaces->UpperCol());
4e57c75e 325 //
326 anIndex1 = theDS->Index(aF1);
327 anIndex2 = theDS->Index(aF2);
328
329 if((anIndex1 == -1) || (anIndex2 == -1))
7fd59977 330 continue;
4e57c75e 331
332 for (i=0; i < aNbFFs; ++i) {
333 BOPDS_InterfFF& aFFi = aFFs(i);
334 aFFi.Indices(nF1, nF2);
335 //
336 BOPDS_VectorOfPoint& aVP=aFFi.ChangePoints();
337 aNbP=aVP.Extent();
338 BOPDS_VectorOfCurve& aVC=aFFi.ChangeCurves();
339 aNbC=aVC.Extent();
340 if (!aNbP && !aNbC) {
341 if (!theDS->HasInterfSubShapes(nF1, nF2)) {
342 continue;
343 }
344 }
7fd59977 345 //
7fd59977 346 if((nF1 == anIndex1) && (nF2 == anIndex2)) {
4e57c75e 347 const BOPDS_VectorOfCurve& aVC = aFFi.Curves();
348 bhassec = Standard_False;
349 //
350 for (j = 0; j < aNbC; ++j) {
351 const BOPDS_Curve& aBCurve = aVC(j);
352 const BOPDS_ListOfPaveBlock& aSectEdges = aBCurve.PaveBlocks();
353 //
354 if (aSectEdges.Extent()) {
355 bhassec = Standard_True;
356 break;
357 }
358 }
359
360 if(!bhassec) {
361 if(!MakeFacesNonSec(ii, myUEdges, myBounds, theDS, anIndex1, anIndex2, myHistMap)) {
362 myHistMap.Clear();
363 return;
364 }
365 }
366 else {
367 if(!MakeFacesSec(ii, myUEdges, myBounds, theDS, anIndex1, anIndex2,
368 i, myAxeOfBisPlane, myHistMap)) {
369 myHistMap.Clear();
370 return;
371 }
372 }
373 break;
7fd59977 374 }
375 }
376 }
377 myDone = Standard_True;
378}
379
380// ===========================================================================================
381// function: IsDone
382// purpose:
383// ===========================================================================================
384Standard_Boolean BRepFill_TrimShellCorner::IsDone() const
385{
386 return myDone;
387}
388
389// ===========================================================================================
390// function: HasSection
391// purpose:
392// ===========================================================================================
393Standard_Boolean BRepFill_TrimShellCorner::HasSection() const
394{
395 return myHasSection;
396}
397
398// ===========================================================================================
399// function: Modified
400// purpose:
401// ===========================================================================================
402void BRepFill_TrimShellCorner::Modified(const TopoDS_Shape& theShape,
4e57c75e 403 TopTools_ListOfShape& theModified)
7fd59977 404{
405 theModified.Clear();
406
407 if(myHistMap.IsBound(theShape)) {
408 theModified = myHistMap.Find(theShape);
409 }
410}
411
412// ----------------------------------------------------------------------------------------------------
413// static function: MakeFacesNonSec
414// purpose:
415// ----------------------------------------------------------------------------------------------------
416Standard_Boolean MakeFacesNonSec(const Standard_Integer theIndex,
4e57c75e 417 const Handle(TopTools_HArray2OfShape)& theUEdges,
418 const Handle(TopTools_HArray2OfShape)& theBounds,
419 const BOPDS_PDS& theDS,
420 const Standard_Integer theFaceIndex1,
421 const Standard_Integer theFaceIndex2,
422 TopTools_DataMapOfShapeListOfShape& theHistMap)
7fd59977 423{
7fd59977 424 Standard_Boolean bHasNewEdge = Standard_False;
425 TopoDS_Edge aNewEdge;
7fd59977 426
427 BRep_Builder aBB;
428 const TopoDS_Shape& aE1 = theBounds->Value(theIndex, 1);
429 const TopoDS_Shape& aE2 = theBounds->Value(theIndex, 2);
430
431 // search common vertex between bounds. begin
432 TopoDS_Vertex aCommonVertex;
4e57c75e 433 Standard_Integer anIndex1 = theDS->Index(aE1);
434 Standard_Integer anIndex2 = theDS->Index(aE2);
7fd59977 435 Standard_Real apar1 = 0., apar2 = 0.;
436
437 Standard_Boolean bvertexfound =
4e57c75e 438 FindCommonVertex(theDS, anIndex1, anIndex2, aCommonVertex, apar1, apar2);
7fd59977 439 // search common vertex between bounds. end
440
441 Handle(BRepTools_ReShape) aSubstitutor = new BRepTools_ReShape();
442
443 // search common vertices between uedges. begin
444 TopTools_ListOfShape aCommonVertices;
445 Standard_Boolean acommonflag = 0; // 0 - no, 1 - first pair, 2 - second pair, 3 - both
446 Standard_Integer ueit = 0, eindex = 0;
447
448 for(ueit = 1, eindex = theIndex; ueit <= 2; ueit++, eindex++) {
449 const TopoDS_Shape& aShape1 = theUEdges->Value(eindex, theUEdges->LowerCol());
450 const TopoDS_Shape& aShape2 = theUEdges->Value(eindex, theUEdges->UpperCol());
451 TopoDS_Edge aUE1 = TopoDS::Edge(aShape1);
452 TopoDS_Edge aUE2 = TopoDS::Edge(aShape2);
453
454 if(theHistMap.IsBound(aShape1)) {
455 const TopTools_ListOfShape& lst = theHistMap.Find(aShape1);
456
457 if(!lst.IsEmpty())
4e57c75e 458 aUE1 = TopoDS::Edge(lst.First());
7fd59977 459 }
460
461 if(theHistMap.IsBound(aShape2)) {
462 const TopTools_ListOfShape& lst = theHistMap.Find(aShape2);
463
464 if(!lst.IsEmpty())
4e57c75e 465 aUE2 = TopoDS::Edge(lst.First());
7fd59977 466 }
467
468 if(!aShape1.IsSame(aUE1))
469 aSubstitutor->Replace(aShape1.Oriented(TopAbs_FORWARD), aUE1.Oriented(TopAbs_FORWARD));
470
471 if(!aShape2.IsSame(aUE2))
472 aSubstitutor->Replace(aShape2.Oriented(TopAbs_FORWARD), aUE2.Oriented(TopAbs_FORWARD));
473
474 TopoDS_Vertex V1 = TopExp::LastVertex(aUE1);
475 TopoDS_Vertex V2 = TopExp::FirstVertex(aUE2);
476
477 if(V1.IsSame(V2)) {
478 acommonflag = (acommonflag == 0) ? ueit : 3;
479 aCommonVertices.Append(V1);
480 }
481 }
482 // search common vertices between uedges. end
483
484 if(bvertexfound) {
485 if(aCommonVertices.Extent() != 1)
486 return Standard_False;
487
488 if(acommonflag == 1)
489 aNewEdge = BRepLib_MakeEdge(TopoDS::Vertex(aCommonVertices.First()), aCommonVertex);
490 else
491 aNewEdge = BRepLib_MakeEdge(aCommonVertex, TopoDS::Vertex(aCommonVertices.First()));
492
493 bHasNewEdge = Standard_True;
494 }
495
496 if(aCommonVertices.Extent() == 2) {
497 aNewEdge = BRepLib_MakeEdge(TopoDS::Vertex(aCommonVertices.First()),
4e57c75e 498 TopoDS::Vertex(aCommonVertices.Last()));
7fd59977 499 bHasNewEdge = Standard_True;
500 }
501 Standard_Integer fit = 0;
502
503 for(fit = 1; fit <= 2; fit++) {
504 TopoDS_Compound aComp;
505 TopTools_MapOfShape aMapV;
506 aBB.MakeCompound(aComp);
507
508 for(ueit = 1, eindex = theIndex; ueit <= 2; ueit++, eindex++) {
509 const TopoDS_Shape& aShape = theUEdges->Value(eindex, theUEdges->LowerCol() + fit - 1);
510 TopoDS_Shape aUE = aShape;
511
512 if(theHistMap.IsBound(aShape)) {
4e57c75e 513 const TopTools_ListOfShape& lst = theHistMap.Find(aShape);
7fd59977 514
4e57c75e 515 if(!lst.IsEmpty())
516 aUE = TopoDS::Edge(lst.First());
7fd59977 517 }
518 const TopoDS_Shape& aV = (fit == 1) ? TopExp::FirstVertex(TopoDS::Edge(aUE)) : TopExp::LastVertex(TopoDS::Edge(aUE));
519 aMapV.Add(aV);
520 aBB.Add(aComp, aUE);
521 }
522 if(bHasNewEdge) {
523 aBB.Add(aComp, aNewEdge);
524 }
525 TopTools_ListOfShape alonevertices;
526 FindFreeVertices(aComp, aMapV, alonevertices);
527
528 if(!alonevertices.IsEmpty() && (alonevertices.Extent() != 2))
529 return Standard_False;
530
531 Standard_Integer aFaceIndex = (fit == 1) ? theFaceIndex1 : theFaceIndex2;
4e57c75e 532 TopoDS_Shape aFace = theDS->Shape(aFaceIndex);
7fd59977 533 TopAbs_Orientation aFaceOri = aFace.Orientation();
534 TopAbs_Orientation anEdgeOri = TopAbs_FORWARD;
535 aFace.Orientation(TopAbs_FORWARD);
536
537 TopExp_Explorer anExpE(aFace, TopAbs_EDGE);
538 const TopoDS_Shape& aCheckEdge = (fit == 1) ? aE1 : aE2;
539
540 for(; anExpE.More(); anExpE.Next()) {
541 if(aCheckEdge.IsSame(anExpE.Current()))
4e57c75e 542 anEdgeOri = anExpE.Current().Orientation();
7fd59977 543 }
544
545 if(bHasNewEdge) {
546 aNewEdge.Orientation(TopAbs_FORWARD);
547 }
548
549 TopTools_ListOfShape aOrderedList;
550
551 if(!alonevertices.IsEmpty()) {
552 Standard_Integer anEIndex = (fit == 1) ? anIndex1 : anIndex2;
7fd59977 553 Standard_Boolean bfound1 = Standard_False;
554 Standard_Boolean bfound2 = Standard_False;
555 Standard_Real aparam1 = 0., aparam2 = 0.;
556
4e57c75e 557 BOPDS_ListOfPave aLP;
558 theDS->Paves(anEIndex, aLP);
559 BOPDS_ListIteratorOfListOfPave aIt;
560 aIt.Initialize(aLP);
561 for ( ; aIt.More(); aIt.Next()) {
562 const BOPDS_Pave& aPave = aIt.Value();
563 TopoDS_Shape aV = theDS->Shape(aPave.Index());
564
565 if(aV.IsSame(alonevertices.First())) {
566 if(!bfound1) {
567 aparam1 = aPave.Parameter();
568 bfound1 = Standard_True;
569 }
570 }
571
572 if(aV.IsSame(alonevertices.Last())) {
573 if(!bfound2) {
574 aparam2 = aPave.Parameter();
575 bfound2 = Standard_True;
576 }
577 }
7fd59977 578 }
579
580 if(bfound1 && bfound2) {
4e57c75e 581 TopoDS_Edge aNewBoundE;
582
583 if(fit == 1) {
584 aNewBoundE = TopoDS::Edge(aE1.EmptyCopied());
585 }
586 else {
587 aNewBoundE = TopoDS::Edge(aE2.EmptyCopied());
588 }
589 TopoDS_Vertex aV1, aV2;
590
591 if(aparam1 < aparam2) {
592 aV1 = TopoDS::Vertex(alonevertices.First());
593 aV2 = TopoDS::Vertex(alonevertices.Last());
594 }
595 else {
596 aV1 = TopoDS::Vertex(alonevertices.Last());
597 aV2 = TopoDS::Vertex(alonevertices.First());
598 Standard_Real tmp = aparam1;
599 aparam1 = aparam2;
600 aparam2 = tmp;
601 }
602 aV1.Orientation(TopAbs_FORWARD);
603 aV2.Orientation(TopAbs_REVERSED);
604 aBB.Add(aNewBoundE, aV1);
605 aBB.Add(aNewBoundE, aV2);
606 aBB.Range(aNewBoundE, aparam1, aparam2);
607 aNewBoundE.Orientation(TopAbs_FORWARD);
608
609 aOrderedList.Append(aNewBoundE);
610
611 if(bHasNewEdge) {
612 TopExp_Explorer anExpV(aNewEdge, TopAbs_VERTEX);
613 Standard_Boolean bfoundv = Standard_False;
614
615 for(; !bfoundv && anExpV.More(); anExpV.Next()) {
616 if(aV2.IsSame(anExpV.Current()))
617 bfoundv = Standard_True;
618 }
619
620 if(bfoundv)
621 aOrderedList.Append(aNewEdge);
622 else
623 aOrderedList.Prepend(aNewEdge);
624 }
7fd59977 625 }
626 else {
4e57c75e 627 return Standard_False;
7fd59977 628 }
629 }
630 else {
631 if(bHasNewEdge) {
4e57c75e 632 aOrderedList.Append(aNewEdge);
7fd59977 633 }
634 }
635
636 if(!aOrderedList.IsEmpty()) {
637 TopoDS_Wire aW;
638 aBB.MakeWire(aW);
639 TopTools_ListIteratorOfListOfShape anItE(aOrderedList);
640
641 for(; anItE.More(); anItE.Next()) {
4e57c75e 642 aBB.Add(aW, anItE.Value());
7fd59977 643 }
644 if(fit == 1)
4e57c75e 645 aSubstitutor->Replace(aE1.Oriented(TopAbs_FORWARD), aW);
7fd59977 646 else
4e57c75e 647 aSubstitutor->Replace(aE2.Oriented(TopAbs_FORWARD), aW);
7fd59977 648 }
649
650 aSubstitutor->Apply(aFace);
651 TopoDS_Shape aNewFace = aSubstitutor->Value(aFace);
652 aNewFace.Orientation(aFaceOri);
653 TopTools_ListOfShape atmpList;
654 atmpList.Append(aNewFace);
655 theHistMap.Bind(aFace, atmpList);
656
657 anExpE.Init(aFace, TopAbs_EDGE);
658
659 for(; anExpE.More(); anExpE.Next()) {
660 TopoDS_Shape aNewValue = aSubstitutor->Value(anExpE.Current());
661
662 if(aNewValue.IsNull() || aNewValue.IsSame(anExpE.Current()))
4e57c75e 663 continue;
7fd59977 664
665 if(theHistMap.IsBound(anExpE.Current()))
4e57c75e 666 continue;
7fd59977 667 TopTools_ListOfShape aListOfNewEdge;
668 TopExp_Explorer anExpE2(aNewValue, TopAbs_EDGE);
669
670 for(; anExpE2.More(); anExpE2.Next()) {
4e57c75e 671 aListOfNewEdge.Append(anExpE2.Current());
7fd59977 672 }
673 theHistMap.Bind(anExpE.Current(), aListOfNewEdge);
674 }
675 }
676
677 return Standard_True;
678}
679
680// ----------------------------------------------------------------------------------------------------
681// static function: MakeFacesSec
682// purpose:
683// ----------------------------------------------------------------------------------------------------
684Standard_Boolean MakeFacesSec(const Standard_Integer theIndex,
4e57c75e 685 const Handle(TopTools_HArray2OfShape)& theUEdges,
686 const Handle(TopTools_HArray2OfShape)& theBounds,
687 const BOPDS_PDS& theDS,
688 const Standard_Integer theFaceIndex1,
689 const Standard_Integer theFaceIndex2,
690 const Standard_Integer theSSInterfIndex,
691 const gp_Ax2& AxeOfBisPlane,
692 TopTools_DataMapOfShapeListOfShape& theHistMap)
7fd59977 693{
4e57c75e 694 const BOPDS_VectorOfInterfFF& aFFs = theDS->InterfFF();
695 const BOPDS_InterfFF& aFFi = aFFs(theSSInterfIndex);
696 const BOPDS_VectorOfCurve& aBCurves = aFFi.Curves();
697
7fd59977 698 TopoDS_Compound aSecEdges;
7fd59977 699 TopoDS_Face aSecPlane;
700
4e57c75e 701 if(!FilterSectionEdges(aBCurves, aSecPlane, theDS, aSecEdges))
7fd59977 702 return Standard_False;
703
704 TopoDS_Shape SecWire;
705 gp_Pln SecPlane;
706 Standard_Boolean IsSingular;
707 Standard_Boolean WireFound = ChooseSection( aSecEdges, AxeOfBisPlane, SecWire, SecPlane, IsSingular );
708
709 if(WireFound) {
710 //aSecEdges = SecWire;
711 TopoDS_Compound aComp;
712 BRep_Builder BB;
713 BB.MakeCompound(aComp);
714 TopExp_Explorer explo( SecWire, TopAbs_EDGE );
715
716 for (; explo.More(); explo.Next())
717 BB.Add( aComp, explo.Current() );
718 aSecEdges = aComp;
719 }
720
721 TopTools_ListOfShape aCommonVertices;
722// Standard_Boolean acommonflag = 0; // 0 - no, 1 - first pair, 2 - second pair, 3 - both
723 Standard_Integer fit = 0; //, ueit = 0, eindex = 0, i = 0;
724 Handle(BRepTools_ReShape) aSubstitutor = new BRepTools_ReShape();
725
4e57c75e 726 for(fit = 0; fit < 2; fit++) {
727 Standard_Integer aFaceIndex = (fit == 0) ? theFaceIndex1 : theFaceIndex2;
728 TopoDS_Face aFace = TopoDS::Face(theDS->Shape(aFaceIndex));
7fd59977 729 TopAbs_Orientation aFaceOri = aFace.Orientation();
730 TopoDS_Face aFaceF = aFace;
731 aFaceF.Orientation(TopAbs_FORWARD);
4e57c75e 732 TopoDS_Edge aBoundEdge = TopoDS::Edge(theBounds->Value(theIndex, theBounds->LowerCol() +fit));
733 Standard_Integer aBoundEdgeIndex = theDS->Index(aBoundEdge);
7fd59977 734 TopoDS_Edge aUE1;
735 TopoDS_Edge aUE2;
736
737 if(!GetUEdges(theIndex, fit, theUEdges, aBoundEdge, aFaceF, aUE1, aUE2))
738 return Standard_False;
739
740 TopoDS_Edge aUE1old = aUE1;
741 TopoDS_Edge aUE2old = aUE2;
742
743 if(theHistMap.IsBound(aUE1)) {
744 const TopTools_ListOfShape& lst = theHistMap.Find(aUE1);
745
746 if(!lst.IsEmpty()) {
4e57c75e 747 const TopoDS_Shape& anEdge = lst.First().Oriented(aUE1.Orientation());
7fd59977 748
4e57c75e 749 if(!aUE1.IsSame(anEdge))
750 aSubstitutor->Replace(aUE1.Oriented(TopAbs_FORWARD), anEdge.Oriented(TopAbs_FORWARD));
751 aUE1 = TopoDS::Edge(anEdge);
7fd59977 752 }
753 }
754
755 if(theHistMap.IsBound(aUE2)) {
756 const TopTools_ListOfShape& lst = theHistMap.Find(aUE2);
757
758 if(!lst.IsEmpty()) {
4e57c75e 759 const TopoDS_Shape& anEdge = lst.First().Oriented(aUE2.Orientation());
7fd59977 760
4e57c75e 761 if(!aUE2.IsSame(anEdge))
762 aSubstitutor->Replace(aUE2.Oriented(TopAbs_FORWARD), anEdge.Oriented(TopAbs_FORWARD));
763 aUE2 = TopoDS::Edge(anEdge);
7fd59977 764 }
765 }
766 TopoDS_Vertex aPrevVertex, aNextVertex;
767 TopoDS_Compound aCompOfSecEdges = aSecEdges;
768 TopTools_ListOfShape aListOfWireEdges;
769 BRep_Builder aBB;
4e57c75e 770 BOPDS_Pave aPave1;
7fd59977 771 Standard_Boolean isPave1OnUEdge = Standard_True;
772
773 if(FindFromUEdge(aUE1old, aUE2old, aUE1, aUE2, aFace, aSecEdges, fit, aBoundEdge, aBoundEdgeIndex,
4e57c75e 774 theDS, theHistMap, aCompOfSecEdges, aListOfWireEdges, aPave1, isPave1OnUEdge)) {
7fd59977 775 TopTools_ListOfShape aSecondListOfEdges;
776 Standard_Boolean bisSectionFound = Standard_False;
777
778 if(!FindFromVEdge(aPave1, isPave1OnUEdge, aUE1old, aUE2old, aFace, aCompOfSecEdges, fit, aBoundEdge,
4e57c75e 779 aBoundEdgeIndex, theDS, theHistMap, aSecondListOfEdges, bisSectionFound)) {
780 return Standard_False;
7fd59977 781 }
782
783 if(!bisSectionFound && aListOfWireEdges.IsEmpty()) {
4e57c75e 784 return Standard_False;
7fd59977 785 }
786 aListOfWireEdges.Append(aSecondListOfEdges);
787 }
788 else {
789 return Standard_False;
790 }
791
792 if(!aListOfWireEdges.IsEmpty()) {
793 TopoDS_Wire aW;
794 aBB.MakeWire(aW);
795 TopTools_ListIteratorOfListOfShape aEIt(aListOfWireEdges);
796
797 for(; aEIt.More(); aEIt.Next()) {
4e57c75e 798 if(!aBoundEdge.IsSame(aEIt.Value()))
799 aBB.Add(aW, aEIt.Value());
7fd59977 800 }
801 aSubstitutor->Replace(aBoundEdge.Oriented(TopAbs_FORWARD), aW);
802 }
803
804 aSubstitutor->Apply(aFace);
805 TopoDS_Shape aNewFace = aSubstitutor->Value(aFace);
806 aNewFace.Orientation(aFaceOri);
807 TopTools_ListOfShape atmpList;
808 atmpList.Append(aNewFace);
809 theHistMap.Bind(aFace, atmpList);
810
811 TopExp_Explorer anExpE(aFace, TopAbs_EDGE);
812
813 for(; anExpE.More(); anExpE.Next()) {
814 TopoDS_Shape aNewValue = aSubstitutor->Value(anExpE.Current());
815
816 if(aNewValue.IsNull() || aNewValue.IsSame(anExpE.Current()))
4e57c75e 817 continue;
7fd59977 818
819 if(theHistMap.IsBound(anExpE.Current()))
4e57c75e 820 continue;
7fd59977 821 TopTools_ListOfShape aListOfNewEdge;
822 TopExp_Explorer anExpE2(aNewValue, TopAbs_EDGE);
823
824 for(; anExpE2.More(); anExpE2.Next()) {
4e57c75e 825 aListOfNewEdge.Append(anExpE2.Current());
7fd59977 826 }
827 theHistMap.Bind(anExpE.Current(), aListOfNewEdge);
828 }
829 }
830 return Standard_True;
831}
832
833
834// ------------------------------------------------------------------------------------------
835// static function: SplitUEdges
836// purpose:
837// ------------------------------------------------------------------------------------------
838Standard_Boolean SplitUEdges(const Handle(TopTools_HArray2OfShape)& theUEdges,
4e57c75e 839 const BOPDS_PDS& theDS,
840 TopTools_DataMapOfShapeListOfShape& theHistMap) {
841
4e57c75e 842 const BOPDS_VectorOfInterfVV& aVVs = theDS->InterfVV();
7fd59977 843
844 BRep_Builder aBB;
4e57c75e 845 Standard_Integer ueit = 0, upRow, lowCol, upCol;
7fd59977 846 TopTools_Array2OfShape aNewVertices(1,2,1,2);
4e57c75e 847 //
848 upRow = theUEdges->UpperRow();
849 lowCol = theUEdges->LowerCol();
850 upCol = theUEdges->UpperCol();
851 //
852 for(ueit = theUEdges->LowerRow(); ueit <= upRow; ueit++) {
853 const TopoDS_Shape& aE1 = theUEdges->Value(ueit, lowCol);
854 const TopoDS_Shape& aE2 = theUEdges->Value(ueit, upCol);
7fd59977 855
856 if(theHistMap.IsBound(aE1) || theHistMap.IsBound(aE2))
857 continue;
858
4e57c75e 859 Standard_Integer anEIndex1 = theDS->Index(aE1);
860 Standard_Integer anEIndex2 = theDS->Index(aE2);
7fd59977 861
862 TopoDS_Vertex aCommonVertex;
863 Standard_Real apar1 = 0., apar2 = 0.;
864 Standard_Boolean bvertexfound =
4e57c75e 865 FindCommonVertex(theDS, anEIndex1, anEIndex2, aCommonVertex, apar1, apar2);
866 //
7fd59977 867 if(!bvertexfound) {
868 TopoDS_Vertex V1 = TopExp::LastVertex(TopoDS::Edge(aE1));
869 TopoDS_Vertex V2 = TopExp::FirstVertex(TopoDS::Edge(aE2));
4e57c75e 870 Standard_Integer vindex1 = theDS->Index(V1);
871 Standard_Integer vindex2 = theDS->Index(V2);
7fd59977 872 Standard_Integer vvit = 0;
4e57c75e 873 Standard_Integer aNbVVs = aVVs.Extent();
874
875 for(vvit = 0; !bvertexfound && (vvit < aNbVVs); vvit++) {
876 //const BOPTools_VVInterference& aVV = aVVs(vvit);
877 const BOPDS_InterfVV& aVV = aVVs(vvit);
878
498ce76b 879 if(((vindex1 == aVV.Index1()) && (vindex2 == aVV.Index2())) ||
880 ((vindex1 == aVV.Index2()) && (vindex2 == aVV.Index1()))) {
4e57c75e 881
882 if(!aVV.HasIndexNew()) {
883 continue;
884 }
885 aCommonVertex = TopoDS::Vertex(theDS->Shape(aVV.IndexNew()));
886 bvertexfound = Standard_True;
887 apar1 = BRep_Tool::Parameter(V1, TopoDS::Edge(aE1));
888 apar2 = BRep_Tool::Parameter(V2, TopoDS::Edge(aE2));
889 }
7fd59977 890 }
891 }
892
893 if(bvertexfound) {
894 TopoDS_Vertex aV1, aV2;
895 Standard_Real f = 0., l = 0.;
896 //
897 TopoDS_Edge aNewE1 = TopoDS::Edge(aE1.EmptyCopied());
898 TopExp::Vertices(TopoDS::Edge(aE1), aV1, aV2);
899 aNewE1.Orientation(TopAbs_FORWARD);
900 aV1.Orientation(TopAbs_FORWARD);
901 aBB.Add(aNewE1, aV1);
902 aCommonVertex.Orientation(TopAbs_REVERSED);
903 aBB.Add(aNewE1, aCommonVertex);
904 BRep_Tool::Range(TopoDS::Edge(aE1), f, l);
905 aBB.Range(aNewE1, f, apar1);
906
907 //
908 TopoDS_Edge aNewE2 = TopoDS::Edge(aE2.EmptyCopied());
909 TopExp::Vertices(TopoDS::Edge(aE2), aV1, aV2);
910 aNewE2.Orientation(TopAbs_FORWARD);
911 aCommonVertex.Orientation(TopAbs_FORWARD);
912 aBB.Add(aNewE2, aCommonVertex);
913 aBB.Add(aNewE2, aV2);
914 BRep_Tool::Range(TopoDS::Edge(aE2), f, l);
915 aBB.Range(aNewE2, apar2, l);
916
917 TopTools_ListOfShape lst;
918 lst.Append(aNewE1);
919 theHistMap.Bind(aE1, lst);
920 lst.Clear();
921 lst.Append(aNewE2);
922 theHistMap.Bind(aE2, lst);
923 }
924 }
925 return Standard_True;
926}
927
928// ------------------------------------------------------------------------------------------
929// static function: FindFreeVertices
930// purpose:
931// ------------------------------------------------------------------------------------------
932void FindFreeVertices(const TopoDS_Shape& theShape,
4e57c75e 933 const TopTools_MapOfShape& theVerticesToAvoid,
934 TopTools_ListOfShape& theListOfVertex) {
7fd59977 935
936 theListOfVertex.Clear();
937 TopTools_IndexedDataMapOfShapeListOfShape aMap;
938 TopExp::MapShapesAndAncestors(theShape, TopAbs_VERTEX, TopAbs_EDGE, aMap);
939 Standard_Integer i = 0;
940
941 for(i = 1; i <= aMap.Extent(); i++) {
942 const TopoDS_Shape& aKey = aMap.FindKey(i);
943
944 if(theVerticesToAvoid.Contains(aKey))
945 continue;
946 const TopTools_ListOfShape& aList = aMap.FindFromIndex(i);
947
948 if(aList.Extent() < 2) {
949 theListOfVertex.Append(aKey);
950 }
951 }
952}
953
7fd59977 954// ------------------------------------------------------------------------------------------
955// static function: FindCommonVertex
956// purpose:
957// ------------------------------------------------------------------------------------------
4e57c75e 958Standard_Boolean FindCommonVertex(const BOPDS_PDS& theDS,
959 const Standard_Integer theEIndex1,
960 const Standard_Integer theEIndex2,
961 TopoDS_Vertex& theCommonVertex,
962 Standard_Real& theParamOnE1,
963 Standard_Real& theParamOnE2) {
964
965 const BOPDS_VectorOfInterfEE& aEEs = theDS->InterfEE();
7fd59977 966
967 Standard_Boolean bvertexfound = Standard_False;
968 TopoDS_Vertex aCommonVertex;
969 Standard_Integer eeit = 0;
970
4e57c75e 971 Standard_Integer aNbEEs;
972 aNbEEs = aEEs.Extent();
973 for(eeit = 0; eeit < aNbEEs; ++eeit) {
974 const BOPDS_InterfEE& aEE = aEEs(eeit);
7fd59977 975
976 if((theEIndex1 == aEE.Index1() && theEIndex2 == aEE.Index2()) ||
977 (theEIndex1 == aEE.Index2() && theEIndex2 == aEE.Index1())) {
978
4e57c75e 979 if(!aEE.HasIndexNew())
980 continue;
981
982 IntTools_CommonPrt aCP = aEE.CommonPart();
983 if(aCP.Type() == TopAbs_VERTEX) {
984 theCommonVertex = *(TopoDS_Vertex*)&theDS->Shape(aEE.IndexNew());
985 if (theEIndex1 == aEE.Index1()) {
986 BOPInt_Tools::VertexParameters(aCP, theParamOnE1, theParamOnE2);
987 } else {
988 BOPInt_Tools::VertexParameters(aCP, theParamOnE2, theParamOnE1);
989 }
990 //
991 bvertexfound = Standard_True;
992 break;
7fd59977 993 }
994 }
995 }
996 return bvertexfound;
997}
998
7fd59977 999// ----------------------------------------------------------------------------------------------------
1000// static function: GetUEdges
1001// purpose:
1002// ----------------------------------------------------------------------------------------------------
1003Standard_Boolean GetUEdges(const Standard_Integer theIndex,
4e57c75e 1004 const Standard_Integer theRank,
1005 const Handle(TopTools_HArray2OfShape)& theUEdges,
1006 const TopoDS_Edge& theBoundEdge,
1007 const TopoDS_Face& theFace,
1008 TopoDS_Edge& theFirstUEdge,
1009 TopoDS_Edge& theSecondUEdge) {
1010 const TopoDS_Shape& aUE1 = theUEdges->Value(theIndex, theUEdges->LowerCol() + theRank);
1011 const TopoDS_Shape& aUE2 = theUEdges->Value(theIndex + 1, theUEdges->LowerCol() + theRank);
7fd59977 1012
1013 TopoDS_Face aFace = theFace;
1014 aFace.Orientation(TopAbs_FORWARD);
1015 TopoDS_Edge E1, E2;
1016 TopExp_Explorer anExp(aFace, TopAbs_EDGE);
1017
1018 for(; anExp.More(); anExp.Next()) {
1019 if(E1.IsNull() && aUE1.IsSame(anExp.Current())) {
1020 E1 = TopoDS::Edge(anExp.Current());
1021 }
1022 else if(E2.IsNull() && aUE2.IsSame(anExp.Current())) {
1023 E2 = TopoDS::Edge(anExp.Current());
1024 }
1025 }
1026
1027 if(E1.IsNull() || E2.IsNull())
1028 return Standard_False;
1029
1030 Standard_Real f, l;
1031 Handle(Geom2d_Curve) C1 = BRep_Tool::CurveOnSurface(E1, aFace, f, l);
1032
1033 if(C1.IsNull())
1034 return Standard_False;
4e57c75e 1035 gp_Pnt2d PU1 = (theRank == 0) ? C1->Value(l) : C1->Value(f);
7fd59977 1036 Handle(Geom2d_Curve) C2 = BRep_Tool::CurveOnSurface(theBoundEdge, aFace, f, l);
1037
1038 if(C2.IsNull())
1039 return Standard_False;
1040 BRep_Tool::Range(theBoundEdge, f, l);
1041 gp_Pnt2d pf = C2->Value(f);
4e57c75e 1042 TopoDS_Vertex aV = (theRank == 0) ? TopExp::LastVertex(E1) : TopExp::FirstVertex(E1);
7fd59977 1043 Standard_Real aTolerance = BRep_Tool::Tolerance(aV);
1044 BRepAdaptor_Surface aBAS(aFace, Standard_False);
1045
1046 if(pf.Distance(PU1) > aBAS.UResolution(aTolerance)) {
1047 TopoDS_Edge atmpE = E1;
1048 E1 = E2;
1049 E2 = atmpE;
1050 }
1051 theFirstUEdge = E1;
1052 theSecondUEdge = E2;
1053 return Standard_True;
1054}
1055
1056// ----------------------------------------------------------------------------------------------------
1057// static function: FillGap
1058// purpose:
1059// ----------------------------------------------------------------------------------------------------
1060Standard_Boolean FillGap(const TopoDS_Vertex& theFirstVertex,
4e57c75e 1061 const TopoDS_Vertex& theLastVertex,
1062 const gp_Pnt2d& theFirstPoint,
1063 const gp_Pnt2d& theLastPoint,
1064 const TopoDS_Face& theFace,
1065 const TopoDS_Compound& theSectionEdges,
1066 TopTools_ListOfShape& theOrderedList) {
7fd59977 1067
1068 TopTools_IndexedDataMapOfShapeListOfShape aMap;
1069 TopExp::MapShapesAndAncestors(theSectionEdges, TopAbs_VERTEX, TopAbs_EDGE, aMap);
1070
1071 if(aMap.IsEmpty()) {
1072 return Standard_False;
1073 }
1074
1075 if(!aMap.Contains(theFirstVertex) ||
1076 !aMap.Contains(theLastVertex)) {
1077 return Standard_False;
1078 }
1079 TopTools_ListOfShape aListOfEdge;
1080// Standard_Integer i = 0;
1081// TopoDS_Vertex aCurVertex = theFirstVertex;
1082 TopTools_MapOfShape aMapToAvoid;
1083
1084 if(FindNextEdge(theFirstVertex, theLastVertex, aMap, aMapToAvoid, aListOfEdge)) {
1085 if(!aListOfEdge.IsEmpty()) {
1086 return CheckAndOrientEdges(aListOfEdge, theFirstPoint, theLastPoint, theFace, theOrderedList);
1087 }
1088 }
1089 return Standard_False;
1090}
1091
1092// ----------------------------------------------------------------------------------------------------
1093// static function: FindNextEdge
1094// purpose:
1095// ----------------------------------------------------------------------------------------------------
1096Standard_Boolean FindNextEdge(const TopoDS_Vertex& theFirstVertex,
4e57c75e 1097 const TopoDS_Vertex& theLastVertex,
1098 const TopTools_IndexedDataMapOfShapeListOfShape& theMapVE,
1099 const TopTools_MapOfShape& theMapToAvoid,
1100 TopTools_ListOfShape& theOrderedList) {
7fd59977 1101 TopoDS_Vertex aCurVertex = theFirstVertex;
1102 TopTools_MapOfShape aMapToAvoid;
1103 aMapToAvoid = theMapToAvoid;
1104 TopTools_ListOfShape aListOfEdge;
1105 Standard_Integer i = 0;
1106
1107 for(i = 1; i <= theMapVE.Extent(); i++) {
1108 if(!theMapVE.Contains(aCurVertex))
1109 break;
1110 const TopTools_ListOfShape& lste = theMapVE.FindFromKey(aCurVertex);
1111 Standard_Boolean befound = Standard_False;
1112
1113 TopTools_ListIteratorOfListOfShape anIt(lste);
1114
1115 for(; anIt.More(); anIt.Next()) {
1116 TopoDS_Shape anEdge = anIt.Value();
1117 TopoDS_Vertex aSaveCurVertex = aCurVertex;
1118
1119 if(!aMapToAvoid.Contains(anEdge)) {
4e57c75e 1120 TopoDS_Vertex V1, V2;
1121 TopExp::Vertices(TopoDS::Edge(anEdge), V1, V2);
1122
1123 if(!aCurVertex.IsSame(V1)) {
1124 aCurVertex = V1;
1125 }
1126 else if(!aCurVertex.IsSame(V2)) {
1127 aCurVertex = V2;
1128 }
1129 aMapToAvoid.Add(anEdge);
1130 befound = Standard_True;
1131 aListOfEdge.Append(anEdge);
1132
1133 if(!aCurVertex.IsSame(theLastVertex)) {
1134 TopTools_ListOfShape aListtmp;
1135
1136 if(!FindNextEdge(aCurVertex, theLastVertex, theMapVE, aMapToAvoid, aListtmp)) {
1137 aListOfEdge.Clear();
1138 aCurVertex = aSaveCurVertex;
1139 continue;
1140 }
1141 else {
1142 aListOfEdge.Append(aListtmp);
1143 theOrderedList.Append(aListOfEdge);
1144 return Standard_True;
1145 }
1146 }
1147 break;
7fd59977 1148 }
1149 }
1150
1151 if(aCurVertex.IsSame(theLastVertex))
1152 break;
1153
1154 if(!befound) {
1155 return Standard_False;
1156 }
1157 }
1158
1159 if(aCurVertex.IsSame(theLastVertex)) {
1160 theOrderedList.Append(aListOfEdge);
1161 return Standard_True;
1162 }
1163 return Standard_False;
1164}
1165
1166// ----------------------------------------------------------------------------------------------------
1167// static function: CheckAndOrientEdges
1168// purpose:
1169// ----------------------------------------------------------------------------------------------------
1170Standard_Boolean CheckAndOrientEdges(const TopTools_ListOfShape& theOrderedList,
4e57c75e 1171 const gp_Pnt2d& theFirstPoint,
1172 const gp_Pnt2d& theLastPoint,
1173 const TopoDS_Face& theFace,
1174 TopTools_ListOfShape& theOrientedList) {
7fd59977 1175 TopTools_ListIteratorOfListOfShape anIt(theOrderedList);
1176
1177 if(!anIt.More())
1178 return Standard_True;
1179
1180 Standard_Real f, l;
1181 TopoDS_Edge aEPrev = TopoDS::Edge(anIt.Value());
1182 anIt.Next();
1183
1184 Handle(Geom2d_Curve) aCurve = BRep_Tool::CurveOnSurface(aEPrev, theFace, f, l);
1185 TopoDS_Vertex Vf, Vl;
1186 TopExp::Vertices(aEPrev, Vf, Vl);
1187 BRepAdaptor_Surface aBAS(theFace, Standard_False);
1188
1189 Standard_Real aTolerance1 = (Vf.IsNull()) ? Precision::Confusion() : BRep_Tool::Tolerance(Vf);
1190 Standard_Real aTolerance2 = (Vl.IsNull()) ? Precision::Confusion() : BRep_Tool::Tolerance(Vl);
1191 Standard_Real utol = aBAS.UResolution(aTolerance1);
1192 Standard_Real vtol = aBAS.VResolution(aTolerance1);
1193 aTolerance1 = (utol > vtol) ? utol : vtol;
1194 utol = aBAS.UResolution(aTolerance2);
1195 vtol = aBAS.VResolution(aTolerance2);
1196 aTolerance2 = (utol > vtol) ? utol : vtol;
1197
1198 gp_Pnt2d ap = aCurve->Value(f);
1199 Standard_Boolean bFirstFound = Standard_False;
1200 Standard_Boolean bLastFound = Standard_False;
1201 Standard_Boolean bforward = Standard_True;
1202
1203 if(ap.Distance(theFirstPoint) < aTolerance1) {
1204 bforward = Standard_True;
1205 if(theOrientedList.IsEmpty())
1206 theOrientedList.Append(aEPrev.Oriented(TopAbs_FORWARD));
1207 bFirstFound = Standard_True;
1208 }
1209 else if(ap.Distance(theLastPoint) < aTolerance1) {
1210 bforward = Standard_False;
1211 if(theOrientedList.IsEmpty())
1212 theOrientedList.Append(aEPrev.Oriented(TopAbs_REVERSED));
1213 bLastFound = Standard_True;
1214 }
1215 ap = aCurve->Value(l);
1216
1217 if(ap.Distance(theLastPoint) < aTolerance2) {
1218 bforward = Standard_True;
1219
1220 if(theOrientedList.IsEmpty())
1221 theOrientedList.Append(aEPrev.Oriented(TopAbs_FORWARD));
1222 bLastFound = Standard_True;
1223 }
1224 else if(ap.Distance(theFirstPoint) < aTolerance2) {
1225 bforward = Standard_False;
1226
1227 if(theOrientedList.IsEmpty())
1228 theOrientedList.Append(aEPrev.Oriented(TopAbs_REVERSED));
1229 bFirstFound = Standard_True;
1230 }
1231
1232 for(; anIt.More(); anIt.Next()) {
1233 const TopoDS_Edge& aE = TopoDS::Edge(anIt.Value());
1234 TopoDS_Vertex aV11, aV12;
1235 TopExp::Vertices(aEPrev, aV11, aV12);
1236 TopoDS_Vertex aV21, aV22;
1237 TopExp::Vertices(aE, aV21, aV22);
1238 TopAbs_Orientation anOri = TopAbs_FORWARD;
1239
1240 if(aV12.IsSame(aV21) || aV11.IsSame(aV22)) {
1241 anOri = (bforward) ? TopAbs_FORWARD : TopAbs_REVERSED;
1242 }
1243 else {
1244 anOri = (bforward) ? TopAbs_REVERSED : TopAbs_FORWARD;
1245 }
1246 theOrientedList.Append(aE.Oriented(anOri));
1247 aEPrev = aE;
1248 aTolerance1 = (aV21.IsNull()) ? Precision::Confusion() : BRep_Tool::Tolerance(aV21);
1249 aTolerance2 = (aV22.IsNull()) ? Precision::Confusion() : BRep_Tool::Tolerance(aV22);
1250 utol = aBAS.UResolution(aTolerance1);
1251 vtol = aBAS.VResolution(aTolerance1);
1252 aTolerance1 = (utol > vtol) ? utol : vtol;
1253 utol = aBAS.UResolution(aTolerance2);
1254 vtol = aBAS.VResolution(aTolerance2);
1255 aTolerance2 = (utol > vtol) ? utol : vtol;
1256 aCurve = BRep_Tool::CurveOnSurface(aE, theFace, f, l);
1257 ap = aCurve->Value(f);
1258
1259 if(ap.Distance(theFirstPoint) < aTolerance1) {
1260 bFirstFound = Standard_True;
1261 }
1262 else if(ap.Distance(theLastPoint) < aTolerance1) {
1263 bLastFound = Standard_True;
1264 }
1265 ap = aCurve->Value(l);
1266
1267 if(ap.Distance(theFirstPoint) < aTolerance2) {
1268 bFirstFound = Standard_True;
1269 }
1270 else if(ap.Distance(theLastPoint) < aTolerance2) {
1271 bLastFound = Standard_True;
1272 }
1273 }
1274
1275 if(!bFirstFound || !bLastFound)
1276 return Standard_False;
1277 return Standard_True;
1278}
1279
1280// ----------------------------------------------------------------------------------------------------
1281// static function: FindVertex
1282// purpose:
1283// ----------------------------------------------------------------------------------------------------
1284Standard_Boolean FindVertex(const TopoDS_Edge& theEdge,
4e57c75e 1285 const Standard_Integer theRank,
1286 const BOPDS_PDS& theDS,
1287 const TopTools_DataMapOfShapeListOfShape& theHistMap,
1288 TopoDS_Vertex& theVertex,
1289 BOPDS_Pave& thePave) {
7fd59977 1290
1291 if(!theHistMap.IsBound(theEdge))
1292 return Standard_False;
1293
1294 const TopTools_ListOfShape& lst = theHistMap.Find(theEdge);
1295
1296 if(lst.IsEmpty())
1297 return Standard_False;
7fd59977 1298
1299 TopoDS_Edge aNewEdge = TopoDS::Edge(lst.First());
1300 Standard_Real f, l;
1301 BRep_Tool::Range(aNewEdge, f, l);
1302
4e57c75e 1303 if(theRank == 0) {
1304 thePave.SetParameter(l);
7fd59977 1305 theVertex = TopExp::LastVertex(aNewEdge);
1306 }
1307 else {
4e57c75e 1308 thePave.SetParameter(f);
7fd59977 1309 theVertex = TopExp::FirstVertex(aNewEdge);
1310 }
4e57c75e 1311 Standard_Integer anIndex = theDS->Index(theVertex);
1312 if (anIndex == -1) {
1313 Standard_Integer i, i1, i2;
1314 i1=theDS->NbSourceShapes();
1315 i2=theDS->NbShapes();
1316 for (i=i1; i<i2; ++i) {
1317 const TopoDS_Shape& aSx=theDS->Shape(i);
1318 if(aSx.IsSame(theVertex)) {
1319 anIndex = i;
1320 break;
7fd59977 1321 }
1322 }
1323 }
4e57c75e 1324
7fd59977 1325 thePave.SetIndex(anIndex);
1326
1327 return Standard_True;
1328}
1329
1330// ----------------------------------------------------------------------------------------------------
1331// static function: FindNextVertex
1332// purpose:
1333// ----------------------------------------------------------------------------------------------------
1334Standard_Boolean FindNextVertex(const Standard_Integer theEdgeIndex,
4e57c75e 1335 const BOPDS_Pave& thePrevPave,
1336 const BOPDS_PDS& theDS,
1337 TopoDS_Vertex& theNextVertex,
1338 BOPDS_Pave& thePave) {
1339
1340 Standard_Boolean bTakePave, bFound;
1341 BOPDS_Pave aTmpPave;
1342 BOPDS_ListIteratorOfListOfPave aItP;
1343 //
1344 BOPDS_Pave anullpave;
1345 bFound = Standard_False;
1346 bTakePave = thePrevPave.IsEqual(anullpave);
1347
1348 BOPDS_ListOfPave aLP;
1349 theDS->Paves(theEdgeIndex, aLP);
1350 aItP.Initialize(aLP);
1351 for (; aItP.More(); aItP.Next()) {
1352 aTmpPave = aItP.Value();
1353 //
1354 if (bTakePave) {
1355 if (theDS->IsNewShape(aTmpPave.Index())) {
1356 theNextVertex = *(TopoDS_Vertex*)&theDS->Shape(aTmpPave.Index());
1357 thePave = aTmpPave;
1358 bFound = Standard_True;
1359 break;
7fd59977 1360 }
1361 }
4e57c75e 1362 //
1363 else if (aTmpPave.IsEqual(thePrevPave)) {
1364 bTakePave = Standard_True;
7fd59977 1365 }
1366 }
4e57c75e 1367
1368 return bFound;
7fd59977 1369}
1370
1371// ----------------------------------------------------------------------------------------------------
1372// static function: GetPave
1373// purpose:
1374// ----------------------------------------------------------------------------------------------------
4e57c75e 1375Standard_Boolean GetPave(const Standard_Integer theEdgeIndex,
1376 const Standard_Boolean isFirst,
1377 const BOPDS_PDS& theDS,
1378 BOPDS_Pave& thePave) {
7fd59977 1379
4e57c75e 1380 Handle(BOPDS_PaveBlock) aPB;
1381 BOPDS_ListOfPave aLP;
1382
1383 theDS->Paves(theEdgeIndex, aLP);
1384 if (!aLP.Extent()) {
1385 return Standard_False;
1386 }
1387 //
1388 if (isFirst) {
1389 thePave = aLP.First();
7fd59977 1390 }
1391 else {
4e57c75e 1392 thePave = aLP.Last();
7fd59977 1393 }
4e57c75e 1394
7fd59977 1395 return Standard_True;
1396}
1397
7fd59977 1398// ----------------------------------------------------------------------------------------------------
1399// static function: FindFromUEdge
1400// purpose:
1401// ----------------------------------------------------------------------------------------------------
1402Standard_Boolean FindFromUEdge(const TopoDS_Edge& theUE1Old,
4e57c75e 1403 const TopoDS_Edge& theUE2Old,
1404 const TopoDS_Edge& theUE1New,
1405 const TopoDS_Edge& theUE2New,
1406 const TopoDS_Face& theFace,
1407 const TopoDS_Compound& theSecEdges,
1408 const Standard_Integer theRank,
1409 const TopoDS_Edge& theBoundEdge,
1410 const Standard_Integer theBoundEdgeIndex,
1411 const BOPDS_PDS& theDS,
1412 const TopTools_DataMapOfShapeListOfShape& theHistMap,
1413 TopoDS_Compound& theSecEdgesNew,
1414 TopTools_ListOfShape& theListOfWireEdges,
1415 BOPDS_Pave& theFoundPave,
1416 Standard_Boolean& isOnUEdge) {
7fd59977 1417 theFoundPave.SetIndex(0);
4e57c75e 1418 theFoundPave.SetParameter(0.);
7fd59977 1419 isOnUEdge = Standard_True;
1420
7fd59977 1421 TopoDS_Face aFaceF = theFace;
1422 aFaceF.Orientation(TopAbs_FORWARD);
1423 TopoDS_Vertex aPrevVertex, aNextVertex;
1424 TopoDS_Compound aCompOfSecEdges = theSecEdges;
1425 TopTools_ListOfShape aListOfWireEdges;
1426// BRep_Builder aBB;
1427
4e57c75e 1428 BOPDS_Pave aPave1, aPave2;
7fd59977 1429 Standard_Real f = 0., l = 0.;
1430 gp_Pnt2d p1, p2;
1431 TopoDS_Vertex aFirstV, aLastV;
4e57c75e 1432 BOPDS_Pave atmpPave;
7fd59977 1433
4e57c75e 1434 if(!FindVertex(theUE1Old, theRank, theDS, theHistMap, aPrevVertex, atmpPave)) {
7fd59977 1435 return Standard_True;
1436 }
1437
1438 if(aPrevVertex.IsNull()) {
1439 return Standard_False;
1440 }
1441
1442 aFirstV = aPrevVertex;
1443 Standard_Boolean bSecFound = Standard_False;
1444 Handle(Geom2d_Curve) aC1 = BRep_Tool::CurveOnSurface(theUE1New, aFaceF, f, l);
4e57c75e 1445 p1 = (theRank == 0) ? aC1->Value(l) : aC1->Value(f);
1446 BOPDS_Pave afoundpave;
1447 BOPDS_ListOfPave aLP;
1448 theDS->Paves(theBoundEdgeIndex, aLP);
1449 Standard_Integer nbpave = aLP.Extent();
7fd59977 1450 Standard_Integer pit = 0;
4e57c75e 1451
1452 while(FindNextVertex(theBoundEdgeIndex, aPave1, theDS, aNextVertex, aPave2) && (pit < nbpave)) {
7fd59977 1453 aLastV = aNextVertex;
1454 Handle(Geom2d_Curve) aC2 = BRep_Tool::CurveOnSurface(theBoundEdge, aFaceF, f, l);
4e57c75e 1455 p2 = aC2->Value(aPave2.Parameter());
7fd59977 1456 TopTools_ListOfShape aOrderedList;
1457
1458 if(FillGap(aFirstV, aLastV, p1, p2, aFaceF, aCompOfSecEdges, aOrderedList)) {
1459 // remove found edges...
1460 TopoDS_Compound aComp;
1461 RemoveEdges(aCompOfSecEdges, aOrderedList, aComp);
1462 aCompOfSecEdges = aComp;
1463 aListOfWireEdges.Append(aOrderedList);
1464 afoundpave = aPave2;
1465 isOnUEdge = Standard_False;
1466 bSecFound = Standard_True;
1467 break;
1468 }
1469 aPrevVertex = aNextVertex;
1470 aPave1 = aPave2;
1471 pit++;
1472 }
1473
4e57c75e 1474 if(!bSecFound && FindVertex(theUE2Old, theRank, theDS, theHistMap, aNextVertex, aPave2)) {
7fd59977 1475 aLastV = aNextVertex;
1476 Handle(Geom2d_Curve) aC2 = BRep_Tool::CurveOnSurface(theUE2New, aFaceF, f, l);
4e57c75e 1477 p2 = aC2->Value(aPave2.Parameter());
7fd59977 1478 TopTools_ListOfShape aOrderedList;
1479
1480 if(FillGap(aFirstV, aLastV, p1, p2, aFaceF, aCompOfSecEdges, aOrderedList)) {
1481 // remove found edges...
1482 TopoDS_Compound aComp;
1483
1484 RemoveEdges(aCompOfSecEdges, aOrderedList, aComp);
1485 aCompOfSecEdges = aComp;
1486 aListOfWireEdges.Append(aOrderedList);
1487 afoundpave = aPave2;
1488 bSecFound = Standard_True;
1489 isOnUEdge = Standard_True;
1490 }
1491 }
1492
1493 if(bSecFound) {
1494 theFoundPave = afoundpave;
1495 theListOfWireEdges = aListOfWireEdges;
1496 theSecEdgesNew = aCompOfSecEdges;
1497 }
1498 return Standard_True;
1499}
1500
1501
1502// ----------------------------------------------------------------------------------------------------
1503// static function: FindFromVEdge
1504// purpose:
1505// ----------------------------------------------------------------------------------------------------
4e57c75e 1506Standard_Boolean FindFromVEdge(const BOPDS_Pave& thePrevPave,
1507 const Standard_Boolean& isOnUEdge,
1508 const TopoDS_Edge& theUE1Old,
1509 const TopoDS_Edge& theUE2Old,
1510 const TopoDS_Face& theFace,
1511 const TopoDS_Compound& theSecEdges,
1512 const Standard_Integer theRank,
1513 const TopoDS_Edge& theBoundEdge,
1514 const Standard_Integer theBoundEdgeIndex,
1515 const BOPDS_PDS& theDS,
1516 const TopTools_DataMapOfShapeListOfShape& theHistMap,
1517 TopTools_ListOfShape& theListOfWireEdges,
1518 Standard_Boolean& isSectionFound) {
1519
7fd59977 1520 theListOfWireEdges.Clear();
1521 isSectionFound = Standard_False;
4e57c75e 1522 //
7fd59977 1523 TopoDS_Face aFaceF = theFace;
1524 aFaceF.Orientation(TopAbs_FORWARD);
1525 TopoDS_Vertex aPrevVertex, aNextVertex;
1526 TopoDS_Compound aCompOfSecEdges = theSecEdges;
1527 TopTools_ListOfShape aListOfWireEdges;
1528// BRep_Builder aBB;
1529
4e57c75e 1530 BOPDS_Pave aPave1, aPave2;
7fd59977 1531
1532 if(isOnUEdge) {
1533 TopoDS_Vertex atmpVertex;
4e57c75e 1534 BOPDS_Pave aPaveOfE2;
7fd59977 1535
4e57c75e 1536 if(FindVertex(theUE2Old, theRank, theDS, theHistMap, atmpVertex, aPaveOfE2)) {
7fd59977 1537 if(thePrevPave.IsEqual(aPaveOfE2))
4e57c75e 1538 return Standard_True;
7fd59977 1539 }
1540 }
1541
1542 Standard_Real f = 0., l = 0.;
1543 gp_Pnt2d p1(0., 0.), p2(0., 0.);
1544 TopoDS_Vertex aFirstV, aLastV;
1545 Handle(Geom2d_Curve) aC1 = BRep_Tool::CurveOnSurface(theUE1Old, aFaceF, f, l);
1546 Handle(Geom2d_Curve) aC2 = BRep_Tool::CurveOnSurface(theBoundEdge, aFaceF, f, l);
1547 Standard_Boolean bSecFound = Standard_False;
1548
1549 aPave1 = thePrevPave;
1550
1551 if(isOnUEdge) {
4e57c75e 1552 BOPDS_Pave atmpPave;
7fd59977 1553
4e57c75e 1554 if(!GetPave(theBoundEdgeIndex, Standard_True, theDS, atmpPave)) {
7fd59977 1555 return Standard_False;
1556 }
1557 aPave1 = atmpPave;
1558 }
4e57c75e 1559 p1 = aC2->Value(aPave1.Parameter());
1560 aPrevVertex = TopoDS::Vertex(theDS->Shape(aPave1.Index()));
7fd59977 1561
4e57c75e 1562 BOPDS_ListOfPave aLP;
1563 theDS->Paves(theBoundEdgeIndex, aLP);
1564 Standard_Integer nbpave = aLP.Extent();
7fd59977 1565 Standard_Integer pit = 0;
1566 TopTools_Array1OfListOfShape anArrayOfListOfSec(1, nbpave);
1567
1568 // by pairs non continuously. begin
1569 Standard_Integer k = 0;
4e57c75e 1570 BOPDS_Pave aFirstPave = aPave1;
7fd59977 1571 TopoDS_Vertex aFirstVertex = aPrevVertex;
1572 gp_Pnt2d apfirst = p1;
4e57c75e 1573 BOPDS_ListOfPave aFirstPaves, aLastPaves;
7fd59977 1574 TColStd_ListOfInteger aListOfFlags;
1575 Standard_Integer apaircounter = 1;
1576
1577 for(k = 0; k < nbpave; k++) {
1578 aPave1 = aFirstPave;
1579 p1 = apfirst;
1580 aPrevVertex = aFirstVertex;
1581 Standard_Boolean bfound = Standard_False;
1582 pit = 0;
1583
4e57c75e 1584 while(FindNextVertex(theBoundEdgeIndex, aPave1, theDS, aNextVertex, aPave2) && (pit < nbpave)) {
7fd59977 1585 aFirstV = aPrevVertex;
1586 aLastV = aNextVertex;
4e57c75e 1587 p2 = aC2->Value(aPave2.Parameter());
7fd59977 1588
1589 TopTools_ListOfShape aOrderedList;
1590
1591 if(FillGap(aFirstV, aLastV, p1, p2, aFaceF, aCompOfSecEdges, aOrderedList)) {
4e57c75e 1592 TopoDS_Compound aComp;
1593 RemoveEdges(aCompOfSecEdges, aOrderedList, aComp);
1594 aCompOfSecEdges = aComp;
1595
1596 anArrayOfListOfSec(apaircounter++).Append(aOrderedList);
1597 aFirstPaves.Append(aFirstPave);
1598 aLastPaves.Append(aPave2);
1599 aListOfFlags.Append(1);
1600 aFirstPave = aPave2;
1601 aFirstVertex = aNextVertex;
1602 apfirst = p2;
1603 aPrevVertex = aNextVertex;
1604 bSecFound = Standard_True;
1605 bfound = Standard_True;
7fd59977 1606 }
1607 aPave1 = aPave2;
1608 pit++;
1609 }
1610
4e57c75e 1611 if(FindVertex(theUE2Old, theRank, theDS, theHistMap, aNextVertex, aPave2)) {
7fd59977 1612 aFirstV = aPrevVertex;
1613 aLastV = aNextVertex;
1614 Handle(Geom2d_Curve) aC3 = BRep_Tool::CurveOnSurface(theUE2Old, aFaceF, f, l);
4e57c75e 1615 p2 = aC3->Value(aPave2.Parameter());
7fd59977 1616
1617 TopTools_ListOfShape aOrderedList;
1618
1619 if(FillGap(aFirstV, aLastV, p1, p2, aFaceF, aCompOfSecEdges, aOrderedList)) {
4e57c75e 1620 TopoDS_Compound aComp;
1621 RemoveEdges(aCompOfSecEdges, aOrderedList, aComp);
1622 aCompOfSecEdges = aComp;
1623 anArrayOfListOfSec(apaircounter++).Append(aOrderedList);
1624 aFirstPaves.Append(aFirstPave);
1625 aLastPaves.Append(aPave2);
1626 aListOfFlags.Append(0);
1627 bSecFound = Standard_True;
1628 break;
7fd59977 1629 }
1630 }
1631
1632 if(!bfound) {
4e57c75e 1633 if(!FindNextVertex(theBoundEdgeIndex, aFirstPave, theDS, aNextVertex, aPave2)) {
1634 break;
7fd59977 1635 }
1636 aFirstPave = aPave2;
4e57c75e 1637 apfirst = aC2->Value(aPave2.Parameter());
7fd59977 1638 aFirstVertex = aNextVertex;
1639 }
1640 }
1641 // by pairs non continuously. end
1642
1643 // by pairs continuously. begin
1644 aPave1 = thePrevPave;
1645
1646 if(isOnUEdge) {
4e57c75e 1647 BOPDS_Pave atmpPave;
7fd59977 1648
4e57c75e 1649 if(!GetPave(theBoundEdgeIndex, Standard_True, theDS, atmpPave)) {
7fd59977 1650 return Standard_False;
1651 }
1652 aPave1 = atmpPave;
1653 }
4e57c75e 1654 p1 = aC2->Value(aPave1.Parameter());
1655 aPrevVertex = TopoDS::Vertex(theDS->Shape(aPave1.Index()));
7fd59977 1656
1657 pit = 0;
1658
4e57c75e 1659 while(FindNextVertex(theBoundEdgeIndex, aPave1, theDS, aNextVertex, aPave2) && (pit < nbpave)) {
7fd59977 1660 aFirstV = aPrevVertex;
1661 aLastV = aNextVertex;
4e57c75e 1662 p2 = aC2->Value(aPave2.Parameter());
7fd59977 1663
1664 Standard_Boolean bisinside = Standard_False;
1665 Standard_Integer apbindex = 0;
1666 Standard_Integer apbcounter = 1;
4e57c75e 1667 BOPDS_ListIteratorOfListOfPaveBlock aPBIt;
1668 BOPDS_ListIteratorOfListOfPave aPIt1, aPIt2;
7fd59977 1669 TColStd_ListIteratorOfListOfInteger aFlagIt;
1670
1671 for(aPIt1.Initialize(aFirstPaves), aPIt2.Initialize(aLastPaves), aFlagIt.Initialize(aListOfFlags);
4e57c75e 1672 aPIt1.More() && aPIt2.More() && aFlagIt.More();
1673 aPIt1.Next(), aPIt2.Next(), aFlagIt.Next(), apbcounter++) {
7fd59977 1674
1675 Standard_Boolean bfin = Standard_False;
1676 Standard_Boolean blin = Standard_False;
1677
1678 if(aPave1.IsEqual(aPIt1.Value())) {
4e57c75e 1679 bfin = Standard_True;
7fd59977 1680 }
1681 else {
4e57c75e 1682 bfin = (aPave1.Parameter() > aPIt1.Value().Parameter());
7fd59977 1683 }
1684
1685 if(aFlagIt.Value()) {
4e57c75e 1686 if(aPave2.IsEqual(aPIt2.Value())) {
1687 blin = Standard_True;
1688 }
1689 else {
1690 blin = (aPave2.Parameter() < aPIt2.Value().Parameter());
1691 }
7fd59977 1692 }
1693 else {
4e57c75e 1694 if((aPave2.Index() == aPIt2.Value().Index()) && (aPave2.Index() > 0)) {
1695 Handle(Geom2d_Curve) pc = BRep_Tool::CurveOnSurface(theUE2Old, aFaceF, f, l);
1696 gp_Pnt2d p3 = pc->Value(aPIt2.Value().Parameter());
1697 TopoDS_Vertex aV = TopoDS::Vertex(theDS->Shape(aPave2.Index()));
1698 BRepAdaptor_Surface aBAS(aFaceF, Standard_False);
1699 Standard_Real aTolerance = BRep_Tool::Tolerance(aV);
1700 Standard_Real utol = aBAS.UResolution(aTolerance);
1701 Standard_Real vtol = aBAS.VResolution(aTolerance);
1702 aTolerance = (utol > vtol) ? utol : vtol;
1703
1704 if(p2.Distance(p3) < aTolerance)
1705 blin = Standard_True;
1706 }
7fd59977 1707 }
1708
1709 if(bfin && blin) {
4e57c75e 1710 apbindex = apbcounter;
1711 bisinside = Standard_True;
1712 break;
7fd59977 1713 }
1714 }
1715
1716 if(!bisinside) {
1717
1718 TopTools_ListOfShape aOrderedList;
1719
1720 if(FillGap(aFirstV, aLastV, p1, p2, aFaceF, aCompOfSecEdges, aOrderedList)) {
4e57c75e 1721 TopoDS_Compound aComp;
1722 RemoveEdges(aCompOfSecEdges, aOrderedList, aComp);
1723 aCompOfSecEdges = aComp;
1724 aListOfWireEdges.Append(aOrderedList);
7fd59977 1725
4e57c75e 1726 bSecFound = Standard_True;
7fd59977 1727 }
1728 else {
4e57c75e 1729 TopoDS_Edge aESplit;
1730 // get split
1731 aPBIt.Initialize(theDS->PaveBlocks(theBoundEdgeIndex));
1732
1733 for(; aPBIt.More(); aPBIt.Next()) {
1734 const Handle(BOPDS_PaveBlock)& aPB1 = aPBIt.Value();
1735 if (aPB1->OriginalEdge() == theBoundEdgeIndex &&
1736 aPB1->Pave1().IsEqual(aPave1) &&
1737 aPB1->Pave2().IsEqual(aPave2) ) {
1738 if(aPB1->Edge() > 0) {
1739 aESplit = *(TopoDS_Edge*)&theDS->Shape(aPB1->Edge());
1740 break;
1741 }
1742 }
1743 }
1744
1745 if(!aESplit.IsNull()) {
1746 aListOfWireEdges.Append(aESplit);
1747 }
7fd59977 1748 }
1749 }
1750 else {
1751 if(apbindex > 0) {
4e57c75e 1752 TopTools_ListOfShape& aListOfSec = anArrayOfListOfSec(apbindex);
1753 aListOfWireEdges.Append(aListOfSec);
7fd59977 1754 }
1755 }
1756 aPave1 = aPave2;
1757 aPrevVertex = aNextVertex;
1758 p1 = p2;
1759 pit++;
1760 }
1761
4e57c75e 1762 if(FindVertex(theUE2Old, theRank, theDS, theHistMap, aNextVertex, aPave2)) {
7fd59977 1763 aFirstV = aPrevVertex;
1764 aLastV = aNextVertex;
1765 Handle(Geom2d_Curve) aC3 = BRep_Tool::CurveOnSurface(theUE2Old, aFaceF, f, l);
4e57c75e 1766 p2 = aC3->Value(aPave2.Parameter());
7fd59977 1767
1768 Standard_Boolean bisinside = Standard_False;
1769 Standard_Integer apbindex = 0;
1770 Standard_Integer apbcounter = 1;
4e57c75e 1771 BOPDS_ListIteratorOfListOfPaveBlock aPBIt;
1772 BOPDS_ListIteratorOfListOfPave aPIt1, aPIt2;
7fd59977 1773 TColStd_ListIteratorOfListOfInteger aFlagIt;
1774
1775 for(aPIt1.Initialize(aFirstPaves), aPIt2.Initialize(aLastPaves), aFlagIt.Initialize(aListOfFlags);
4e57c75e 1776 aPIt1.More() && aPIt2.More() && aFlagIt.More();
1777 aPIt1.Next(), aPIt2.Next(), aFlagIt.Next(), apbcounter++) {
7fd59977 1778
1779 Standard_Boolean bfin = Standard_False;
1780 Standard_Boolean blin = Standard_False;
1781
1782 if(aPave1.IsEqual(aPIt1.Value())) {
4e57c75e 1783 bfin = Standard_True;
7fd59977 1784 }
1785 else {
4e57c75e 1786 bfin = (aPave1.Parameter() > aPIt1.Value().Parameter());
7fd59977 1787 }
1788
1789 if(aFlagIt.Value()) {
4e57c75e 1790 if(aPave2.IsEqual(aPIt2.Value())) {
1791 blin = Standard_True;
1792 }
1793 else {
1794 blin = (aPave2.Parameter() < aPIt2.Value().Parameter());
1795 }
7fd59977 1796 }
1797 else {
4e57c75e 1798 blin = Standard_True;
7fd59977 1799 }
1800
1801 if(bfin && blin) {
4e57c75e 1802 apbindex = apbcounter;
1803 bisinside = Standard_True;
1804 break;
7fd59977 1805 }
1806 }
1807
1808 if(!bisinside) {
1809
1810 TopTools_ListOfShape aOrderedList;
1811
1812 if(FillGap(aFirstV, aLastV, p1, p2, aFaceF, aCompOfSecEdges, aOrderedList)) {
4e57c75e 1813 TopoDS_Compound aComp;
1814 RemoveEdges(aCompOfSecEdges, aOrderedList, aComp);
1815 aCompOfSecEdges = aComp;
1816 aListOfWireEdges.Append(aOrderedList);
7fd59977 1817
4e57c75e 1818 bSecFound = Standard_True;
7fd59977 1819 }
1820 else {
4e57c75e 1821 //add split
1822 TopoDS_Edge aESplit;
1823 // get split
1824 if(!GetPave(theBoundEdgeIndex, Standard_False, theDS, aPave2))
1825 return Standard_False;
1826 //
1827 aPBIt.Initialize(theDS->PaveBlocks(theBoundEdgeIndex));
1828 for(; aPBIt.More(); aPBIt.Next()) {
1829 const Handle(BOPDS_PaveBlock)& aPB1 = aPBIt.Value();
1830 if (aPB1->OriginalEdge() == theBoundEdgeIndex &&
1831 aPB1->Pave1().IsEqual(aPave1) &&
1832 aPB1->Pave2().IsEqual(aPave2) ) {
1833 if(aPB1->Edge() > 0) {
1834 aESplit = *(TopoDS_Edge*)&theDS->Shape(aPB1->Edge());
1835 break;
1836 }
1837 }
1838 }
1839
1840 if(!aESplit.IsNull()) {
1841 aListOfWireEdges.Append(aESplit);
1842 }
7fd59977 1843 }
1844 }
1845 else {
1846 if(apbindex > 0) {
4e57c75e 1847 TopTools_ListOfShape& aListOfSec = anArrayOfListOfSec(apbindex);
1848 aListOfWireEdges.Append(aListOfSec);
7fd59977 1849 }
1850 }
1851 }
1852 else {
1853 //add split
1854 TopoDS_Edge aESplit;
1855 // get split
4e57c75e 1856 if(!GetPave(theBoundEdgeIndex, Standard_False, theDS, aPave2))
7fd59977 1857 return Standard_False;
7fd59977 1858
4e57c75e 1859 BOPDS_ListIteratorOfListOfPaveBlock aPBIt;
1860 aPBIt.Initialize(theDS->PaveBlocks(theBoundEdgeIndex));
7fd59977 1861 for(; aPBIt.More(); aPBIt.Next()) {
4e57c75e 1862 const Handle(BOPDS_PaveBlock)& aPB1 = aPBIt.Value();
1863 if (aPB1->OriginalEdge() == theBoundEdgeIndex &&
1864 aPB1->Pave1().IsEqual(aPave1) &&
1865 aPB1->Pave2().IsEqual(aPave2) ) {
1866 if(aPB1->Edge() > 0) {
1867 aESplit = *(TopoDS_Edge*)&theDS->Shape(aPB1->Edge());
1868 break;
1869 }
7fd59977 1870 }
1871 }
1872
1873 if(!aESplit.IsNull()) {
1874 aListOfWireEdges.Append(aESplit);
1875 }
1876 }
1877
1878 // by pairs continuously. end
1879 theListOfWireEdges = aListOfWireEdges;
1880 isSectionFound = bSecFound;
1881 return Standard_True;
1882}
1883
1884// ----------------------------------------------------------------------------------------------------
1885// static function: RemoveEdges
1886// purpose:
1887// ----------------------------------------------------------------------------------------------------
1888void RemoveEdges(const TopoDS_Compound& theSourceComp,
4e57c75e 1889 const TopTools_ListOfShape& theListToRemove,
1890 TopoDS_Compound& theResultComp) {
7fd59977 1891 BRep_Builder aBB;
1892 TopoDS_Compound aComp;
1893 aBB.MakeCompound(aComp);
1894 TopExp_Explorer anExp(theSourceComp, TopAbs_EDGE);
1895
1896 for(; anExp.More(); anExp.Next()) {
1897 Standard_Boolean bfound = Standard_False;
1898 TopTools_ListIteratorOfListOfShape anIt(theListToRemove);
1899
1900 for(; !bfound && anIt.More(); anIt.Next()) {
1901 bfound = anExp.Current().IsSame(anIt.Value());
1902 }
1903
1904 if(!bfound) {
1905 aBB.Add(aComp, anExp.Current());
1906 }
1907 }
1908 theResultComp = aComp;
1909}
1910
1911// ----------------------------------------------------------------------------------------------------
1912// static function: FilterSectionEdges
1913// purpose:
1914// ----------------------------------------------------------------------------------------------------
4e57c75e 1915Standard_Boolean FilterSectionEdges(const BOPDS_VectorOfCurve& theBCurves,
1916 const TopoDS_Face& theSecPlane,
1917 const BOPDS_PDS& theDS,
1918 TopoDS_Compound& theResult) {
7fd59977 1919
1920 theResult.Nullify();
7fd59977 1921
1922 BRep_Builder aBB;
1923 aBB.MakeCompound(theResult);
4e57c75e 1924 Standard_Integer aNbCurves = theBCurves.Extent();
7fd59977 1925 Standard_Integer cit = 0;
4e57c75e 1926 BOPDS_ListIteratorOfListOfPaveBlock aPBIt;
1927
1928 for(cit = 0; cit < aNbCurves; ++cit) {
1929 const BOPDS_Curve& aBCurve = theBCurves(cit);
1930 const BOPDS_ListOfPaveBlock& aSectEdges = aBCurve.PaveBlocks();
7fd59977 1931
4e57c75e 1932 aPBIt.Initialize(aSectEdges);
7fd59977 1933 for (; aPBIt.More(); aPBIt.Next()) {
4e57c75e 1934 const Handle(BOPDS_PaveBlock)& aPB = aPBIt.Value();
1935 Standard_Integer nSect = aPB->Edge();
1936 const TopoDS_Shape& aS = theDS->Shape(nSect);
7fd59977 1937 TopoDS_Edge anEdge = TopoDS::Edge(aS);
1938 Standard_Boolean bAddEdge = Standard_True;
1939
1940 if(!theSecPlane.IsNull()) {
4e57c75e 1941 IntTools_BeanFaceIntersector anIntersector(anEdge, theSecPlane);
1942 Standard_Real f = 0., l = 0.;
1943 BRep_Tool::Range(anEdge, f, l);
1944 anIntersector.SetBeanParameters(f, l);
1945 //
1946 Handle(BOPInt_Context) aContext = new BOPInt_Context;
1947 anIntersector.SetContext(aContext);
1948 //
1949 anIntersector.Perform();
1950
1951 if(anIntersector.IsDone()) {
1952 bAddEdge = Standard_False;
1953 Standard_Integer r = 0;
1954
1955 for(r = 1; r <= anIntersector.Result().Length(); r++) {
1956 const IntTools_Range& aRange = anIntersector.Result().Value(r);
1957
1958 if(((aRange.First() - f) < Precision::PConfusion()) &&
1959 ((l - aRange.Last()) < Precision::PConfusion())) {
1960 bAddEdge = Standard_True;
1961 break;
1962 }//if(((aRange.First() - f) < Precision::PConfusion()) &&
1963 }//for(r = 1; r <= anIntersector.Result().Length(); r++) {
1964 }//if(anIntersector.IsDone()) {
1965 }//if(!theSecPlane.IsNull()) {
7fd59977 1966
1967 if(bAddEdge) {
4e57c75e 1968 aBB.Add(theResult, aS);
7fd59977 1969 }
4e57c75e 1970 }//for (; aPBIt.More(); aPBIt.Next()) {
1971 }//for(cit = 0; cit < aNbCurves; ++cit) {
1972
7fd59977 1973 return Standard_True;
1974}
1975
1976
1977//=======================================================================
1978//function : ComputeAveragePlaneAndMaxDeviation
1979//purpose :
1980//=======================================================================
1981static Standard_Real ComputeAveragePlaneAndMaxDeviation(const TopoDS_Shape& aWire,
4e57c75e 1982 gp_Pln& thePlane,
1983 Standard_Boolean& IsSingular)
7fd59977 1984{
1985 Standard_Integer N = 40, nedges = 0;
1986
1987 TopoDS_Iterator iter( aWire );
1988 for (; iter.More(); iter.Next())
1989 nedges++;
1990
1991 TColgp_Array1OfPnt Pnts( 1, nedges*N );
1992 Standard_Integer ind = 1, i;
1993 for (iter.Initialize(aWire); iter.More(); iter.Next())
1994 {
1995 const TopoDS_Edge& anEdge = TopoDS::Edge( iter.Value() );
1996 BRepAdaptor_Curve aCurve(anEdge);
1997 GCPnts_UniformAbscissa Distribution( aCurve, N+1 );
1998 for (i = 1; i <= N; i++)
4e57c75e 1999 {
2000 Standard_Real par = Distribution.Parameter(i);
2001 Pnts( ind++ ) = aCurve.Value(par);
2002 }
7fd59977 2003 }
2004
2005 gp_Ax2 Axe;
2006 GeomLib::AxeOfInertia( Pnts, Axe, IsSingular );
2007 if (IsSingular)
2008 return -1;
2009
2010 thePlane = gp_Pln( Axe );
2011 Standard_Real MaxDeviation = 0;
2012 for (i = 1; i <= Pnts.Length(); i++)
2013 {
2014 Standard_Real dist = thePlane.Distance( Pnts(i) );
2015 if (dist > MaxDeviation)
4e57c75e 2016 MaxDeviation = dist;
7fd59977 2017 }
2018 return MaxDeviation;
2019}
2020
2021//=======================================================================
2022//function : ChooseSection
2023//purpose :
2024//=======================================================================
2025static Standard_Boolean ChooseSection(const TopoDS_Shape& Comp,
4e57c75e 2026 const gp_Ax2& bis,
2027 TopoDS_Shape& resWire,
2028 gp_Pln& resPlane,
2029 Standard_Boolean& IsSingular)
7fd59977 2030{
2031 IsSingular = Standard_False;
2032 Standard_Real TolDeviation = 0.01; //, TolConf = 1.e-4, TolAng = 1.e-5;
2033
2034// Standard_Integer N = 100;
2035 Standard_Integer ind, i, j;
2036
2037 //Simplest case
2038 TopoDS_Compound OldComp;
2039 BRep_Builder B;
2040 B.MakeCompound( OldComp );
2041 TopoDS_Iterator iter( Comp );
2042 for (; iter.More(); iter.Next())
2043 B.Add( OldComp, iter.Value() );
2044
2045 Standard_Boolean anError = Standard_False;
2046 //TopoDS_Wire NewWire [2];
2047 TopTools_SequenceOfShape Wseq;
2048 for (;;)
2049 {
2050 TopExp_Explorer explo( OldComp, TopAbs_EDGE );
2051 if (!explo.More())
4e57c75e 2052 break;
7fd59977 2053 TopoDS_Edge FirstEdge = TopoDS::Edge( explo.Current() );
2054 TopoDS_Wire NewWire = BRepLib_MakeWire( FirstEdge );
2055 B.Remove( OldComp, FirstEdge );
2056 if (NewWire.Closed())
4e57c75e 2057 {
2058 Wseq.Append(NewWire);
2059 continue;
2060 }
7fd59977 2061
2062 for (;;)
4e57c75e 2063 {
2064 TopoDS_Vertex Extremity [2];
2065 TopExp::Vertices( NewWire, Extremity[0], Extremity[1] );
2066 if (Extremity[0].IsNull() || Extremity[1].IsNull())
2067 {
2068 anError = Standard_True;
2069 break;
2070 }
2071 TopTools_IndexedDataMapOfShapeListOfShape VEmap;
2072 TopExp::MapShapesAndAncestors( OldComp, TopAbs_VERTEX, TopAbs_EDGE, VEmap );
2073 TopTools_ListOfShape Vedges [2];
2074 for (j = 0; j < 2; j++)
2075 if (VEmap.Contains( Extremity[j] ))
2076 Vedges[j] = VEmap.FindFromKey( Extremity[j] );
2077 if (Vedges[0].IsEmpty() && Vedges[1].IsEmpty())
2078 //no more edges in OldComp to continue NewWire
2079 break;
2080 Standard_Boolean Modified = Standard_False;
2081 for (j = 0; j < 2; j++)
2082 {
2083 if (Vedges[j].Extent() == 1)
2084 {
2085 const TopoDS_Edge& anEdge = TopoDS::Edge( Vedges[j].First() );
2086 NewWire = BRepLib_MakeWire( NewWire, anEdge );
2087 B.Remove( OldComp, anEdge );
2088 Modified = Standard_True;
2089 }
2090 }
2091 if (!Modified) //only multiple connections
2092 {
2093 ind = (Vedges[0].IsEmpty())? 1 : 0;
2094 TopTools_SequenceOfShape Edges;
2095 TopTools_ListIteratorOfListOfShape itl( Vedges[ind] );
2096 for (; itl.More(); itl.Next())
2097 Edges.Append( itl.Value() );
2098 Standard_Integer theind=0;
2099 Standard_Real MinDeviation = RealLast();
2100 for (j = 1; j <= Edges.Length(); j++)
2101 {
2102 TopoDS_Wire aWire = BRepLib_MakeWire( NewWire, TopoDS::Edge(Edges(j)) );
2103 gp_Pln aPlane;
2104 Standard_Boolean issing;
2105 Standard_Real Deviation = ComputeAveragePlaneAndMaxDeviation( aWire, aPlane, issing );
2106 if (Deviation < MinDeviation)
2107 {
2108 MinDeviation = Deviation;
2109 theind = j;
2110 }
2111 }
2112 NewWire = BRepLib_MakeWire( NewWire, TopoDS::Edge(Edges(theind)) );
2113 B.Remove( OldComp, Edges(theind) );
2114 }
2115 if (NewWire.Closed())
2116 break;
2117 }
7fd59977 2118 Wseq.Append(NewWire);
2119 if (anError)
4e57c75e 2120 break;
7fd59977 2121 }
2122
2123 Standard_Real Deviation=0.;
2124 Standard_Real MinAngle = RealLast();
2125 TopExp_Explorer Explo( OldComp, TopAbs_EDGE );
2126 if (!anError && !Explo.More())
2127 {
2128 if (Wseq.Length() == 1)
4e57c75e 2129 {
2130 resWire = Wseq.First();
2131 Deviation = ComputeAveragePlaneAndMaxDeviation( resWire, resPlane, IsSingular );
2132 return Standard_True;
2133 }
7fd59977 2134 else
4e57c75e 2135 {
2136 for (i = 1; i <= Wseq.Length(); i++)
2137 {
2138 TopoDS_Wire aWire = TopoDS::Wire( Wseq(i) );
2139 gp_Pln aPln;
2140 Standard_Boolean issing;
2141 Standard_Real aDeviation =
2142 ComputeAveragePlaneAndMaxDeviation( aWire, aPln, issing );
2143 if (issing)
2144 continue;
2145
2146 Standard_Real Angle = aPln.Axis().Angle( bis.Axis() );
2147 if (Angle > M_PI/2)
2148 Angle = M_PI - Angle;
2149
2150 if (Angle < MinAngle)
2151 {
2152 MinAngle = Angle;
2153 resWire = aWire;
2154 resPlane = aPln;
2155 Deviation = aDeviation;
2156 }
2157 }
2158 if (Deviation <= TolDeviation)
2159 return Standard_True;
2160 }
7fd59977 2161 }
2162 return Standard_False;
2163 //end of simplest case
2164}
Open CASCADE Technology repository