0025477: Boolean Operations with additional tolerance - Fuzzy Boolean operations
[occt.git] / src / BOPDS / BOPDS_DS.cxx
CommitLineData
4e57c75e 1// Created by: Peter KURNEV
973c2be1 2// Copyright (c) 1999-2014 OPEN CASCADE SAS
4e57c75e 3//
973c2be1 4// This file is part of Open CASCADE Technology software library.
4e57c75e 5//
d5f74e42 6// This library is free software; you can redistribute it and/or modify it under
7// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1 8// by the Free Software Foundation, with special exception defined in the file
9// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10// distribution for complete text of the license and disclaimer of any warranty.
4e57c75e 11//
973c2be1 12// Alternatively, this file may be used under the terms of Open CASCADE
13// commercial license or contractual agreement.
4e57c75e 14
15#include <BOPDS_DS.ixx>
16//
7a76337e 17#include <Standard_Assert.hxx>
18//
4e57c75e 19#include <NCollection_IncAllocator.hxx>
20#include <NCollection_BaseAllocator.hxx>
21
22#include <gp_Pnt.hxx>
23#include <Bnd_Box.hxx>
24//
25#include <TopoDS_Shape.hxx>
26#include <TopoDS_Iterator.hxx>
27#include <TopoDS_Vertex.hxx>
28#include <TopoDS_Edge.hxx>
29#include <TopoDS_Face.hxx>
b1d15f53 30//
31#include <BRep_TVertex.hxx>
32#include <BRep_TEdge.hxx>
33#include <BRep_TFace.hxx>
4e57c75e 34#include <BRep_Tool.hxx>
35//
36#include <BRepBndLib.hxx>
37//
38#include <BOPCol_MapOfInteger.hxx>
39#include <BOPCol_ListOfInteger.hxx>
40#include <BOPCol_DataMapOfShapeInteger.hxx>
b1d15f53 41#include <BOPCol_DataMapOfIntegerMapOfInteger.hxx>
4e57c75e 42//
43#include <BOPDS_IndexRange.hxx>
44#include <BOPDS_ShapeInfo.hxx>
45#include <BOPDS_PassKey.hxx>
46#include <BOPDS_DataMapOfPassKeyListOfPaveBlock.hxx>
47#include <BOPDS_PassKey.hxx>
decdfc94 48#include <BOPDS_MapOfPave.hxx>
49#include <BOPDS_MapOfPaveBlock.hxx>
7a76337e 50#include <BOPDS_VectorOfPave.hxx>
4e57c75e 51
52#include <Geom_Curve.hxx>
53#include <BRep_Builder.hxx>
54#include <Precision.hxx>
55#include <IntTools_Tools.hxx>
56#include <BOPTools_AlgoTools.hxx>
57#include <GeomAPI_ProjectPointOnCurve.hxx>
4e57c75e 58
7a76337e 59#include <algorithm>
60
4e57c75e 61//
62static
63 inline void ResetShape(const TopoDS_Shape& aS);
64
65static
66 inline void ResetShapes(const TopoDS_Shape& aS);
67
68static
69 void TotalShapes(const TopoDS_Shape& aS,
70 Standard_Integer& aNbS);
71
72static
73 Standard_Real ComputeParameter(const TopoDS_Vertex& aV,
74 const TopoDS_Edge& aE);
4e57c75e 75
b1d15f53 76static
77 void AddShapeAndSubShapes(const Standard_Integer nS,
78 const BOPDS_ShapeInfo& theSI,
79 BOPCol_MapOfInteger& theMI);
80
81static
82 void CollectEdges(const BOPDS_DS& theDS,
83 const Standard_Integer nF,
84 BOPCol_MapOfInteger& theMI);
85
4e57c75e 86//=======================================================================
87//function :
88//purpose :
89//=======================================================================
72e88cf7 90BOPDS_DS::BOPDS_DS()
4e57c75e 91:
92 myAllocator(NCollection_BaseAllocator::CommonBaseAllocator()),
93 myArguments(myAllocator),
94 myRanges(myAllocator),
95 myLines(myAllocator),
96 myMapShapeIndex(100, myAllocator),
97 myPaveBlocksPool(myAllocator),
5a77460e 98 myMapPBCB(100, myAllocator),
2f6cb3ac 99 myFaceInfoPool(myAllocator),
eafb234b 100 myShapesSD(100, myAllocator),
4e57c75e 101 myInterfTB(100, myAllocator),
102 myInterfVV(myAllocator),
103 myInterfVE(myAllocator),
104 myInterfVF(myAllocator),
105 myInterfEE(myAllocator),
106 myInterfEF(myAllocator),
ceaa5e27 107 myInterfFF(myAllocator),
108 myInterfVZ(myAllocator),
109 myInterfEZ(myAllocator),
110 myInterfFZ(myAllocator),
b1d15f53 111 myInterfZZ(myAllocator),
112 myFuzzyValue(0.),
113 myToleranceMap(100, myAllocator)
4e57c75e 114{
115 myNbShapes=0;
116 myNbSourceShapes=0;
117}
118//=======================================================================
119//function :
120//purpose :
121//=======================================================================
72e88cf7 122BOPDS_DS::BOPDS_DS(const Handle(NCollection_BaseAllocator)& theAllocator)
4e57c75e 123:
124 myAllocator(theAllocator),
125 myArguments(myAllocator),
126 myRanges(myAllocator),
127 myLines(myAllocator),
128 myMapShapeIndex(100, myAllocator),
129 myPaveBlocksPool(myAllocator),
5a77460e 130 myMapPBCB(100, myAllocator),
2f6cb3ac 131 myFaceInfoPool(myAllocator),
eafb234b 132 myShapesSD(100, myAllocator),
4e57c75e 133 myInterfTB(100, myAllocator),
134 myInterfVV(myAllocator),
135 myInterfVE(myAllocator),
136 myInterfVF(myAllocator),
137 myInterfEE(myAllocator),
138 myInterfEF(myAllocator),
ceaa5e27 139 myInterfFF(myAllocator),
140 myInterfVZ(myAllocator),
141 myInterfEZ(myAllocator),
142 myInterfFZ(myAllocator),
b1d15f53 143 myInterfZZ(myAllocator),
144 myFuzzyValue(0.),
145 myToleranceMap(100, myAllocator)
4e57c75e 146{
147 myNbShapes=0;
148 myNbSourceShapes=0;
149}
150//=======================================================================
151//function : ~
152//purpose :
153//=======================================================================
72e88cf7 154BOPDS_DS::~BOPDS_DS()
4e57c75e 155{
156 Clear();
157}
158//=======================================================================
159//function : Clear
160//purpose :
161//=======================================================================
72e88cf7 162void BOPDS_DS::Clear()
4e57c75e 163{
164 myNbShapes=0;
165 myNbSourceShapes=0;
b1d15f53 166 myFuzzyValue=0.;
4e57c75e 167 //
168 myArguments.Clear();
169 myRanges.Clear();
170 myLines.Clear();
171 myMapShapeIndex.Clear();
172 myPaveBlocksPool.Clear();
173 myFaceInfoPool.Clear();
174 myShapesSD.Clear();
5a77460e 175 myMapPBCB.Clear();
4e57c75e 176 myInterfTB.Clear();
177 myInterfVV.Clear();
178 myInterfVE.Clear();
179 myInterfVF.Clear();
180 myInterfEE.Clear();
181 myInterfEF.Clear();
182 myInterfFF.Clear();
ceaa5e27 183 myInterfVZ.Clear();
184 myInterfEZ.Clear();
185 myInterfFZ.Clear();
186 myInterfZZ.Clear();
b1d15f53 187 myToleranceMap.Clear();
4e57c75e 188}
189//=======================================================================
190//function : SetArguments
191//purpose :
192//=======================================================================
72e88cf7 193void BOPDS_DS::SetArguments(const BOPCol_ListOfShape& theLS)
4e57c75e 194{
195 myArguments=theLS;
196}
197//=======================================================================
198//function : Arguments
199//purpose :
200//=======================================================================
72e88cf7 201const BOPCol_ListOfShape& BOPDS_DS::Arguments()const
4e57c75e 202{
203 return myArguments;
204}
205//=======================================================================
206//function : Allocator
207//purpose :
208//=======================================================================
72e88cf7 209const Handle(NCollection_BaseAllocator)& BOPDS_DS::Allocator()const
4e57c75e 210{
211 return myAllocator;
212}
213
214//=======================================================================
215//function : NbShapes
216//purpose :
217//=======================================================================
72e88cf7 218Standard_Integer BOPDS_DS::NbShapes()const
4e57c75e 219{
220 return myLines.Size();
221}
222//=======================================================================
223//function : NbSourceShapes
224//purpose :
225//=======================================================================
72e88cf7 226Standard_Integer BOPDS_DS::NbSourceShapes()const
4e57c75e 227{
228 return myNbSourceShapes;
229}
230//=======================================================================
231//function : NbRanges
232//purpose :
233//=======================================================================
72e88cf7 234Standard_Integer BOPDS_DS::NbRanges()const
4e57c75e 235{
236 return myRanges.Size();
237}
238//=======================================================================
239//function : Range
240//purpose :
241//=======================================================================
72e88cf7 242const BOPDS_IndexRange& BOPDS_DS::Range(const Standard_Integer theI)const
4e57c75e 243{
244 return myRanges(theI);
245}
246//=======================================================================
247//function : Rank
248//purpose :
249//=======================================================================
72e88cf7 250Standard_Integer BOPDS_DS::Rank(const Standard_Integer theI)const
4e57c75e 251{
252 Standard_Integer i, aNb, iErr;
253 //
254 iErr=-1;
255 aNb=NbRanges();
256 for(i=0; i<aNb; ++i) {
257 const BOPDS_IndexRange& aR=Range(i);
258 if (aR.Contains(theI)) {
259 return i;
260 }
261 }
262 return iErr;
263}
264//=======================================================================
265//function : IsNewShape
266//purpose :
267//=======================================================================
72e88cf7 268Standard_Boolean BOPDS_DS::IsNewShape(const Standard_Integer theI)const
4e57c75e 269{
270 return theI>=NbSourceShapes();
271}
272//=======================================================================
273//function : Append
274//purpose :
275//=======================================================================
72e88cf7 276Standard_Integer BOPDS_DS::Append(const BOPDS_ShapeInfo& theSI)
4e57c75e 277{
278 Standard_Integer iX;
279 //
280 iX=myLines.Append()-1;
281 myLines(iX)=theSI;
282 return iX;
283}
284//=======================================================================
285//function : Append
286//purpose :
287//=======================================================================
72e88cf7 288Standard_Integer BOPDS_DS::Append(const TopoDS_Shape& theS)
4e57c75e 289{
290 Standard_Integer iX;
291 //
292 iX=myLines.Append()-1;
293 myLines(iX).SetShape(theS);
294 return iX;
295}
296//=======================================================================
297//function : ShapeInfo
298//purpose :
299//=======================================================================
362dec17 300const BOPDS_ShapeInfo& BOPDS_DS::ShapeInfo
301 (const Standard_Integer theI)const
4e57c75e 302{
303 return myLines(theI);
304}
305//=======================================================================
306//function : ChangeShapeInfo
307//purpose :
308//=======================================================================
72e88cf7 309BOPDS_ShapeInfo& BOPDS_DS::ChangeShapeInfo(const Standard_Integer theI)
4e57c75e 310{
311 BOPDS_ShapeInfo *pSI;
312 //
313 const BOPDS_ShapeInfo& aSI=ShapeInfo(theI);
314 pSI=(BOPDS_ShapeInfo *)&aSI;
315 return *pSI;
316}
317//=======================================================================
318//function : Shape
319//purpose :
320//=======================================================================
72e88cf7 321const TopoDS_Shape& BOPDS_DS::Shape(const Standard_Integer theI)const
4e57c75e 322{
323 const TopoDS_Shape& aS=ShapeInfo(theI).Shape();
324 return aS;
325}
326//=======================================================================
327//function : Index
328//purpose :
329//=======================================================================
72e88cf7 330Standard_Integer BOPDS_DS::Index(const TopoDS_Shape& theS)const
4e57c75e 331{
332 Standard_Integer iRet;
333 //
334 iRet=-1;
335 if (myMapShapeIndex.IsBound(theS)) {
336 iRet=myMapShapeIndex.Find(theS);
337 }
338 return iRet;
339}
340
341//=======================================================================
342//function : Init
343//purpose :
344//=======================================================================
72e88cf7 345void BOPDS_DS::Init()
4e57c75e 346{
362dec17 347 Standard_Integer i1, i2, j, aI, aNb, aNbS, aNbE, aNbSx;
348 Standard_Integer n1, n2, n3, nV, nW, nE, aNbF;
b1d15f53 349 Standard_Real aTol, aFuzz;
4e57c75e 350 TopAbs_ShapeEnum aTS;
50ba108c 351 TopoDS_Iterator aItS;
4e57c75e 352 BOPCol_ListIteratorOfListOfInteger aIt1, aIt2, aIt3;
353 BOPCol_ListIteratorOfListOfShape aIt;
354 BOPDS_IndexRange aR;
355 Handle(NCollection_IncAllocator) aAllocator;
356 //
357 // 1 Append Source Shapes
358 aNb=myArguments.Extent();
359 if (!aNb) {
360 return;
361 }
362 //
363 myRanges.SetStartSize(aNb);
364 myRanges.Init();
365 //
366 aIt.Initialize(myArguments);
367 for (; aIt.More(); aIt.Next()) {
368 const TopoDS_Shape& aSx=aIt.Value();
369 ResetShapes(aSx);
370 }
371 //
372 aNbS=0;
373 aIt.Initialize(myArguments);
374 for (; aIt.More(); aIt.Next()) {
375 const TopoDS_Shape& aSx=aIt.Value();
376 //
377 aNbSx=0;
378 TotalShapes(aSx, aNbSx);
379 aNbS=aNbS+aNbSx;
380 }
381 //
382 myLines.SetStartSize(2*aNbS);
383 myLines.SetIncrement(aNbS);
384 myLines.Init();
385 //
386 //-----------------------------------------------------scope_1 f
387 aAllocator=new NCollection_IncAllocator();
388 //
389 BOPCol_DataMapOfShapeInteger& aMSI=myMapShapeIndex;
390 //
391 i1=0;
392 i2=0;
393 aIt.Initialize(myArguments);
394 for (; aIt.More(); aIt.Next()) {
395 const TopoDS_Shape& aS=aIt.Value();
72e88cf7 396 if (aMSI.IsBound(aS)) {
397 continue;
398 }
4e57c75e 399 aI=Append(aS);
400 aMSI.Bind(aS, aI);
401 //
402 InitShape(aI, aS, aAllocator, aMSI);
403 //
404 i2=NbShapes()-1;
405 aR.SetIndices(i1, i2);
406 myRanges.Append(aR);
407 i1=i2+1;
408 }
409 //
b1d15f53 410 aFuzz = myFuzzyValue / 2.;
4e57c75e 411 myNbSourceShapes=NbShapes();
412 //
413 // 2 Bounding Boxes
414 //
415 // 2.1 Vertex
416 for (j=0; j<myNbSourceShapes; ++j) {
417 BOPDS_ShapeInfo& aSI=ChangeShapeInfo(j);
418 //
419 const TopoDS_Shape& aS=aSI.Shape();
420 ResetShape(aS);
421 //
422 aTS=aSI.ShapeType();
423 //
424 if (aTS==TopAbs_VERTEX) {
425 Bnd_Box& aBox=aSI.ChangeBox();
426 const TopoDS_Vertex& aV=*((TopoDS_Vertex*)&aS);
427 const gp_Pnt& aP=BRep_Tool::Pnt(aV);
b1d15f53 428 //
429 const Handle(BRep_TVertex)& TV =
430 *((Handle(BRep_TVertex)*)&aV.TShape());
431 aTol = TV->Tolerance();
432 //
433 myToleranceMap.Bind(j, aTol);
434 aTol += aFuzz;
435 TV->Tolerance(aTol);
436 //
4e57c75e 437 aBox.SetGap(aTol);
438 aBox.Add(aP);
439 }
440 }
441 // 2.2 Edge
442 aNbE=0;
443 for (j=0; j<myNbSourceShapes; ++j) {
444 BOPDS_ShapeInfo& aSI=ChangeShapeInfo(j);
445 //
446 aTS=aSI.ShapeType();
447 if (aTS==TopAbs_EDGE) {
448 const TopoDS_Shape& aS=aSI.Shape();
449 const TopoDS_Edge& aE=*((TopoDS_Edge*)&aS);
b1d15f53 450 //
451 const Handle(BRep_TEdge)& TE =
452 *((Handle(BRep_TEdge)*)&aE.TShape());
453 aTol = TE->Tolerance();
454 //
455 myToleranceMap.Bind(j, aTol);
456 aTol += aFuzz;
457 TE->Tolerance(aTol);
4e57c75e 458 //
459 if (!BRep_Tool::Degenerated(aE)) {
460 Standard_Boolean bInf1, bInf2;
461 Standard_Integer aIx;
462 Standard_Real aT1, aT2;
463 gp_Pnt aPx;
464 Handle(Geom_Curve) aC3D;
465 TopoDS_Vertex aVx;
466 TopoDS_Edge aEx;
467 BRep_Builder aBB;
468 BOPDS_ShapeInfo aSIx;
469 //
470 BOPCol_ListOfInteger& aLI=aSI.ChangeSubShapes();
471 //
472 aEx=aE;
473 aEx.Orientation(TopAbs_FORWARD);
474 //
475 aC3D=BRep_Tool::Curve (aEx, aT1, aT2);
476 bInf1=Precision::IsNegativeInfinite(aT1);
477 bInf2=Precision::IsPositiveInfinite(aT2);
478 //
479 if (bInf1) {
480 aC3D->D0(aT1, aPx);
481 aBB.MakeVertex(aVx, aPx, aTol);
482 aVx.Orientation(TopAbs_FORWARD);
483 //
484 aSIx.SetShape(aVx);
485 aSIx.SetShapeType(TopAbs_VERTEX);
486 aSIx.SetFlag(1); //infinite flag
487 //
488 aIx=Append(aSIx);
489 aLI.Append(aIx);
490 }
491 if (bInf2) {
492 aC3D->D0(aT2, aPx);
493 aBB.MakeVertex(aVx, aPx, aTol);
494 aVx.Orientation(TopAbs_REVERSED);
495 //
496 aSIx.SetShape(aVx);
497 aSIx.SetShapeType(TopAbs_VERTEX);
498 aSIx.SetFlag(1);//infinite flag
499 //
500 aIx=Append(aSIx);
501 aLI.Append(aIx);
502 }
503 }
504 else {
505 aSI.SetFlag(j);
506 }
507 //
508 Bnd_Box& aBox=aSI.ChangeBox();
509 BRepBndLib::Add(aE, aBox);
510 //
511 const BOPCol_ListOfInteger& aLV=aSI.SubShapes();
512 aIt1.Initialize(aLV);
513 for (; aIt1.More(); aIt1.Next()) {
514 nV=aIt1.Value();
515 BOPDS_ShapeInfo& aSIV=ChangeShapeInfo(nV);
516 Bnd_Box& aBx=aSIV.ChangeBox();
517 aBox.Add(aBx);
518 }
519 ++aNbE;
520 }
521 }
522 // 2.3 Face
523 BOPCol_MapOfInteger aMI(100, aAllocator);
524 BOPCol_MapIteratorOfMapOfInteger aItMI;
525 //
526 aNbF=0;
527 for (j=0; j<myNbSourceShapes; ++j) {
528 BOPDS_ShapeInfo& aSI=ChangeShapeInfo(j);
529 //
530 aTS=aSI.ShapeType();
531 if (aTS==TopAbs_FACE) {
532 const TopoDS_Shape& aS=aSI.Shape();
533 const TopoDS_Face& aF=*((TopoDS_Face*)&aS);
b1d15f53 534 //
535 const Handle(BRep_TFace)& TF =
536 *((Handle(BRep_TFace)*)&aF.TShape());
537 aTol = TF->Tolerance();
538 //
539 myToleranceMap.Bind(j, aTol);
540 aTol += aFuzz;
541 TF->Tolerance(aTol);
4e57c75e 542 //
543 Bnd_Box& aBox=aSI.ChangeBox();
544 BRepBndLib::Add(aS, aBox);
545 //
546 BOPCol_ListOfInteger& aLW=aSI.ChangeSubShapes();
547 aIt1.Initialize(aLW);
548 for (; aIt1.More(); aIt1.Next()) {
549 nW=aIt1.Value();
550 BOPDS_ShapeInfo& aSIW=ChangeShapeInfo(nW);
551 //
552 const BOPCol_ListOfInteger& aLE=aSIW.SubShapes();
553 aIt2.Initialize(aLE);
554 for (; aIt2.More(); aIt2.Next()) {
555 nE=aIt2.Value();
556 BOPDS_ShapeInfo& aSIE=ChangeShapeInfo(nE);
557 Bnd_Box& aBx=aSIE.ChangeBox();
558 aBox.Add(aBx);
559 aMI.Add(nE);
560 //
561 const TopoDS_Edge& aE=*(TopoDS_Edge*)(&aSIE.Shape());
562 if (BRep_Tool::Degenerated(aE)) {
563 aSIE.SetFlag(j);
564 }
565 //
566 const BOPCol_ListOfInteger& aLV=aSIE.SubShapes();
567 aIt3.Initialize(aLV);
568 for (; aIt3.More(); aIt3.Next()) {
569 nV=aIt3.Value();
570 aMI.Add(nV);
571 }
572 }
573 }//for (; aIt1.More(); aIt1.Next()) {
574 //
50ba108c 575 // pure internal vertices on the face
576 aItS.Initialize(aS);
577 for (; aItS.More(); aItS.Next()) {
362dec17 578 const TopoDS_Shape& aSx=aItS.Value();
579 if (aSx.ShapeType()==TopAbs_VERTEX){
580 nV=Index(aSx);
581 aMI.Add(nV);
582 }
50ba108c 583 }
584 //
4e57c75e 585 //
586 // For a Face: change wires for BRep sub-shapes
587 aLW.Clear();
588 aItMI.Initialize(aMI);
589 for (; aItMI.More(); aItMI.Next()) {
590 nV=aItMI.Value();
591 aLW.Append(nV);
592 }
593 aMI.Clear();
594 ++aNbF;
595 }//if (aTS==TopAbs_FACE) {
596 }//for (j=0; j<myNbSourceShapes; ++j) {
597 //
30ecd5f8 598 // 2.4 Solids
599 for (j=0; j<myNbSourceShapes; ++j) {
600 BOPDS_ShapeInfo& aSI=ChangeShapeInfo(j);
601 //
602 aTS=aSI.ShapeType();
ceaa5e27 603 if (aTS!=TopAbs_SOLID) {
604 continue;
605 }
606 Bnd_Box& aBox=aSI.ChangeBox();
607 BuildBndBoxSolid(j, aBox);
608 //
609 //
610 // update sub-shapes by BRep comprising ones
611 aMI.Clear();
612 BOPCol_ListOfInteger& aLI1=aSI.ChangeSubShapes();
613 //
614 aIt1.Initialize(aLI1);
615 for (; aIt1.More(); aIt1.Next()) {
616 n1=aIt1.Value();
617 BOPDS_ShapeInfo& aSI1=ChangeShapeInfo(n1);
618 if (aSI1.ShapeType()!=TopAbs_SHELL) {
362dec17 619 continue;
ceaa5e27 620 }
621 //
622 const BOPCol_ListOfInteger& aLI2=aSI1.SubShapes();
623 aIt2.Initialize(aLI2);
624 for (; aIt2.More(); aIt2.Next()) {
362dec17 625 n2=aIt2.Value();
626 BOPDS_ShapeInfo& aSI2=ChangeShapeInfo(n2);
627 if (aSI2.ShapeType()!=TopAbs_FACE) {
628 continue;
629 }
630 //
631 aMI.Add(n2);
632 //
633 const BOPCol_ListOfInteger& aLI3=aSI2.SubShapes();
634 aIt3.Initialize(aLI3);
635 for (; aIt3.More(); aIt3.Next()) {
636 n3=aIt3.Value();
637 aMI.Add(n3);
638 }
ceaa5e27 639 }
30ecd5f8 640 }
ceaa5e27 641 //
642 aLI1.Clear();
643 aItMI.Initialize(aMI);
644 for (; aItMI.More(); aItMI.Next()) {
645 n1=aItMI.Value();
646 aLI1.Append(n1);
647 }
648 aMI.Clear();
30ecd5f8 649 }//for (j=0; j<myNbSourceShapes; ++j) {
650 //
4e57c75e 651 aMI.Clear();
652 aAllocator.Nullify();
653 //-----------------------------------------------------scope_1 t
654 //
655 // 3 myPaveBlocksPool
656 myPaveBlocksPool.SetStartSize(aNbE);
657 myPaveBlocksPool.SetIncrement(aNbE);
658 myPaveBlocksPool.Init();
659 //
660 // 4. myFaceInfoPool
661 myFaceInfoPool.SetStartSize(aNbF);
662 myFaceInfoPool.SetIncrement(aNbF);
663 myFaceInfoPool.Init();
664 //
665}
666//=======================================================================
667//function : InitShape
668//purpose :
669//=======================================================================
362dec17 670void BOPDS_DS::InitShape
671 (const Standard_Integer aI,
672 const TopoDS_Shape& aS,
673 Handle(NCollection_BaseAllocator)& theAllocator,
674 BOPCol_DataMapOfShapeInteger& aMSI)
4e57c75e 675{
676 Standard_Integer aIx;
677 TopoDS_Iterator aIt;
678 BOPCol_ListIteratorOfListOfInteger aIt1;
679 //
680 BOPDS_ShapeInfo& aSI=ChangeShapeInfo(aI);
681 aSI.SetShapeType(aS.ShapeType());
682 BOPCol_ListOfInteger& aLI=aSI.ChangeSubShapes();
683 //
684 BOPCol_MapOfInteger aM(100, theAllocator);
685 //
686 aIt1.Initialize(aLI);
687 for (; aIt1.More(); aIt1.Next()) {
688 aM.Add(aIt1.Value());
689 }
690 //
691 aIt.Initialize(aS);
692 for (; aIt.More(); aIt.Next()) {
693 const TopoDS_Shape& aSx=aIt.Value();
694 if (aMSI.IsBound(aSx)) {
695 aIx=aMSI.Find(aSx);
696 }
697 else {
698 aIx=Append(aSx);
699 aMSI.Bind(aSx, aIx);
700 }
701 //
702 InitShape(aIx, aSx, theAllocator, aMSI);
703 //
704 if (aM.Add(aIx)) {
705 aLI.Append(aIx);
706 }
707 }
708}
709
710//=======================================================================
711//function : HasInterf
712//purpose :
713//=======================================================================
72e88cf7 714Standard_Boolean BOPDS_DS::HasInterf(const Standard_Integer theI) const
4e57c75e 715{
716 Standard_Integer n1, n2;
717 Standard_Boolean bRet;
718 BOPDS_MapIteratorMapOfPassKey aIt;
719 //
720 bRet = Standard_False;
721 //
722 aIt.Initialize(myInterfTB);
723 for (; aIt.More(); aIt.Next()) {
724 const BOPDS_PassKey& aPK = aIt.Value();
725 aPK.Ids(n1, n2);
726 if (n1 == theI || n2 == theI) {
727 bRet = Standard_True;
728 break;
729 }
730 }
731 //
732 return bRet;
733}
4e57c75e 734//=======================================================================
735//function : HasInterfShapeSubShapes
736//purpose :
737//=======================================================================
ceaa5e27 738Standard_Boolean BOPDS_DS::HasInterfShapeSubShapes
739 (const Standard_Integer theI1,
740 const Standard_Integer theI2,
741 const Standard_Boolean theFlag)const
4e57c75e 742{
743 Standard_Boolean bRet;
744 Standard_Integer n2;
745 BOPCol_ListIteratorOfListOfInteger aIt;
746 bRet = Standard_False;
747 //
748 const BOPDS_ShapeInfo& aSI=ShapeInfo(theI2);
749 const BOPCol_ListOfInteger& aLI=aSI.SubShapes();
750 aIt.Initialize(aLI);
751 for (; aIt.More(); aIt.Next()) {
752 n2=aIt.Value();
753 bRet=HasInterf(theI1, n2);
ceaa5e27 754 if (theFlag) {
755 if(bRet) {
b1d15f53 756 break;
ceaa5e27 757 }
758 }
759 else {
760 if(!bRet) {
b1d15f53 761 break;
ceaa5e27 762 }
4e57c75e 763 }
764 }
765 return bRet;
766}
4e57c75e 767//=======================================================================
768//function : HasInterfSubShapes
769//purpose :
770//=======================================================================
362dec17 771Standard_Boolean BOPDS_DS::HasInterfSubShapes
772 (const Standard_Integer theI1,
773 const Standard_Integer theI2)const
4e57c75e 774{
775 Standard_Boolean bRet;
776 Standard_Integer n1;
777 BOPCol_ListIteratorOfListOfInteger aIt;
778 bRet = Standard_False;
779 //
780 const BOPDS_ShapeInfo& aSI=ShapeInfo(theI1);
781 const BOPCol_ListOfInteger& aLI=aSI.SubShapes();
782 aIt.Initialize(aLI);
783 for (; aIt.More(); aIt.Next()) {
784 n1=aIt.Value();
785 bRet=HasInterfShapeSubShapes(n1, theI2);
786 if(bRet) {
787 break;
788 }
789 }
790 return bRet;
791}
792//
793// PaveBlocks
794//=======================================================================
795//function : PaveBlocksPool
796//purpose :
797//=======================================================================
72e88cf7 798const BOPDS_VectorOfListOfPaveBlock& BOPDS_DS::PaveBlocksPool()const
4e57c75e 799{
800 return myPaveBlocksPool;
801}
802//=======================================================================
803//function : ChangePaveBlocksPool
804//purpose :
805//=======================================================================
72e88cf7 806BOPDS_VectorOfListOfPaveBlock& BOPDS_DS::ChangePaveBlocksPool()
4e57c75e 807{
808 return myPaveBlocksPool;
809}
810//=======================================================================
811//function : HasPaveBlocks
812//purpose :
813//=======================================================================
72e88cf7 814Standard_Boolean BOPDS_DS::HasPaveBlocks(const Standard_Integer theI)const
4e57c75e 815{
816 return ShapeInfo(theI).HasReference();
817}
818//=======================================================================
819//function : PaveBlocks
820//purpose :
821//=======================================================================
362dec17 822const BOPDS_ListOfPaveBlock& BOPDS_DS::PaveBlocks
823 (const Standard_Integer theI)const
4e57c75e 824{
825 static BOPDS_ListOfPaveBlock sLPB;
826 Standard_Integer aRef;
827 //
828 if (HasPaveBlocks(theI)) {
829 aRef=ShapeInfo(theI).Reference();
830 const BOPDS_ListOfPaveBlock& aLPB=myPaveBlocksPool(aRef);
831 return aLPB;
832 }
833 return sLPB;
834}
835//=======================================================================
836//function : ChangePaveBlocks
837//purpose :
838//=======================================================================
362dec17 839BOPDS_ListOfPaveBlock& BOPDS_DS::ChangePaveBlocks
840 (const Standard_Integer theI)
4e57c75e 841{
842 Standard_Boolean bHasReference;
843 Standard_Integer aRef;
4e57c75e 844 //
845 BOPDS_ShapeInfo& aSI=ChangeShapeInfo(theI);
846 bHasReference=aSI.HasReference();
847 if (!bHasReference) {
848 InitPaveBlocks(theI);
849 }
850 //
851 aRef=aSI.Reference();
323c04de 852 return myPaveBlocksPool(aRef);
4e57c75e 853}
854//=======================================================================
855//function : InitPaveBlocks
856//purpose :
857//=======================================================================
72e88cf7 858void BOPDS_DS::InitPaveBlocks(const Standard_Integer theI)
4e57c75e 859{
59427cbc 860 Standard_Integer nV=0, iRef, aNbV, nVSD;
4e57c75e 861 Standard_Real aT;
59427cbc 862 TopAbs_Orientation aOrE;
4e57c75e 863 TopoDS_Vertex aV;
864 BOPCol_ListIteratorOfListOfInteger aIt;
865 BOPDS_Pave aPave;
866 Handle(BOPDS_PaveBlock) aPB;
867 //
868 BOPDS_ShapeInfo& aSI=ChangeShapeInfo(theI);
869 const TopoDS_Edge& aE=*(TopoDS_Edge*)(&aSI.Shape());
59427cbc 870 aOrE=aE.Orientation();
4e57c75e 871 //
872 const BOPCol_ListOfInteger& aLV=aSI.SubShapes();
873 aNbV=aLV.Extent();
874 if (!aNbV) {
875 return;
876 }
877 //
878 aPB=new BOPDS_PaveBlock;
879 aPB->SetOriginalEdge(theI);
880 //
59427cbc 881 if (aOrE!=TopAbs_INTERNAL) {
882 aIt.Initialize(aLV);
883 for (; aIt.More(); aIt.Next()) {
884 nV=aIt.Value();
885 //
886 const BOPDS_ShapeInfo& aSIV=ShapeInfo(nV);
887 aV=*(TopoDS_Vertex*)(&aSIV.Shape());
888 if (aSIV.HasFlag()) {
889 aT=ComputeParameter(aV, aE);
890 }
891 else {
892 aT=BRep_Tool::Parameter(aV, aE);
893 }
894 //
895 if (HasShapeSD(nV, nVSD)) {
896 nV=nVSD;
897 }
898 aPave.SetIndex(nV);
899 aPave.SetParameter(aT);
900 aPB->AppendExtPave(aPave);
4e57c75e 901 }
4e57c75e 902 //
59427cbc 903 if (aNbV==1) {
904 aV.Reverse();
905 aT=BRep_Tool::Parameter(aV, aE);
906 aPave.SetIndex(nV);
907 aPave.SetParameter(aT);
908 aPB->AppendExtPave1(aPave);
4e57c75e 909 }
4e57c75e 910 }
911 //
59427cbc 912 else {
913 TopoDS_Iterator aItE;
914 //
915 aItE.Initialize(aE, Standard_False, Standard_True);
916 for (; aItE.More(); aItE.Next()) {
917 aV=*((TopoDS_Vertex*)&aItE.Value());
918 nV=Index(aV);
2a2e3ecd 919 //
920 const BOPDS_ShapeInfo& aSIV=ShapeInfo(nV);
921 if (aSIV.HasFlag()) {
922 aT=ComputeParameter(aV, aE);
923 }
924 else {
925 aT=BRep_Tool::Parameter(aV, aE);
926 }
927 //
928 if (HasShapeSD(nV, nVSD)) {
929 nV=nVSD;
930 }
59427cbc 931 aPave.SetIndex(nV);
932 aPave.SetParameter(aT);
933 aPB->AppendExtPave1(aPave);
934 }
4e57c75e 935 }
936 //
323c04de 937 iRef = myPaveBlocksPool.Append() - 1;
4e57c75e 938 BOPDS_ListOfPaveBlock &aLPB=myPaveBlocksPool(iRef);
939 //
940 aPB->Update(aLPB, Standard_False);
4e57c75e 941 aSI.SetReference(iRef);
942}
943//=======================================================================
944//function : UpdatePaveBlocks
945//purpose :
946//=======================================================================
72e88cf7 947void BOPDS_DS::UpdatePaveBlocks()
4e57c75e 948{
949 Standard_Boolean bIsToUpdate;
950 Standard_Integer i, aNbPBP;
951 BOPDS_ListOfPaveBlock aLPBN(myAllocator);
952 BOPDS_ListIteratorOfListOfPaveBlock aItPB, aItPBN;
953 //
954 BOPDS_VectorOfListOfPaveBlock& aPBP=myPaveBlocksPool;
955 //
956 aNbPBP=aPBP.Size();
957 for (i=0; i<aNbPBP; ++i) {
958 BOPDS_ListOfPaveBlock& aLPB=aPBP(i);
959 //
960 aItPB.Initialize(aLPB);
961 for (; aItPB.More(); aItPB.Next()) {
962 Handle(BOPDS_PaveBlock)& aPB=aItPB.ChangeValue();
963 //
964 bIsToUpdate=aPB->IsToUpdate();
965 if (bIsToUpdate){
966 aLPBN.Clear();
967 aPB->Update(aLPBN);
968
969 aItPBN.Initialize(aLPBN);
970 for (; aItPBN.More(); aItPBN.Next()) {
971 Handle(BOPDS_PaveBlock)& aPBN=aItPBN.ChangeValue();
972 aLPB.Append(aPBN);
973 }
974 aLPB.Remove(aItPB);
975 }
976 }// for (; aItPB.More(); aItPB.Next()) {
977 }// for (i=0; i<aNbPBP; ++i) {
978}
979//=======================================================================
980//function : UpdatePaveBlock
981//purpose :
982//=======================================================================
72e88cf7 983void BOPDS_DS::UpdatePaveBlock(const Handle(BOPDS_PaveBlock)& thePB)
4e57c75e 984{
985 if (!thePB->IsToUpdate()){
986 return;
987 }
988 //
989 Standard_Integer nE, iRef;
990 BOPDS_ListIteratorOfListOfPaveBlock aItPB, aItPBN;
991 BOPDS_ListOfPaveBlock aLPBN(myAllocator);
992 Handle(BOPDS_PaveBlock) aPB;
993 //
994 BOPDS_VectorOfListOfPaveBlock& aPBP=myPaveBlocksPool;
995 //
996 nE=thePB->OriginalEdge();
997 BOPDS_ShapeInfo& aSI=ChangeShapeInfo(nE);
998 iRef=aSI.Reference();
999 BOPDS_ListOfPaveBlock& aLPB=aPBP(iRef);
1000 //
1001 aItPB.Initialize(aLPB);
1002 for (; aItPB.More(); aItPB.Next()) {
1003 aPB=aItPB.ChangeValue();
1004 if (aPB==thePB) {
1005 aPB->Update(aLPBN);
1006 //
1007 aItPBN.Initialize(aLPBN);
1008 for (; aItPBN.More(); aItPBN.Next()) {
1009 Handle(BOPDS_PaveBlock)& aPBN=aItPBN.ChangeValue();
1010 aLPB.Append(aPBN);
1011 }
1012 aLPB.Remove(aItPB);
1013 break;
1014 }
1015 }
1016}
1017//=======================================================================
1018//function : UpdateCommonBlock
1019//purpose :
1020//=======================================================================
72e88cf7 1021void BOPDS_DS::UpdateCommonBlock(const Handle(BOPDS_CommonBlock)& theCB)
4e57c75e 1022{
1023 Standard_Integer nE, iRef, n1, n2;
1024 BOPDS_ListIteratorOfListOfPaveBlock aItPB, aItPBCB, aItPBN;
1025 BOPDS_DataMapIteratorOfDataMapOfPassKeyListOfPaveBlock aItMPKLPB;
1026 BOPDS_ListOfPaveBlock aLPBN;
1027 BOPDS_DataMapOfPassKeyListOfPaveBlock aMPKLPB;
1028 Handle(BOPDS_PaveBlock) aPB;
1029 Handle(BOPDS_CommonBlock) aCBx;
1030 BOPDS_PassKey aPK;
1031 //
1032 const BOPDS_ListOfPaveBlock& aLPBCB=theCB->PaveBlocks();
1033 if (!aLPBCB.First()->IsToUpdate()){
1034 return;
1035 }
1036 //
1037 const BOPCol_ListOfInteger& aLF=theCB->Faces();
1038 //
1039 BOPDS_VectorOfListOfPaveBlock& aPBP=myPaveBlocksPool;
1040 //
1041 aItPBCB.Initialize(aLPBCB);
1042 for (; aItPBCB.More(); aItPBCB.Next()) {
1043 const Handle(BOPDS_PaveBlock)& aPBCB=aItPBCB.ChangeValue();
1044 //
1045 nE=aPBCB->OriginalEdge();
1046 iRef=ChangeShapeInfo(nE).Reference();
1047 BOPDS_ListOfPaveBlock& aLPB=aPBP(iRef);
1048 //
1049 aItPB.Initialize(aLPB);
1050 for (; aItPB.More(); aItPB.Next()) {
1051 aPB=aItPB.ChangeValue();
1052 if (aPB==aPBCB) {
1053 //
1054 aLPBN.Clear();
1055 aPB->Update(aLPBN);
1056 //
1057 aItPBN.Initialize(aLPBN);
1058 for (; aItPBN.More(); aItPBN.Next()) {
1059 Handle(BOPDS_PaveBlock)& aPBN=aItPBN.ChangeValue();
1060 aLPB.Append(aPBN);
1061 //
1062 aPBN->Indices(n1, n2);
1063 aPK.SetIds(n1, n2);
1064 if (aMPKLPB.IsBound(aPK)) {
1065 BOPDS_ListOfPaveBlock& aLPBx=aMPKLPB.ChangeFind(aPK);
1066 aLPBx.Append(aPBN);
1067 }
1068 else {
1069 BOPDS_ListOfPaveBlock aLPBx;
1070 aLPBx.Append(aPBN);
1071 aMPKLPB.Bind(aPK, aLPBx);
1072 }
1073 }
1074 aLPB.Remove(aItPB);
1075 break;
1076 }
1077 }
1078 }
1079 //
1080 aItMPKLPB.Initialize(aMPKLPB);
1081 for (; aItMPKLPB.More(); aItMPKLPB.Next()) {
1082 BOPDS_ListOfPaveBlock& aLPBx=aItMPKLPB.ChangeValue();
1083 //
1084 while (aLPBx.Extent()) {
1085 Standard_Boolean bCoinside;
1086 Standard_Real aTol, aTolMax(0.);
1087 BOPDS_ListOfPaveBlock aLPBxN;
1088 //
1089 aItPB.Initialize(aLPBx);
1090 for(; aItPB.More(); ) {
1091 const Handle(BOPDS_PaveBlock)& aPBx=aItPB.Value();
1092 if (aLPBxN.Extent()) {
1093 const Handle(BOPDS_PaveBlock)& aPBCx = aLPBxN.First();
1094 bCoinside = CheckCoincidence(aPBx, aPBCx);
1095 if (bCoinside) {
1096 nE = aPBx->OriginalEdge();
1097 const TopoDS_Edge& aE = *(TopoDS_Edge*)&Shape(nE);
1098 aTol = BRep_Tool::Tolerance(aE);
1099 //
1100 //pave block with the max tolerance of the original edge
1101 //must be the first in the common block
1102 if (aTolMax < aTol) {
1103 aTolMax = aTol;
1104 aLPBxN.Prepend(aPBx);
1105 } else {
1106 aLPBxN.Append(aPBx);
1107 }
1108 aLPBx.Remove(aItPB);
1109 continue;
1110 }//if (bCoinside) {
1111 }//if (aLPBxN.Extent()) {
1112 else {
1113 nE = aPBx->OriginalEdge();
1114 const TopoDS_Edge& aE = *(TopoDS_Edge*)&Shape(nE);
1115 aTolMax = BRep_Tool::Tolerance(aE);
1116 //
1117 aLPBxN.Append(aPBx);
1118 aLPBx.Remove(aItPB);
1119 continue;
1120 }
1121 aItPB.Next();
1122 }//for(; aItPB.More(); ) {
1123 //
1124 aCBx=new BOPDS_CommonBlock;
1125 aCBx->AddPaveBlocks(aLPBxN);
1126 aCBx->AddFaces(aLF);
1127 //
1128 aItPB.Initialize(aLPBxN);
1129 for (; aItPB.More(); aItPB.Next()) {
1130 aPB=aItPB.ChangeValue();
5a77460e 1131 SetCommonBlock(aPB, aCBx);
4e57c75e 1132 }
1133 }
1134 }
1135}
5a77460e 1136
1137//=======================================================================
1138// function: RealPaveBlock
1139// purpose:
1140//=======================================================================
72e88cf7 1141Handle(BOPDS_PaveBlock) BOPDS_DS::RealPaveBlock
5a77460e 1142 (const Handle(BOPDS_PaveBlock)& thePB) const
1143{
1144 if (IsCommonBlock(thePB)) {
1145 const Handle(BOPDS_CommonBlock)& aCB = CommonBlock(thePB);
1146 const Handle(BOPDS_PaveBlock)& aPB = aCB->PaveBlock1();
1147 return aPB;
1148 }
1149 return thePB;
1150}
1151
1152//=======================================================================
1153// function: IsCommonBlockOnEdge
1154// purpose:
1155//=======================================================================
72e88cf7 1156Standard_Boolean BOPDS_DS::IsCommonBlockOnEdge
5a77460e 1157 (const Handle(BOPDS_PaveBlock)& thePB) const
1158{
1159 if (IsCommonBlock(thePB)) {
1160 const Handle(BOPDS_CommonBlock)& aCB = CommonBlock(thePB);
1161 return aCB->PaveBlocks().Extent()>1;
1162 }
1163 return Standard_False;
1164}
1165
1166//=======================================================================
1167//function : IsCommonBlock
1168//purpose :
1169//=======================================================================
72e88cf7 1170Standard_Boolean BOPDS_DS::IsCommonBlock
5a77460e 1171 (const Handle(BOPDS_PaveBlock)& thePB) const
1172{
1173 return myMapPBCB.IsBound(thePB);
1174}
1175
1176//=======================================================================
1177//function : CommonBlock
1178//purpose :
1179//=======================================================================
819f58c7 1180Handle(BOPDS_CommonBlock) BOPDS_DS::CommonBlock
5a77460e 1181 (const Handle(BOPDS_PaveBlock)& thePB) const
1182{
819f58c7 1183 return (IsCommonBlock(thePB) ? myMapPBCB.Find(thePB) : NULL);
5a77460e 1184}
1185
1186//=======================================================================
1187//function : SetCommonBlock
1188//purpose :
1189//=======================================================================
72e88cf7 1190void BOPDS_DS::SetCommonBlock(const Handle(BOPDS_PaveBlock)& thePB,
362dec17 1191 const Handle(BOPDS_CommonBlock)& theCB)
5a77460e 1192{
1193 if (IsCommonBlock(thePB)) {
1194 Handle(BOPDS_CommonBlock)& aCB = myMapPBCB.ChangeFind(thePB);
1195 aCB=theCB;
1196 }
1197 else {
1198 myMapPBCB.Bind(thePB, theCB);
1199 }
1200}
1201
4e57c75e 1202//
1203// FaceInfo
1204//
1205
1206//=======================================================================
1207//function : FaceInfoPool
1208//purpose :
1209//=======================================================================
72e88cf7 1210const BOPDS_VectorOfFaceInfo& BOPDS_DS::FaceInfoPool()const
4e57c75e 1211{
1212 return myFaceInfoPool;
1213}
1214//=======================================================================
1215//function : HasFaceInfo
1216//purpose :
1217//=======================================================================
72e88cf7 1218Standard_Boolean BOPDS_DS::HasFaceInfo(const Standard_Integer theI)const
4e57c75e 1219{
1220 return ShapeInfo(theI).HasReference();
1221}
1222//=======================================================================
1223//function : FaceInfo
1224//purpose :
1225//=======================================================================
72e88cf7 1226const BOPDS_FaceInfo& BOPDS_DS::FaceInfo(const Standard_Integer theI)const
4e57c75e 1227{
1228 static BOPDS_FaceInfo sFI;
1229 Standard_Integer aRef;
1230 //
1231 if (HasFaceInfo(theI)) {
1232 aRef=ShapeInfo(theI).Reference();
1233 const BOPDS_FaceInfo& aFI=myFaceInfoPool(aRef);
1234 return aFI;
1235 }
1236 return sFI;
1237}
1238//=======================================================================
1239//function : ChangeFaceInfo
1240//purpose :
1241//=======================================================================
72e88cf7 1242BOPDS_FaceInfo& BOPDS_DS::ChangeFaceInfo(const Standard_Integer theI)
4e57c75e 1243{
1244 Standard_Boolean bHasReference;
1245 Standard_Integer aRef;
1246 BOPDS_FaceInfo* pFI;
1247 //
1248 BOPDS_ShapeInfo& aSI=ChangeShapeInfo(theI);
1249 bHasReference=aSI.HasReference();
1250 if (!bHasReference) {
1251 InitFaceInfo(theI);
1252 }
1253 //
1254 aRef=aSI.Reference();
1255 const BOPDS_FaceInfo& aFI=myFaceInfoPool(aRef);
1256 pFI=(BOPDS_FaceInfo*)&aFI;
1257 return *pFI;
1258}
1259//=======================================================================
1260//function : InitFaceInfo
1261//purpose :
1262//=======================================================================
72e88cf7 1263void BOPDS_DS::InitFaceInfo(const Standard_Integer theI)
4e57c75e 1264{
1265 Standard_Integer iRef;
1266 //
1267 BOPDS_ShapeInfo& aSI=ChangeShapeInfo(theI);
1268 iRef=myFaceInfoPool.Append()-1;
1269 BOPDS_FaceInfo &aFI=myFaceInfoPool(iRef);
1270 aSI.SetReference(iRef);
1271 //
1272 aFI.SetIndex(theI);
1273 UpdateFaceInfoIn(theI);
1274 UpdateFaceInfoOn(theI);
1275}
1276//=======================================================================
1277//function : UpdateFaceInfoIn
1278//purpose :
1279//=======================================================================
72e88cf7 1280void BOPDS_DS::UpdateFaceInfoIn(const Standard_Integer theI)
4e57c75e 1281{
1282 Standard_Integer iRef;
1283 //
1284 BOPDS_ShapeInfo& aSI=ChangeShapeInfo(theI);
1285 if (aSI.HasReference()) {
1286 iRef=aSI.Reference();
1287 BOPDS_FaceInfo &aFI=myFaceInfoPool(iRef);
1288 //
1289 BOPDS_IndexedMapOfPaveBlock& aMPBIn=aFI.ChangePaveBlocksIn();
1290 BOPCol_MapOfInteger& aMVIn=aFI.ChangeVerticesIn();
1291 aMPBIn.Clear();
1292 aMVIn.Clear();
1293 FaceInfoIn(theI, aMPBIn, aMVIn);
1294 }
1295}
1296//=======================================================================
1297//function : UpdateFaceInfoOn
1298//purpose :
1299//=======================================================================
72e88cf7 1300void BOPDS_DS::UpdateFaceInfoOn(const Standard_Integer theI)
4e57c75e 1301{
1302 Standard_Integer iRef;
1303 //
1304 BOPDS_ShapeInfo& aSI=ChangeShapeInfo(theI);
1305 if (aSI.HasReference()) {
1306 iRef=aSI.Reference();
1307 BOPDS_FaceInfo &aFI=myFaceInfoPool(iRef);
1308 //
1309 BOPDS_IndexedMapOfPaveBlock& aMPBOn=aFI.ChangePaveBlocksOn();
1310 BOPCol_MapOfInteger& aMVOn=aFI.ChangeVerticesOn();
1311 aMPBOn.Clear();
1312 aMVOn.Clear();
1313 FaceInfoOn(theI, aMPBOn, aMVOn);
1314 }
1315}
1316//=======================================================================
1317//function : FaceInfoOn
1318//purpose :
1319//=======================================================================
72e88cf7 1320void BOPDS_DS::FaceInfoOn(const Standard_Integer theF,
362dec17 1321 BOPDS_IndexedMapOfPaveBlock& theMPB,
1322 BOPCol_MapOfInteger& theMI)
4e57c75e 1323{
1324 Standard_Integer nS, nSD, nV1, nV2;
1325 BOPCol_ListIteratorOfListOfInteger aIt;
1326 BOPDS_ListIteratorOfListOfPaveBlock aItPB;
1327 //
1328 const BOPDS_ShapeInfo& aSI=ShapeInfo(theF);
1329 const BOPCol_ListOfInteger& aLI=aSI.SubShapes();
1330 aIt.Initialize(aLI);
1331 for (; aIt.More(); aIt.Next()) {
1332 nS=aIt.Value();
1333 const BOPDS_ShapeInfo& aSIE=ShapeInfo(nS);
1334 if (aSIE.ShapeType()==TopAbs_EDGE) {
1335 const BOPDS_ListOfPaveBlock& aLPB=PaveBlocks(nS);
1336 aItPB.Initialize(aLPB);
1337 for (; aItPB.More(); aItPB.Next()) {
1338 const Handle(BOPDS_PaveBlock)& aPB=aItPB.Value();
1339 aPB->Indices(nV1, nV2);
1340 theMI.Add(nV1);
1341 theMI.Add(nV2);
5a77460e 1342 Handle(BOPDS_PaveBlock) aPBR=RealPaveBlock(aPB);
1343 theMPB.Add(aPBR);
4e57c75e 1344 }
1345 }//if (aSIE.ShapeType()==TopAbs_EDGE)
1346 else {
1347 // nE is TopAbs_VERTEX
1348 if (HasShapeSD(nS, nSD)) {
1349 nS=nSD;
1350 }
1351 theMI.Add(nS);
1352 }
1353 }
1354}
1355//=======================================================================
1356//function : FaceInfoIn
1357//purpose :
1358//=======================================================================
72e88cf7 1359void BOPDS_DS::FaceInfoIn(const Standard_Integer theF,
362dec17 1360 BOPDS_IndexedMapOfPaveBlock& theMPB,
1361 BOPCol_MapOfInteger& theMI)
4e57c75e 1362{
50ba108c 1363 Standard_Integer i, aNbVF, aNbEF, nV, nE, nVSD;
1364 TopoDS_Iterator aItS;
4e57c75e 1365 BOPDS_ListIteratorOfListOfPaveBlock aItPB;
1366 //
50ba108c 1367 // 1. Pure internal vertices on the face
1368 const TopoDS_Shape& aF=Shape(theF);
1369 aItS.Initialize(aF);
1370 for (; aItS.More(); aItS.Next()) {
1371 const TopoDS_Shape& aSx=aItS.Value();
1372 if (aSx.ShapeType()==TopAbs_VERTEX){
1373 nV=Index(aSx);
1374 if (HasShapeSD(nV, nVSD)) {
362dec17 1375 nV=nVSD;
50ba108c 1376 }
1377 theMI.Add(nV);
1378 }
1379 }
1380 //
1381 // 2. aVFs
4e57c75e 1382 BOPDS_VectorOfInterfVF& aVFs=InterfVF();
1383 aNbVF=aVFs.Extent();
1384 for (i=0; i<aNbVF; ++i) {
1385 BOPDS_InterfVF& aVF=aVFs(i);
1386 if(aVF.Contains(theF)) {
1387 nV=aVF.OppositeIndex(theF);
1388 theMI.Add(nV);
1389 }
1390 }
1391 //
50ba108c 1392 // 3. aEFs
4e57c75e 1393 BOPDS_VectorOfInterfEF& aEFs=InterfEF();
1394 aNbEF=aEFs.Extent();
1395 for (i=0; i<aNbEF; ++i) {
1396 BOPDS_InterfEF& aEF=aEFs(i);
1397 if(aEF.Contains(theF)) {
1398 if(aEF.HasIndexNew(nV)) {
1399 theMI.Add(nV);
1400 }
1401 else {
1402 nE=aEF.OppositeIndex(theF);
1403 const BOPDS_ListOfPaveBlock& aLPB=PaveBlocks(nE);
1404 aItPB.Initialize(aLPB);
1405 for (; aItPB.More(); aItPB.Next()) {
1406 const Handle(BOPDS_PaveBlock)& aPB=aItPB.Value();
5a77460e 1407 if (IsCommonBlock(aPB)) {
1408 const Handle(BOPDS_CommonBlock)& aCB=CommonBlock(aPB);
4e57c75e 1409 if (aCB->Contains(theF)) {
1410 const Handle(BOPDS_PaveBlock)& aPB1=aCB->PaveBlock1();
1411 theMPB.Add(aPB1);
1412 }
1413 }
1414 }// for (; aItPB.More(); aItPB.Next()) {
1415 }// else {
1416 }// if(aEF.Contains(theF)) {
1417 }// for (i=0; i<aNbEF; ++i) {
1418}
1419
1420//=======================================================================
1421//function : RefineFaceInfoOn
1422//purpose :
1423//=======================================================================
72e88cf7 1424void BOPDS_DS::RefineFaceInfoOn()
4e57c75e 1425{
1426 Standard_Integer i, aNb, nF, aNbPB, j;
1427 BOPDS_IndexedMapOfPaveBlock aMPB;
1428 //
1429 aNb=myFaceInfoPool.Extent();
1430 for (i=0; i<aNb; ++i) {
1431 BOPDS_FaceInfo &aFI=myFaceInfoPool(i);
1432 nF=aFI.Index();
1433 UpdateFaceInfoOn(nF);
1434 BOPDS_IndexedMapOfPaveBlock& aMPBOn=aFI.ChangePaveBlocksOn();
1435 //
1436 aMPB.Clear();
1437 aMPB.Assign(aMPBOn);
1438 aMPBOn.Clear();
1439 //
1440 aNbPB=aMPB.Extent();
1441 for (j=1; j<=aNbPB; ++j) {
1442 const Handle(BOPDS_PaveBlock)& aPB=aMPB(j);
1443 if (aPB->HasEdge()) {
1444 aMPBOn.Add(aPB);
1445 }
1446 }
1447 }
1448}
1449//=======================================================================
1450//function : AloneVertices
1451//purpose :
1452//=======================================================================
72e88cf7 1453void BOPDS_DS::AloneVertices(const Standard_Integer theI,
362dec17 1454 BOPCol_ListOfInteger& theLI)const
4e57c75e 1455{
1456 if (HasFaceInfo(theI)) {
1457 //
1458 Standard_Integer i, nV1, nV2, nV;
1459 BOPDS_MapIteratorOfMapOfPaveBlock aItMPB;
1460 BOPCol_MapIteratorOfMapOfInteger aItMI;
1461 //
1462 BOPCol_MapOfInteger aMI(100, myAllocator);
1463 //
1464 const BOPDS_FaceInfo& aFI=FaceInfo(theI);
1465 //
1466 for (i=0; i<2; ++i) {
362dec17 1467 const BOPDS_IndexedMapOfPaveBlock& aMPB=
1468 (!i) ? aFI.PaveBlocksIn() : aFI.PaveBlocksSc();
4e57c75e 1469 aItMPB.Initialize(aMPB);
1470 for (; aItMPB.More(); aItMPB.Next()) {
1471 const Handle(BOPDS_PaveBlock)& aPB=aItMPB.Value();
1472 aPB->Indices(nV1, nV2);
1473 aMI.Add(nV1);
1474 aMI.Add(nV2);
1475 }
1476 }
1477 //
1478 for (i=0; i<2; ++i) {
362dec17 1479 const BOPCol_MapOfInteger& aMIV=
1480 (!i) ? aFI.VerticesIn() : aFI.VerticesSc();
4e57c75e 1481 aItMI.Initialize(aMIV);
1482 for (; aItMI.More(); aItMI.Next()) {
1483 nV=aItMI.Value();
362dec17 1484 if (nV>=0) {
4e57c75e 1485 if (aMI.Add(nV)) {
1486 theLI.Append(nV);
1487 }
1488 }
1489 }
1490 }
1491 }
1492}
4e57c75e 1493//=======================================================================
1494//function : VerticesOnIn
1495//purpose :
1496//=======================================================================
362dec17 1497void BOPDS_DS::VerticesOnIn
1498 (const Standard_Integer nF1,
1499 const Standard_Integer nF2,
1500 BOPCol_MapOfInteger& aMI,
decdfc94 1501 BOPDS_IndexedMapOfPaveBlock& aMPB)const
4e57c75e 1502{
decdfc94 1503 Standard_Integer i, j, nV, nV1, nV2, aNbPB;
4e57c75e 1504 BOPCol_MapIteratorOfMapOfInteger aIt;
decdfc94 1505 BOPDS_IndexedMapOfPaveBlock pMPB[4];
4e57c75e 1506 //
1507 const BOPDS_FaceInfo& aFI1=FaceInfo(nF1);
1508 const BOPDS_FaceInfo& aFI2=FaceInfo(nF2);
1509 //
decdfc94 1510 pMPB[0]=aFI1.PaveBlocksOn();
1511 pMPB[1]=aFI1.PaveBlocksIn();
1512 pMPB[2]=aFI2.PaveBlocksOn();
1513 pMPB[3]=aFI2.PaveBlocksIn();
1da6ad32 1514 //
1515 for (i=0; i<4; ++i) {
decdfc94 1516 aNbPB = pMPB[i].Extent();
1517 for (j = 1; j <= aNbPB; ++j) {
1518 const Handle(BOPDS_PaveBlock)& aPB = pMPB[i](j);
1da6ad32 1519 aMPB.Add(aPB);
1520 aPB->Indices(nV1, nV2);
1521 aMI.Add(nV1);
1522 aMI.Add(nV2);
1523 }
4e57c75e 1524 }
1525 //
1526 const BOPCol_MapOfInteger& aMVOn1=aFI1.VerticesOn();
4e57c75e 1527 const BOPCol_MapOfInteger& aMVIn1=aFI1.VerticesIn();
4e57c75e 1528 const BOPCol_MapOfInteger& aMVOn2=aFI2.VerticesOn();
4e57c75e 1529 const BOPCol_MapOfInteger& aMVIn2=aFI2.VerticesIn();
1da6ad32 1530 //
1531 for (i=0; i<2; ++i) {
1532 const BOPCol_MapOfInteger& aMV1=(!i) ? aMVOn1 : aMVIn1;
1533 aIt.Initialize(aMV1);
1534 for (; aIt.More(); aIt.Next()) {
1535 nV=aIt.Value();
1536 if (aMVOn2.Contains(nV) || aMVIn2.Contains(nV)) {
decdfc94 1537 aMI.Add(nV);
1da6ad32 1538 }
1539 }
4e57c75e 1540 }
1541}
1542//=======================================================================
1543//function : SharedEdges
1544//purpose :
1545//=======================================================================
72e88cf7 1546void BOPDS_DS::SharedEdges(const Standard_Integer nF1,
362dec17 1547 const Standard_Integer nF2,
1548 BOPCol_ListOfInteger& theLI,
1549 const Handle(NCollection_BaseAllocator)& aAllocator)
4e57c75e 1550{
1551 Standard_Integer nE, nSp;
1552 BOPCol_ListIteratorOfListOfInteger aItLI;
1553 BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
1554 BOPCol_MapOfInteger aMI(100, aAllocator);
1555 //
1556 const BOPDS_ShapeInfo& aSI1=ShapeInfo(nF1);
1557 const BOPCol_ListOfInteger& aLI1=aSI1.SubShapes();
1558 aItLI.Initialize(aLI1);
1559 for (; aItLI.More(); aItLI.Next()) {
1560 nE=aItLI.Value();
1561 const BOPDS_ShapeInfo& aSIE=ChangeShapeInfo(nE);
1562 if(aSIE.ShapeType()==TopAbs_EDGE) {
1563 const BOPDS_ListOfPaveBlock& aLPB=PaveBlocks(nE);
1564 if (aLPB.IsEmpty()) {
1565 aMI.Add(nE);
1566 }
1567 else {
1568 aItLPB.Initialize(aLPB);
1569 for (; aItLPB.More(); aItLPB.Next()) {
5a77460e 1570 const Handle(BOPDS_PaveBlock) aPB=RealPaveBlock(aItLPB.Value());
4e57c75e 1571 nSp=aPB->Edge();
1572 aMI.Add(nSp);
1573 }
1574 }
1575 }
1576 }
1577 //
1578 const BOPDS_ShapeInfo& aSI2=ShapeInfo(nF2);
1579 const BOPCol_ListOfInteger& aLI2=aSI2.SubShapes();
1580 aItLI.Initialize(aLI2);
1581 for (; aItLI.More(); aItLI.Next()) {
1582 nE=aItLI.Value();
1583 const BOPDS_ShapeInfo& aSIE=ChangeShapeInfo(nE);
1584 if(aSIE.ShapeType()==TopAbs_EDGE) {
1585 const BOPDS_ListOfPaveBlock& aLPB=PaveBlocks(nE);
1586 if (aLPB.IsEmpty()) {
1587 if (aMI.Contains(nE)) {
1588 theLI.Append(nE);
1589 }
1590 }
1591 else {
1592 aItLPB.Initialize(aLPB);
1593 for (; aItLPB.More(); aItLPB.Next()) {
5a77460e 1594 const Handle(BOPDS_PaveBlock) aPB=RealPaveBlock(aItLPB.Value());
4e57c75e 1595 nSp=aPB->Edge();
1596 if (aMI.Contains(nSp)) {
1597 theLI.Append(nSp);
1598 }
1599 }
1600 }
1601 }
1602 }
1603}
1604
1605//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1606//
1607// same domain shapes
1608//
1609//=======================================================================
1610//function : ShapesSD
1611//purpose :
1612//=======================================================================
72e88cf7 1613BOPCol_DataMapOfIntegerInteger& BOPDS_DS::ShapesSD()
4e57c75e 1614{
1615 return myShapesSD;
1616}
1617//=======================================================================
1618//function : AddShapeSD
1619//purpose :
1620//=======================================================================
72e88cf7 1621void BOPDS_DS::AddShapeSD(const Standard_Integer theIndex,
362dec17 1622 const Standard_Integer theIndexSD)
4e57c75e 1623{
1624 myShapesSD.Bind(theIndex, theIndexSD);
1625}
1626//=======================================================================
1627//function : HasShapeSD
1628//purpose :
1629//=======================================================================
362dec17 1630Standard_Boolean BOPDS_DS::HasShapeSD
1631 (const Standard_Integer theIndex,
1632 Standard_Integer& theIndexSD)const
4e57c75e 1633{
1634 Standard_Boolean bRet;
1635 //
1636 bRet=myShapesSD.IsBound(theIndex);
1637 if (bRet) {
1638 theIndexSD=myShapesSD.Find(theIndex);
1639 }
1640 return bRet;
1641}
1642//=======================================================================
1643//function : Dump
1644//purpose :
1645//=======================================================================
72e88cf7 1646void BOPDS_DS::Dump()const
4e57c75e 1647{
1648 Standard_Integer i, aNb, aNbSS;
1649 //
1650 printf(" *** DS ***\n");
1651 aNb=NbRanges();
1652 printf(" Ranges:%d\n", aNb);
1653 for (i=0; i<aNb; ++i) {
1654 const BOPDS_IndexRange& aR=Range(i);
1655 aR.Dump();
1656 printf("\n");
1657 }
1658 //
1659 aNbSS=NbSourceShapes();
1660 printf(" Shapes:%d\n", aNbSS);
1661 aNb=NbShapes();
1662 for (i=0; i<aNb; ++i) {
1663 const BOPDS_ShapeInfo& aSI=ShapeInfo(i);
1664 printf(" %d :", i);
1665 aSI.Dump();
1666 printf("\n");
1667 if (i==aNbSS-1) {
1668 printf(" ****** adds\n");
1669 }
1670 }
1671 printf(" ******\n");
1672}
1673
1674//=======================================================================
1675// function: CheckCoincidence
1676// purpose:
1677//=======================================================================
362dec17 1678Standard_Boolean BOPDS_DS::CheckCoincidence
1679 (const Handle(BOPDS_PaveBlock)& aPB1,
1680 const Handle(BOPDS_PaveBlock)& aPB2)
4e57c75e 1681{
1682 Standard_Boolean bRet;
1683 Standard_Integer nE1, nE2, aNbPoints;
1684 Standard_Real aT11, aT12, aT21, aT22, aT1m, aD, aTol, aT2x;
1685 gp_Pnt aP1m;
1686 //
1687 bRet=Standard_False;
1688 //
1689 aPB1->Range(aT11, aT12);
1690 aT1m=IntTools_Tools::IntermediatePoint (aT11, aT12);
1691 nE1=aPB1->OriginalEdge();
1692 const TopoDS_Edge& aE1=(*(TopoDS_Edge*)(&Shape(nE1)));
1693 BOPTools_AlgoTools::PointOnEdge(aE1, aT1m, aP1m);
1694 //
1695 aPB2->Range(aT21, aT22);
1696 nE2=aPB2->OriginalEdge();
1697 const TopoDS_Edge& aE2=(*(TopoDS_Edge*)(&Shape(nE2)));
1698 //
1699 Standard_Real f, l;
1700 Handle(Geom_Curve)aC2 = BRep_Tool::Curve (aE2, f, l);
1701 GeomAPI_ProjectPointOnCurve aPPC;
1702 aPPC.Init(aC2, f, l);
1703 aPPC.Perform(aP1m);
1704 aNbPoints=aPPC.NbPoints();
1705 if (aNbPoints) {
1706 aD=aPPC.LowerDistance();
1707 //
1708 aTol=BRep_Tool::Tolerance(aE1);
1709 aTol=aTol+BRep_Tool::Tolerance(aE2);
1710 if (aD<aTol) {
1711 aT2x=aPPC.LowerDistanceParameter();
1712 if (aT2x>aT21 && aT2x<aT22) {
1713 return !bRet;
1714 }
1715 }
1716 }
1717 return bRet;
1718}
4e57c75e 1719//=======================================================================
1720// function: SortPaveBlocks
1721// purpose:
1722//=======================================================================
72e88cf7 1723void BOPDS_DS::SortPaveBlocks(const Handle(BOPDS_CommonBlock)& aCB)
4e57c75e 1724{
1725 Standard_Integer theI;
1726 Standard_Boolean bToSort;
1727 bToSort = IsToSort(aCB, theI);
1728 if (!bToSort) {
1729 return;
1730 }
1731
1732 Standard_Integer i(0);
1733 const BOPDS_ListOfPaveBlock& aLPB = aCB->PaveBlocks();
1734 BOPDS_ListOfPaveBlock aLPBN = aLPB;
1735
1736 Handle(BOPDS_PaveBlock) aPB;
1737 BOPDS_ListIteratorOfListOfPaveBlock aIt;
1738 //
1739 aIt.Initialize(aLPBN);
1740 for (aIt.Next(); aIt.More(); ) {
1741 i++;
1742 if(i == theI) {
1743 aPB = aIt.Value();
1744 aLPBN.Remove(aIt);
1745 aLPBN.Prepend(aPB);
1746 break;
1747 }
1748 aIt.Next();
1749 }
1750 //
1751 aCB->AddPaveBlocks(aLPBN);
1752}
4e57c75e 1753//=======================================================================
1754// function: IsToSort
1755// purpose:
1756//=======================================================================
362dec17 1757Standard_Boolean BOPDS_DS::IsToSort
1758 (const Handle(BOPDS_CommonBlock)& aCB,
1759 Standard_Integer& theI)
4e57c75e 1760{
1761 Standard_Boolean bRet;
1762 bRet = Standard_False;
1763 const BOPDS_ListOfPaveBlock& aLPB = aCB->PaveBlocks();
1764 if (aLPB.Extent()==1) {
1765 return bRet;
1766 }
1767
1768 Standard_Integer nE;
1769 Standard_Real aTolMax, aTol;
1770 Handle(BOPDS_PaveBlock) aPB;
1771 TopoDS_Edge aE;
1772 BOPDS_ListIteratorOfListOfPaveBlock aIt;
1773 //
1774 aPB = aLPB.First();
1775 nE = aPB->OriginalEdge();
1776 aE = (*(TopoDS_Edge *)(&Shape(nE)));
1777 aTolMax = BRep_Tool::Tolerance(aE);
1778 //
1779 theI = 0;
1780 aIt.Initialize(aLPB);
1781 for (aIt.Next(); aIt.More(); aIt.Next()) {
1782 theI++;
1783 aPB = aIt.Value();
1784 nE = aPB->OriginalEdge();
1785 aE = (*(TopoDS_Edge *)(&Shape(nE)));
1786 aTol = BRep_Tool::Tolerance(aE);
1787 if (aTolMax < aTol) {
1788 aTolMax = aTol;
1789 bRet = Standard_True;
1790 }
1791 }
1792
1793 return bRet;
1794}
4e57c75e 1795//=======================================================================
1796// function: IsSubShape
1797// purpose:
1798//=======================================================================
362dec17 1799Standard_Boolean BOPDS_DS::IsSubShape
1800 (const Standard_Integer theI1,
1801 const Standard_Integer theI2)
4e57c75e 1802{
1803 Standard_Boolean bRet;
1804 Standard_Integer nS;
1805 bRet = Standard_False;
1806 //
1807 BOPCol_ListIteratorOfListOfInteger aItLI;
1808 //
1809 const BOPDS_ShapeInfo& aSI = ShapeInfo(theI2);
1810 const BOPCol_ListOfInteger& aLI = aSI.SubShapes();
1811 aItLI.Initialize(aLI);
1812 for(;aItLI.More(); aItLI.Next()) {
1813 nS = aItLI.Value();
1814 if (nS == theI1) {
1815 bRet = Standard_True;
1816 break;
1817 }
1818 }
1819
1820 return bRet;
1821}
1822
1823//=======================================================================
1824// function: Paves
1825// purpose:
1826//=======================================================================
72e88cf7 1827void BOPDS_DS::Paves(const Standard_Integer theEdge,
362dec17 1828 BOPDS_ListOfPave& theLP)
4e57c75e 1829{
1830 Standard_Integer aNb, i;
4e57c75e 1831 BOPDS_ListIteratorOfListOfPaveBlock aIt;
1832 BOPDS_MapOfPave aMP;
1833 //
1834 const BOPDS_ListOfPaveBlock& aLPB = PaveBlocks(theEdge);
7a76337e 1835 aNb = aLPB.Extent() + 1;
1836 if (aNb == 1) {
1837 return;
4e57c75e 1838 }
1839 //
7a76337e 1840 BOPDS_VectorOfPave pPaves(1, aNb);
1841 //
1842 i = 1;
1843 aIt.Initialize(aLPB);
1844 for (; aIt.More(); aIt.Next()) {
4e57c75e 1845 const Handle(BOPDS_PaveBlock)& aPB = aIt.Value();
7a76337e 1846 const BOPDS_Pave& aPave1 = aPB->Pave1();
1847 const BOPDS_Pave& aPave2 = aPB->Pave2();
1848 //
1849 if (aMP.Add(aPave1)){
1850 pPaves(i) = aPave1;
4e57c75e 1851 ++i;
1852 }
7a76337e 1853 //
1854 if (aMP.Add(aPave2)){
1855 pPaves(i) = aPave2;
4e57c75e 1856 ++i;
1857 }
1858 }
1859 //
7a76337e 1860 Standard_ASSERT_VOID(aNb == aMP.Extent(), "Abnormal number of paves");
1861 //
1862 std::sort(pPaves.begin(), pPaves.end());
4e57c75e 1863 //
7a76337e 1864 for (i = 1; i <= aNb; ++i) {
1865 theLP.Append(pPaves(i));
4e57c75e 1866 }
1867}
1868
1869//=======================================================================
1870// function: UpdateTolerance
1871// purpose:
1872//=======================================================================
72e88cf7 1873void BOPDS_DS::UpdateEdgeTolerance(const Standard_Integer nE,
362dec17 1874 const Standard_Real aTol)
4e57c75e 1875{
1876 Standard_Integer nV;
1877 Standard_Real aTolV;
1878 BRep_Builder aBB;
1879 BOPCol_ListIteratorOfListOfInteger aIt;
1880 //
1881 const TopoDS_Edge& aE = *(TopoDS_Edge*)&Shape(nE);
1882 aBB.UpdateEdge(aE, aTol);
1883 BOPDS_ShapeInfo& aSIE=ChangeShapeInfo(nE);
1884 Bnd_Box& aBoxE=aSIE.ChangeBox();
1885 BRepBndLib::Add(aE, aBoxE);
1886 //
1887 const BOPCol_ListOfInteger& aLI = aSIE.SubShapes();
1888 aIt.Initialize(aLI);
1889 for (; aIt.More(); aIt.Next()) {
1890 nV = aIt.Value();
1891 const TopoDS_Vertex& aV = *(TopoDS_Vertex*)&Shape(nV);
1892 aTolV = BRep_Tool::Tolerance(aV);
1893 if (aTolV < aTol) {
1894 aBB.UpdateVertex(aV, aTol);
1895 BOPDS_ShapeInfo& aSIV = ChangeShapeInfo(nV);
1896 Bnd_Box& aBoxV = aSIV.ChangeBox();
1897 BRepBndLib::Add(aV, aBoxV);
1898 }
1899 }
1900}
1901
1902//=======================================================================
1903//function : TotalShapes
1904//purpose :
1905//=======================================================================
1906void TotalShapes(const TopoDS_Shape& aS,
1907 Standard_Integer& aNbS)
1908{
1909 TopoDS_Shape *pS;
1910 //
1911 pS=(TopoDS_Shape *)&aS;
1912 if (!pS->Checked()) {
1913 TopoDS_Iterator aIt;
1914 //
1915 pS->Checked(1);
1916 ++aNbS;
1917 aIt.Initialize(aS);
1918 for (; aIt.More(); aIt.Next()) {
1919 const TopoDS_Shape& aSx=aIt.Value();
1920 TotalShapes(aSx, aNbS);
1921 }
1922 }
1923}
1924//=======================================================================
1925//function : ResetShape
1926//purpose :
1927//=======================================================================
1928void ResetShape(const TopoDS_Shape& aS)
1929{
1930 TopoDS_Shape *pS;
1931 //
1932 pS=(TopoDS_Shape *)&aS;
1933 pS->Checked(0);
1934}
1935//=======================================================================
1936//function : ResetShape
1937//purpose :
1938//=======================================================================
1939void ResetShapes(const TopoDS_Shape& aS)
1940{
1941 TopoDS_Iterator aIt;
1942 //
1943 ResetShape(aS);
1944 aIt.Initialize(aS);
1945 for (; aIt.More(); aIt.Next()) {
1946 const TopoDS_Shape& aSx=aIt.Value();
1947 ResetShape(aSx);
1948 }
1949}
4e57c75e 1950//=======================================================================
1951//function : ComputeParameter
1952//purpose :
1953//=======================================================================
1954Standard_Real ComputeParameter(const TopoDS_Vertex& aV,
1955 const TopoDS_Edge& aE)
1956{
1957 Standard_Real aT1, aT2, aTRet, aTolE2, aD2;
1958 gp_Pnt aPC, aPV;
1959 Handle(Geom_Curve) aC3D;
1960 TopoDS_Edge aEE;
1961 //
1962 aEE=aE;
1963 aEE.Orientation(TopAbs_FORWARD);
1964 //
1965 aTRet=0.;
1966 //
1967 aTolE2=BRep_Tool::Tolerance(aE);
1968 aTolE2=aTolE2*aTolE2;
1969 //
1970 aPV=BRep_Tool::Pnt(aV);
1971 //
1972 aC3D=BRep_Tool::Curve (aEE, aT1, aT2);
1973 //
1974 aC3D->D0(aT1, aPC);
1975 aD2=aPC.SquareDistance(aPV);
1976 if (aD2<aTolE2) {
1977 aTRet=aT1;
1978 }
1979 //
1980 aC3D->D0(aT2, aPC);
1981 aD2=aPC.SquareDistance(aPV);
1982 if (aD2<aTolE2) {
1983 aTRet=aT2;
1984 }
1985 //
1986 return aTRet;
1987}
1988//=======================================================================
30ecd5f8 1989//function : BuildBndBoxSolid
1990//purpose :
1991//=======================================================================
1992void BOPDS_DS::BuildBndBoxSolid(const Standard_Integer theIndex,
362dec17 1993 Bnd_Box& aBoxS)
30ecd5f8 1994{
1995 Standard_Boolean bIsOpenBox, bIsInverted;
1996 Standard_Integer nSh, nFc;
1997 Standard_Real aTolS, aTolFc;
1998 BOPCol_ListIteratorOfListOfInteger aItLI, aItLI1;
1999 //
2000 const BOPDS_ShapeInfo& aSI=ShapeInfo(theIndex);
2001 const TopoDS_Shape& aS=aSI.Shape();
2002 const TopoDS_Solid& aSolid=(*(TopoDS_Solid*)(&aS));
2003 //
2004 bIsOpenBox=Standard_False;
2005 //
2006 aTolS=0.;
2007 const BOPCol_ListOfInteger& aLISh=aSI.SubShapes();
2008 aItLI.Initialize(aLISh);
2009 for (; aItLI.More(); aItLI.Next()) {
2010 nSh=aItLI.Value();
2011 const BOPDS_ShapeInfo& aSISh=ShapeInfo(nSh);
2012 if (aSISh.ShapeType()!=TopAbs_SHELL) {
2013 continue;
2014 }
2015 //
2016 const BOPCol_ListOfInteger& aLIFc=aSISh.SubShapes();
2017 aItLI1.Initialize(aLIFc);
2018 for (; aItLI1.More(); aItLI1.Next()) {
2019 nFc=aItLI1.Value();
2020 const BOPDS_ShapeInfo& aSIFc=ShapeInfo(nFc);
2021 if (aSIFc.ShapeType()!=TopAbs_FACE) {
362dec17 2022 continue;
30ecd5f8 2023 }
2024 //
2025 const Bnd_Box& aBFc=aSIFc.Box();
2026 aBoxS.Add(aBFc);
2027 //
2028 if (!bIsOpenBox) {
362dec17 2029 bIsOpenBox=(aBFc.IsOpenXmin() || aBFc.IsOpenXmax() ||
2030 aBFc.IsOpenYmin() || aBFc.IsOpenYmax() ||
2031 aBFc.IsOpenZmin() || aBFc.IsOpenZmax());
2032 if (bIsOpenBox) {
2033 break;
2034 }
30ecd5f8 2035 }
2036 //
2037 const TopoDS_Face& aFc=*((TopoDS_Face*)&aSIFc.Shape());
2038 aTolFc=BRep_Tool::Tolerance(aFc);
2039 if (aTolFc>aTolS) {
362dec17 2040 aTolS=aTolFc;
30ecd5f8 2041 }
2042 }//for (; aItLI1.More(); aItLI1.Next()) {
2043 if (bIsOpenBox) {
2044 break;
2045 }
2046 //
2047 const TopoDS_Shell& aSh=*((TopoDS_Shell*)&aSISh.Shape());
2048 bIsOpenBox=BOPTools_AlgoTools::IsOpenShell(aSh);
2049 if (bIsOpenBox) {
2050 break;
2051 }
2052 }//for (; aItLI.More(); aItLI.Next()) {
2053 //
2054 if (bIsOpenBox) {
2055 aBoxS.SetWhole();
2056 }
2057 else {
2058 bIsInverted=BOPTools_AlgoTools::IsInvertedSolid(aSolid);
2059 if (bIsInverted) {
2060 aBoxS.SetWhole();
2061 }
2062 }
2063}
b1d15f53 2064
2065//=======================================================================
2066//function : DefaultTolerances
2067//purpose :
2068//=======================================================================
2069void BOPDS_DS::SetDefaultTolerances()
2070{
2071 if (myFuzzyValue == 0.) {
2072 return;
2073 }
2074 //
2075 Standard_Boolean bAdd;
2076 Standard_Integer i, j, n1, n2, nS, nSOp, nSs;
2077 Standard_Integer anIntType, aNbFF, aNbFIn;
2078 Standard_Real aTolDef;
2079 TopAbs_ShapeEnum aTS1, aTS2;
2080 BOPCol_MapOfInteger aMICh;
2081 BOPCol_DataMapOfIntegerMapOfInteger aDMI;
2082 BOPCol_ListIteratorOfListOfInteger aItLI;
2083 BOPDS_MapIteratorMapOfPassKey aItPK;
2084 BOPDS_ListIteratorOfListOfPaveBlock aItPB;
2085 BOPCol_MapIteratorOfMapOfInteger aItMI;
2086 BOPCol_DataMapIteratorOfDataMapOfIntegerReal aItDMIR;
2087 //
2088 // 1. Collect interfered shapes
2089 // 1.1. Interferences V/V, V/E, V/F, E/E and E/F
2090 aItPK.Initialize(myInterfTB);
2091 for (; aItPK.More(); aItPK.Next()) {
2092 const BOPDS_PassKey& aPK = aItPK.Value();
2093 aPK.Ids(n1, n2);
2094 //
2095 const BOPDS_ShapeInfo& aSI1 = ShapeInfo(n1);
2096 const BOPDS_ShapeInfo& aSI2 = ShapeInfo(n2);
2097 //
2098 aTS1 = aSI1.ShapeType();
2099 aTS2 = aSI2.ShapeType();
2100 //
2101 anIntType = BOPDS_Tools::TypeToInteger(aTS1, aTS2);
2102 if (anIntType < 5) {
2103 AddShapeAndSubShapes(n1, aSI1, aMICh);
2104 AddShapeAndSubShapes(n2, aSI2, aMICh);
2105 } // if (anIntType < 5) {
2106 } // for (; aIt.More(); aIt.Next()) {
2107 //
2108 // 1.2 FaceInfo information
2109 aNbFF = myFaceInfoPool.Extent();
2110 for (i = 0; i < aNbFF; ++i) {
2111 const BOPDS_FaceInfo& aFI = myFaceInfoPool(i);
2112 nS = aFI.Index();
2113 if (aMICh.Contains(nS)) {
2114 continue;
2115 }
2116 //
2117 aNbFIn = (aFI.PaveBlocksIn().Extent() +
2118 aFI.VerticesIn().Extent() +
2119 aFI.PaveBlocksSc().Extent() +
2120 aFI.VerticesSc().Extent());
2121 if (aNbFIn > 0) {
2122 AddShapeAndSubShapes(nS, ShapeInfo(nS), aMICh);
2123 } // if (aNbFIn > 0) {
2124 } // for (i = 0; i < aNbFF; ++i) {
2125 //
2126 // 1.3. Empty F/F interferences
2127 aNbFF = myInterfFF.Extent();
2128 for (i = 0; i < aNbFF; ++i) {
2129 BOPDS_InterfFF& aFF = myInterfFF(i);
2130 if ((aFF.Curves().Extent() == 0) &&
2131 (aFF.Points().Extent() == 0)) {
2132 aFF.Indices(n1, n2);
2133 for (j = 0; j < 2; ++j) {
2134 nS = !j ? n1 : n2;
2135 if (aMICh.Contains(nS)) {
2136 continue;
2137 }
2138 nSOp = !j ? n2 : n1;
2139 //
2140 BOPCol_MapOfInteger aME, aMEOp;
2141 //
2142 if (aDMI.IsBound(nS)) {
2143 aME = aDMI.Find(nS);
2144 } else {
2145 CollectEdges(*this, nS, aME);
2146 aDMI.Bind(nS, aME);
2147 }
2148 //
2149 if (aDMI.IsBound(nSOp)) {
2150 aMEOp = aDMI.Find(nSOp);
2151 } else {
2152 CollectEdges(*this, nSOp, aMEOp);
2153 aDMI.Bind(nSOp, aMEOp);
2154 }
2155 //
2156 bAdd = Standard_True;
2157 aItMI.Initialize(aME);
2158 for (; aItMI.More(); aItMI.Next()) {
2159 nSs = aItMI.Value();
2160 if (!aMEOp.Contains(nSs)) {
2161 bAdd = Standard_False;
2162 break;
2163 }
2164 }
2165 //
2166 if (bAdd) {
2167 AddShapeAndSubShapes(nS, ShapeInfo(nS), aMICh);
2168 if (j == 0) {
2169 AddShapeAndSubShapes(nSOp, ShapeInfo(nSOp), aMICh);
2170 }
2171 } // if (bAdd) {
2172 } // for (j = 0; j < 2; ++j) {
2173 } //if ((aFF.Curves().Extent() == 0) &&
2174 } // for (i = 0; i < aNbFF; ++i) {
2175 //
2176 // 2. Back to default tolerance values
2177 aItDMIR.Initialize(myToleranceMap);
2178 for (; aItDMIR.More(); aItDMIR.Next()) {
2179 i = aItDMIR.Key();
2180 //
2181 if (aMICh.Contains(i)) {
2182 continue;
2183 }
2184 //
2185 const BOPDS_ShapeInfo& aSI = ShapeInfo(i);
2186 aTolDef = aItDMIR.Value();
2187 aTS1 = aSI.ShapeType();
2188 switch (aTS1) {
2189 case TopAbs_VERTEX: {
2190 const TopoDS_Vertex& aV = *(TopoDS_Vertex*)&aSI.Shape();
2191 const Handle(BRep_TVertex)& aTV =
2192 *((Handle(BRep_TVertex)*)&aV.TShape());
2193 aTV->Tolerance(aTolDef);
2194 break;
2195 }
2196 case TopAbs_EDGE: {
2197 const TopoDS_Edge& aE = *(TopoDS_Edge*)&aSI.Shape();
2198 const Handle(BRep_TEdge)& aTE =
2199 *((Handle(BRep_TEdge)*)&aE.TShape());
2200 aTE->Tolerance(aTolDef);
2201 //
2202 const BOPDS_ListOfPaveBlock& aLPB = PaveBlocks(i);
2203 aItPB.Initialize(aLPB);
2204 for (; aItPB.More(); aItPB.Next()) {
2205 const Handle(BOPDS_PaveBlock)& aPB = aItPB.Value();
2206 nS = aPB->Edge();
2207 const TopoDS_Edge& aEIm = *(TopoDS_Edge*)&Shape(nS);
2208 const Handle(BRep_TEdge)& aTEIm =
2209 *((Handle(BRep_TEdge)*)&aEIm.TShape());
2210 aTEIm->Tolerance(aTolDef);
2211 }
2212 break;
2213 }
2214 case TopAbs_FACE: {
2215 const TopoDS_Face& aF = *(TopoDS_Face*)&aSI.Shape();
2216 const Handle(BRep_TFace)& aTF =
2217 *((Handle(BRep_TFace)*)&aF.TShape());
2218 aTF->Tolerance(aTolDef);
2219 break;
2220 }
2221 default:
2222 break;
2223 } // switch (aTS1) {
2224 } // for (; aItDMIR.More(); aItDMIR.Next()) {
2225}
2226
2227//=======================================================================
2228//function : AddShapeAndSubShapes
2229//purpose :
2230//=======================================================================
2231void AddShapeAndSubShapes(const Standard_Integer nS,
2232 const BOPDS_ShapeInfo& theSI,
2233 BOPCol_MapOfInteger& theMI)
2234{
2235 Standard_Integer nSs;
2236 if (theMI.Add(nS)) {
2237 const BOPCol_ListOfInteger& aLI = theSI.SubShapes();
2238 BOPCol_ListIteratorOfListOfInteger aItLI(aLI);
2239 for (; aItLI.More(); aItLI.Next()) {
2240 nSs = aItLI.Value();
2241 theMI.Add(nSs);
2242 }
2243 }
2244}
2245
2246//=======================================================================
2247//function : CollectEdges
2248//purpose :
2249//=======================================================================
2250void CollectEdges(const BOPDS_DS& theDS,
2251 const Standard_Integer nF,
2252 BOPCol_MapOfInteger& theMI)
2253{
2254 Standard_Integer i, j, aNbPB, nE, nEIm;
2255 BOPCol_ListIteratorOfListOfInteger aItLI;
2256 BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
2257 //
2258 // ON edges
2259 const BOPDS_ShapeInfo& aSI = theDS.ShapeInfo(nF);
2260 const BOPCol_ListOfInteger& aLI = aSI.SubShapes();
2261 aItLI.Initialize(aLI);
2262 for (; aItLI.More(); aItLI.Next()) {
2263 nE = aItLI.Value();
2264 const BOPDS_ShapeInfo& aSIE = theDS.ShapeInfo(nE);
2265 if (aSIE.ShapeType() != TopAbs_EDGE) {
2266 continue;
2267 }
2268 //
2269 if (!aSIE.HasReference()) {
2270 theMI.Add(nE);
2271 continue;
2272 }
2273 //
2274 const BOPDS_ListOfPaveBlock& aLPB = theDS.PaveBlocks(nE);
2275 aItLPB.Initialize(aLPB);
2276 for (; aItLPB.More(); aItLPB.Next()) {
2277 const Handle(BOPDS_PaveBlock)& aPB = aItLPB.Value();
2278 nEIm = aPB->Edge();
2279 theMI.Add(nEIm);
2280 }
2281 }
2282 // IN and SC edges
2283 const BOPDS_FaceInfo& aFI = theDS.FaceInfo(nF);
2284 const BOPDS_IndexedMapOfPaveBlock& aMPBIn = aFI.PaveBlocksIn();
2285 const BOPDS_IndexedMapOfPaveBlock& aMPBSc = aFI.PaveBlocksSc();
2286 //
2287 for (i = 0; i < 2; ++i) {
2288 const BOPDS_IndexedMapOfPaveBlock& aMPB = !i ? aMPBIn : aMPBSc;
2289 aNbPB = aMPB.Extent();
2290 for (j = 1; j <= aNbPB; ++j) {
2291 const Handle(BOPDS_PaveBlock)& aPB = aMPB(j);
2292 nE = aPB->Edge();
2293 theMI.Add(nE);
2294 }
2295 }
2296}