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