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