0024257: Minor corrections for building / testing on VC++ 11
[occt.git] / src / BOPAlgo / BOPAlgo_Builder_2.cxx
1 // Created by: Peter KURNEV
2 // Copyright (c) 2010-2012 OPEN CASCADE SAS
3 // Copyright (c) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
4 // Copyright (c) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, CEDRAT,
5 //                         EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 //
7 // The content of this file is subject to the Open CASCADE Technology Public
8 // License Version 6.5 (the "License"). You may not use the content of this file
9 // except in compliance with the License. Please obtain a copy of the License
10 // at http://www.opencascade.org and read it completely before using this file.
11 //
12 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
13 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
14 //
15 // The Original Code and all software distributed under the License is
16 // distributed on an "AS IS" basis, without warranty of any kind, and the
17 // Initial Developer hereby disclaims all such warranties, including without
18 // limitation, any warranties of merchantability, fitness for a particular
19 // purpose or non-infringement. Please see the License for the specific terms
20 // and conditions governing the rights and limitations under the License.
21
22 #include <BOPAlgo_Builder.ixx>
23
24 #include <NCollection_IncAllocator.hxx>
25
26 #include <TopoDS_Shape.hxx>
27 #include <TopoDS_Face.hxx>
28 #include <TopoDS_Edge.hxx>
29 #include <TopoDS_Vertex.hxx>
30 #include <TopoDS_Compound.hxx>
31
32 #include <BRep_Tool.hxx>
33 #include <BRep_Builder.hxx>
34
35 #include <TopExp_Explorer.hxx>
36
37 #include <BOPCol_ListOfShape.hxx>
38 #include <BOPCol_ListOfInteger.hxx>
39 #include <BOPCol_MapOfInteger.hxx>
40 #include <BOPCol_DataMapOfIntegerListOfShape.hxx>
41 #include <BOPCol_DataMapOfShapeShape.hxx>
42
43 #include <BOPInt_Context.hxx>
44
45 #include <BOPDS_PaveBlock.hxx>
46 #include <BOPDS_ShapeInfo.hxx>
47 #include <BOPDS_DS.hxx>
48 #include <BOPDS_FaceInfo.hxx>
49 #include <BOPDS_MapOfPaveBlock.hxx>
50 #include <BOPDS_VectorOfInterfFF.hxx>
51 #include <BOPDS_Interf.hxx>
52 #include <BOPDS_VectorOfCurve.hxx>
53 #include <BOPDS_VectorOfPoint.hxx>
54
55 #include <BOPTools.hxx>
56 #include <BOPTools_AlgoTools.hxx>
57 #include <BOPTools_AlgoTools2D.hxx>
58 #include <BOPTools_AlgoTools3D.hxx>
59 #include <BOPAlgo_BuilderFace.hxx>
60 #include <BOPTools_CoupleOfShape.hxx>
61 #include <BOPTools_ListOfCoupleOfShape.hxx>
62 #include <BOPTools_MapOfSet.hxx>
63 #include <BOPTools_DataMapOfShapeSet.hxx>
64 #include <BOPAlgo_Builder_2Cnt.hxx>
65
66 static
67   Standard_Boolean HasPaveBlocksOnIn(const BOPDS_FaceInfo& aFI1,
68                                      const BOPDS_FaceInfo& aFI2);
69 static
70   void FillMap(const TopoDS_Shape& aS1,
71                const TopoDS_Shape& aS2,
72                BOPCol_IndexedDataMapOfShapeListOfShape& aDMSLS,
73                Handle(NCollection_IncAllocator)& aAllocator);
74 static
75   void MakeBlocksCnx(const BOPCol_IndexedDataMapOfShapeListOfShape& aMILI,
76                      BOPCol_DataMapOfIntegerListOfShape& aMBlocks,
77                      Handle(NCollection_IncAllocator)& aAllocator);
78
79
80 //=======================================================================
81 //function : FillImagesFaces
82 //purpose  : 
83 //=======================================================================
84 void BOPAlgo_Builder::FillImagesFaces()
85 {
86   myErrorStatus=0;
87   //
88   BuildSplitFaces();
89   FillSameDomainFaces();
90   FillImagesFaces1();
91 }
92 //=======================================================================
93 //function : BuildSplitFaces
94 //purpose  : 
95 //=======================================================================
96 void BOPAlgo_Builder::BuildSplitFaces()
97 {
98   Standard_Boolean bHasFaceInfo, bIsClosed, bIsDegenerated, bToReverse;
99   Standard_Integer i, j, k, aNbS, aNbPBIn, aNbPBOn, aNbPBSc, aNbAV, nSp;
100   Standard_Boolean bRunParallel;
101   Standard_Size aNbBF;
102   TopoDS_Face aFF, aFSD;
103   TopoDS_Edge aSp, aEE;
104   TopAbs_Orientation anOriF, anOriE;
105   TopExp_Explorer aExp;
106   BOPCol_ListIteratorOfListOfShape aIt;
107   BOPCol_ListOfInteger aLIAV;
108   BOPCol_MapOfShape aMFence;
109   Handle(NCollection_BaseAllocator) aAllocator;
110   BOPCol_ListOfShape aLFIm(myAllocator);
111   BOPCol_MapIteratorOfMapOfShape aItMS;
112   BOPAlgo_VectorOfBuilderFace aVBF;
113   //
114   myErrorStatus=0;
115   //
116   //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~scope f
117   aAllocator=new NCollection_IncAllocator();
118   //
119   BOPCol_ListOfShape aLE(aAllocator);
120   BOPCol_MapOfShape aMDE(100, aAllocator);
121   //
122   aNbS=myDS->NbSourceShapes();
123   //
124   for (i=0; i<aNbS; ++i) {
125     const BOPDS_ShapeInfo& aSI=myDS->ShapeInfo(i);
126     if (aSI.ShapeType()!=TopAbs_FACE) {
127       continue;
128     }
129     //
130     const TopoDS_Face& aF=(*(TopoDS_Face*)(&aSI.Shape()));
131     //
132     bHasFaceInfo=myDS->HasFaceInfo(i);
133     if(!bHasFaceInfo) {
134       continue;
135     }
136     //
137     const BOPDS_FaceInfo& aFI=myDS->FaceInfo(i);
138     //
139     const BOPDS_IndexedMapOfPaveBlock& aMPBIn=aFI.PaveBlocksIn();
140     const BOPDS_IndexedMapOfPaveBlock& aMPBOn=aFI.PaveBlocksOn();
141     const BOPDS_IndexedMapOfPaveBlock& aMPBSc=aFI.PaveBlocksSc();
142     aLIAV.Clear();
143     myDS->AloneVertices(i, aLIAV);
144     
145     aNbPBIn=aMPBIn.Extent();
146     aNbPBOn=aMPBOn.Extent();
147     aNbPBSc=aMPBSc.Extent();
148     aNbAV=aLIAV.Extent();
149     if (!aNbPBIn && !aNbPBOn && !aNbPBSc && !aNbAV) { // not compete
150       continue;
151     }
152     //
153     aMFence.Clear();
154     //
155     anOriF=aF.Orientation();
156     aFF=aF;
157     aFF.Orientation(TopAbs_FORWARD);
158     //
159     
160     //
161     // 1. Fill the egdes set for the face aFF -> LE
162     aLE.Clear();
163     //
164     //
165     // 1.1 Bounding edges
166     aExp.Init(aFF, TopAbs_EDGE);
167     for (; aExp.More(); aExp.Next()) {
168       const TopoDS_Edge& aE=(*(TopoDS_Edge*)(&aExp.Current()));
169       anOriE=aE.Orientation();
170       bIsDegenerated=BRep_Tool::Degenerated(aE);
171       bIsClosed=BRep_Tool::IsClosed(aE, aF);
172       //
173       if (!myImages.IsBound(aE)) {
174         if (anOriE==TopAbs_INTERNAL) {
175           aEE=aE;
176           aEE.Orientation(TopAbs_FORWARD);
177           aLE.Append(aEE);
178           aEE.Orientation(TopAbs_REVERSED);
179           aLE.Append(aEE);
180         }
181         else {
182           aLE.Append(aE);
183         }
184       }
185       else {//else 1
186         const BOPCol_ListOfShape& aLIE=myImages.Find(aE);
187         aIt.Initialize(aLIE);
188         for (; aIt.More(); aIt.Next()) {
189           aSp=(*(TopoDS_Edge*)(&aIt.Value()));
190           if (bIsDegenerated) {
191             aSp.Orientation(anOriE);
192             aLE.Append(aSp);
193             continue;
194           }
195           //
196           if (anOriE==TopAbs_INTERNAL) {
197             aSp.Orientation(TopAbs_FORWARD);
198             aLE.Append(aSp);
199             aSp.Orientation(TopAbs_REVERSED);
200             aLE.Append(aSp);
201             continue;
202           }
203           //
204           if (bIsClosed) {
205             if (aMFence.Add(aSp)) {
206               if (!BRep_Tool::IsClosed(aSp, aF)){
207                 BOPTools_AlgoTools3D::DoSplitSEAMOnFace(aSp, aF);
208                 }
209               //
210               aSp.Orientation(TopAbs_FORWARD);
211               aLE.Append(aSp);
212               aSp.Orientation(TopAbs_REVERSED);
213               aLE.Append(aSp);
214             }// if (aMFence.Add(aSp))
215             continue;
216           }// if (bIsClosed){
217           //
218           aSp.Orientation(anOriE);
219           bToReverse=BOPTools_AlgoTools::IsSplitToReverse(aSp, aE, myContext);
220           if (bToReverse) {
221             aSp.Reverse();
222           }
223           aLE.Append(aSp);
224         }// for (; aIt.More(); aIt.Next()) {
225       }// else 1
226     }// for (; aExp.More(); aExp.Next()) {
227     // 
228     //
229     // 1.2 In edges
230     for (j=1; j<=aNbPBIn; ++j) {
231       const Handle(BOPDS_PaveBlock)& aPB=aMPBIn(j);
232       nSp=aPB->Edge();
233       aSp=(*(TopoDS_Edge*)(&myDS->Shape(nSp)));
234       //
235       aSp.Orientation(TopAbs_FORWARD);
236       aLE.Append(aSp);
237       aSp.Orientation(TopAbs_REVERSED);
238       aLE.Append(aSp);
239     }
240     //
241     //
242     // 1.3 Section edges
243     for (j=1; j<=aNbPBSc; ++j) {
244       const Handle(BOPDS_PaveBlock)& aPB=aMPBSc(j);
245       nSp=aPB->Edge();
246       aSp=(*(TopoDS_Edge*)(&myDS->Shape(nSp)));
247       //
248       aSp.Orientation(TopAbs_FORWARD);
249       aLE.Append(aSp);
250       aSp.Orientation(TopAbs_REVERSED);
251       aLE.Append(aSp);
252     }
253     //
254     BOPTools_AlgoTools2D::BuildPCurveForEdgesOnPlane (aLE, aFF);
255     //
256     // 3 Build split faces
257     BOPAlgo_BuilderFace& aBF=aVBF.Append1();
258     aBF.SetFace(aF);
259     aBF.SetShapes(aLE);
260     //
261   }// for (i=0; i<aNbS; ++i) {
262   //
263   aNbBF=aVBF.Extent();
264   //
265   //===================================================
266   bRunParallel=Standard_True;
267   BOPAlgo_BuilderFaceCnt::Perform(bRunParallel, aVBF);
268   //===================================================
269   //
270   for (k=0; k<(Standard_Integer)aNbBF; ++k) {
271     aLFIm.Clear();
272     //
273     BOPAlgo_BuilderFace& aBF=aVBF(k);
274     TopoDS_Face aF=aBF.Face();
275     anOriF=aBF.Orientation();
276     aF.Orientation(anOriF);
277     //
278     const BOPCol_ListOfShape& aLFR=aBF.Areas();
279     aIt.Initialize(aLFR);
280     for (; aIt.More(); aIt.Next()) {
281       TopoDS_Shape& aFR=aIt.ChangeValue();
282       if (anOriF==TopAbs_REVERSED) {
283         aFR.Orientation(TopAbs_REVERSED);
284       }
285       //aFR.Orientation(anOriF);
286       aLFIm.Append(aFR);
287     }
288     //
289     mySplits.Bind(aF, aLFIm); 
290   }// for (k=0; k<aNbBF; ++k) {
291   //
292   aAllocator.Nullify();
293   //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~scope t
294 }
295 //=======================================================================
296 //function : FillSameDomainFaces
297 //purpose  : 
298 //=======================================================================
299 void BOPAlgo_Builder::FillSameDomainFaces()
300 {
301   Standard_Boolean bFlag;
302   Standard_Integer i, j, k, aNbFFs, aNbCurves, aNbPoints, nF1, nF2, aNbS;
303   Handle(NCollection_IncAllocator) aAllocator;
304   BOPCol_ListIteratorOfListOfShape aItF;
305   BOPCol_MapOfShape aMFence;
306   BOPAlgo_IndexedDataMapOfSetInteger aIDMSS;
307   BOPAlgo_VectorOfVectorOfShape aVVS;
308 //
309   myErrorStatus=0;
310   //
311   const BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
312   //
313   aNbFFs=aFFs.Extent();
314   if (!aNbFFs) {
315     return;
316   }
317   //
318   for (i=0; i<aNbFFs; ++i) {
319     const BOPDS_InterfFF& aFF=aFFs(i);
320     aFF.Indices(nF1, nF2);
321     //
322     const BOPDS_VectorOfCurve& aCurves=aFF.Curves();
323     aNbCurves=aCurves.Extent();
324     if (aNbCurves) {
325       //
326       bFlag=Standard_False;
327       for (j=0; j<aNbCurves; ++j) {
328         const BOPDS_Curve& aNC=aCurves.Value(j);
329         bFlag=aNC.HasEdge();
330         if (bFlag) {
331           break;
332         }
333       }
334       if (bFlag) {
335         continue;
336       }
337       //continue;
338     }
339     //
340     const BOPDS_VectorOfPoint& aPoints=aFF.Points();
341     aNbPoints=aPoints.Extent();
342     if (aNbPoints) {
343       continue;
344     }
345     //
346     if (!myDS->HasFaceInfo(nF1) || !myDS->HasFaceInfo(nF2) ) {
347       continue;
348     }
349     //
350     const BOPDS_FaceInfo& aFI1=myDS->FaceInfo(nF1);
351     const BOPDS_FaceInfo& aFI2=myDS->FaceInfo(nF2);
352     //
353     const TopoDS_Shape& aF1=myDS->Shape(nF1);
354     const TopoDS_Shape& aF2=myDS->Shape(nF2);
355     //
356     bFlag=HasPaveBlocksOnIn(aFI1, aFI2);
357     bFlag=bFlag && (mySplits.IsBound(aF1) && mySplits.IsBound(aF2));
358     //
359     if (bFlag) {
360       for (k=0; k<2; ++k) {
361         const TopoDS_Shape& aF=(!k) ? aF1 : aF2;
362         const BOPCol_ListOfShape& aLF=mySplits.Find(aF);
363         //
364         aItF.Initialize(aLF);
365         for (; aItF.More(); aItF.Next()) {
366           const TopoDS_Shape& aFx=aItF.Value();
367           //
368           if (aMFence.Add(aFx)) {
369             BOPTools_Set aSTx;
370             //
371             aSTx.AddEdges(aFx);
372             //
373             if (!aIDMSS.Contains(aSTx)) {
374               BOPAlgo_VectorOfShape& aVS=aVVS.Append1(); 
375               aVS.Append(aFx);
376               //
377               j=aVVS.Extent()-1;
378               aIDMSS.Add (aSTx, j);
379             }
380             else {
381               j=aIDMSS.ChangeFromKey(aSTx);
382               BOPAlgo_VectorOfShape& aVS=aVVS(j);
383               aVS.Append(aFx);
384             }
385           }
386         }
387       }
388     }// if (bFlag) {
389     else {// if (!bFlag) 
390       BOPTools_Set aST1, aST2;
391       //
392       aST1.AddEdges(aF1);
393       aST2.AddEdges(aF2);
394       //
395       if (aST1.IsEqual(aST2)) {
396         if (!aIDMSS.Contains(aST1)) {
397           BOPAlgo_VectorOfShape& aVS=aVVS.Append1(); 
398           if (aMFence.Add(aF1)) {
399             aVS.Append(aF1);
400           }
401           if (aMFence.Add(aF2)) {
402             aVS.Append(aF2);
403           }
404           //
405           k=aVVS.Extent()-1;
406           aIDMSS.Add (aST1, k);
407         }
408         else {
409           k=aIDMSS.ChangeFromKey(aST1);
410           BOPAlgo_VectorOfShape& aVS=aVVS(k);
411           if (aMFence.Add(aF1)) {
412             aVS.Append(aF1);
413           }
414           if (aMFence.Add(aF2)) {
415             aVS.Append(aF2);
416           }
417         }
418       }//if (aST1.IsEqual(aST2)) {
419     }// else {// if (!bFlag) 
420     //
421   }// for (i=0; i<aNbFFs; ++i) {
422   //
423   aIDMSS.Clear();
424   //
425   Standard_Boolean bRunParallel, bFlagSD;
426   Standard_Integer aNbVPSB, aNbVVS, aNbF, aNbF1;
427   BOPAlgo_VectorOfPairOfShapeBoolean aVPSB;
428   //
429   aNbVVS=aVVS.Extent();
430   for (i=0; i<aNbVVS; ++i) {
431     const BOPAlgo_VectorOfShape& aVS=aVVS(i);
432     aNbF=aVS.Extent();
433     if (aNbF<2) {
434       continue;
435     }
436     //
437     aNbF1=aNbF-1;
438     for (j=0; j<aNbF1; ++j) {
439       const TopoDS_Shape& aFj=aVS(j);
440       for (k=j+1; k<aNbF; ++k) {
441         const TopoDS_Shape& aFk=aVS(k);
442         BOPAlgo_PairOfShapeBoolean& aPSB=aVPSB.Append1();
443         aPSB.Shape1()=aFj;
444         aPSB.Shape2()=aFk;
445       }
446     }
447   }
448   //====================================================
449   bRunParallel=Standard_True;
450   BOPAlgo_BuilderSDFaceCnt::Perform(bRunParallel, aVPSB);
451   //====================================================
452   aAllocator=new NCollection_IncAllocator();
453   BOPCol_IndexedDataMapOfShapeListOfShape aDMSLS(100, aAllocator);
454   BOPCol_DataMapOfIntegerListOfShape aMBlocks(100, aAllocator);
455   //
456   aNbVPSB=aVPSB.Extent();
457   for (i=0; i<aNbVPSB; ++i) {
458     BOPAlgo_PairOfShapeBoolean& aPSB=aVPSB(i);
459     bFlagSD=aPSB.Flag();
460     if (bFlagSD) {
461       const TopoDS_Shape& aFj=aPSB.Shape1();
462       const TopoDS_Shape& aFk=aPSB.Shape2();
463       FillMap(aFj, aFk, aDMSLS, aAllocator);
464     }
465   }
466   aVPSB.Clear();
467   //
468   // 2. Make blocks
469   MakeBlocksCnx(aDMSLS, aMBlocks, aAllocator);
470   //
471   // 3. Fill same domain faces map -> aMSDF
472   aNbS = aMBlocks.Extent();
473   for (i=0; i<aNbS; ++i) {
474     const BOPCol_ListOfShape& aLSD=aMBlocks.Find(i);
475     if (aLSD.IsEmpty()) {
476       continue;
477     }
478     //
479     const TopoDS_Shape& aFSD1=aLSD.First();
480     aItF.Initialize(aLSD);
481     for (; aItF.More(); aItF.Next()) {
482       const TopoDS_Shape& aFSD=aItF.Value();
483       myShapesSD.Bind(aFSD, aFSD1);
484       //
485       // If the face has no splits but are SD face,
486       // it is considered as splitted face
487       if (!mySplits.IsBound(aFSD)) {
488         BOPCol_ListOfShape aLS;
489         aLS.Append(aFSD);
490         mySplits.Bind(aFSD, aLS);
491       }
492     }
493   }
494   aMBlocks.Clear();
495   aDMSLS.Clear();
496   aAllocator.Nullify();
497 }
498 //=======================================================================
499 // function: FillImagesFaces1
500 // purpose: 
501 //=======================================================================
502 void BOPAlgo_Builder::FillImagesFaces1()
503 {
504   Standard_Integer i, aNbS, iSense;
505   TopoDS_Face aFSD;
506   BOPCol_ListOfInteger aLIAV;
507   BOPCol_ListOfShape aLFIm;
508   BOPCol_ListIteratorOfListOfShape aItLS;
509   //
510   aNbS=myDS->NbSourceShapes();
511   for (i=0; i<aNbS; ++i) {
512     const BOPDS_ShapeInfo& aSI=myDS->ShapeInfo(i);
513     if (aSI.ShapeType()!=TopAbs_FACE) {
514       continue;
515     }
516     //
517     const TopoDS_Face& aF=(*(TopoDS_Face*)(&aSI.Shape()));
518     //
519     if (!mySplits.IsBound(aF)) {
520       continue;
521     }
522     //
523     aLIAV.Clear();
524     myDS->AloneVertices(i, aLIAV);
525     aLFIm.Clear();
526     //
527     const BOPCol_ListOfShape& aLSp=mySplits.Find(aF);
528     aItLS.Initialize(aLSp);
529     for (; aItLS.More(); aItLS.Next()) {
530       const TopoDS_Face& aFSp=(*(TopoDS_Face*)(&aItLS.Value()));
531       if (!myShapesSD.IsBound(aFSp)) {
532         aLFIm.Append(aFSp);
533       }
534       else {
535         aFSD=(*(TopoDS_Face*)(&myShapesSD.Find(aFSp)));
536         iSense=BOPTools_AlgoTools::Sense(aFSp, aFSD);
537         if (iSense<0) {
538           aFSD.Reverse();
539         }
540         aLFIm.Append(aFSD);
541       }
542     }
543     //
544     FillInternalVertices(aLFIm, aLIAV);
545     //
546     myImages.Bind(aF, aLFIm); 
547     //
548     //fill myOrigins
549     aItLS.Initialize(aLFIm);
550     for (; aItLS.More(); aItLS.Next()) {
551       const TopoDS_Face& aFSp=(*(TopoDS_Face*)(&aItLS.Value()));
552       myOrigins.Bind(aFSp, aF);
553     }
554   }// for (i=0; i<aNbS; ++i) {
555 }
556 //=======================================================================
557 // function: FillInternalVertices
558 // purpose: 
559 //=======================================================================
560 void BOPAlgo_Builder::FillInternalVertices(BOPCol_ListOfShape& aLFIm,
561                                            BOPCol_ListOfInteger& aLIAV)
562 {
563   Standard_Integer nV, iFlag;
564   Standard_Real aU1, aU2;
565   TopoDS_Vertex aV;
566   BRep_Builder aBB;
567   BOPCol_ListIteratorOfListOfInteger aItV;
568   BOPCol_ListIteratorOfListOfShape aItF;
569   //
570   aItV.Initialize(aLIAV);
571   for (; aItV.More(); aItV.Next()) {
572     nV=aItV.Value();
573     aV=(*(TopoDS_Vertex*)(&myDS->Shape(nV)));
574     aV.Orientation(TopAbs_INTERNAL);
575     //
576     aItF.Initialize(aLFIm);
577     for (; aItF.More(); aItF.Next()) {
578       TopoDS_Face& aF=(*(TopoDS_Face*)(&aItF.Value()));
579       iFlag=myContext->ComputeVF(aV, aF, aU1, aU2);
580       if (!iFlag) {
581         aBB.Add(aF, aV);
582         break;
583       }
584     }
585   }
586 }
587 //=======================================================================
588 //function : MakeBlocksCnx
589 //purpose  : 
590 //=======================================================================
591 void MakeBlocksCnx(const BOPCol_IndexedDataMapOfShapeListOfShape& aMILI,
592                    BOPCol_DataMapOfIntegerListOfShape& aMBlocks,
593                    Handle(NCollection_IncAllocator)& aAllocator)
594 {
595   Standard_Integer aNbV, aNbVS, aNbVP, aNbEC, k, i, j;
596   BOPCol_ListIteratorOfListOfShape aItLI;
597   //
598   BOPCol_MapOfShape aMVS(100, aAllocator);
599   BOPCol_IndexedMapOfShape aMEC(100, aAllocator);
600   BOPCol_IndexedMapOfShape aMVP(100, aAllocator);
601   BOPCol_IndexedMapOfShape aMVAdd(100, aAllocator);
602   //
603   aNbV=aMILI.Extent();
604   //
605   for (k=0,i=1; i<=aNbV; ++i) {
606     aNbVS=aMVS.Extent();
607     if (aNbVS==aNbV) {
608       break;
609     }
610     //
611     const TopoDS_Shape& nV=aMILI.FindKey(i);
612     if (aMVS.Contains(nV)){
613       continue;
614     }
615     aMVS.Add(nV);
616     //
617     aMEC.Clear();
618     aMVP.Clear();
619     aMVAdd.Clear();
620     //
621     aMVP.Add(nV);
622     for(;;) {
623       aNbVP=aMVP.Extent();
624       for (j=1; j<=aNbVP; ++j) {
625         const TopoDS_Shape& nVP=aMVP(j);
626         const BOPCol_ListOfShape& aLV=aMILI.FindFromKey(nVP);
627         aItLI.Initialize(aLV);
628         for (; aItLI.More(); aItLI.Next()) {
629           const TopoDS_Shape& nVx=aItLI.Value();
630           if (aMEC.Contains(nVx)) {
631             continue;
632           }
633           //
634           aMVS.Add(nVx);
635           aMEC.Add(nVx);
636           aMVAdd.Add(nVx);
637         }
638       }
639       //
640       aNbVP=aMVAdd.Extent();
641       if (!aNbVP) {
642         break; // from while(1)
643       }
644       //
645       aMVP.Clear();
646       for (j=1; j<=aNbVP; ++j) {
647         aMVP.Add(aMVAdd(j));
648       }
649       aMVAdd.Clear();
650     }//while(1) {
651     //
652     BOPCol_ListOfShape aLIx(aAllocator);
653     //
654     aNbEC = aMEC.Extent();
655     for (j=1; j<=aNbEC; ++j) {
656       const TopoDS_Shape& nVx=aMEC(j);
657       aLIx.Append(nVx);
658     }
659     //
660     aMBlocks.Bind(k, aLIx);
661     ++k;
662   }//for (k=0,i=1; i<=aNbV; ++i)
663   aMVAdd.Clear();
664   aMVP.Clear();
665   aMEC.Clear();
666   aMVS.Clear();
667 }
668
669 //=======================================================================
670 //function : FillMap
671 //purpose  : 
672 //=======================================================================
673 void FillMap(const TopoDS_Shape& aS1,
674              const TopoDS_Shape& aS2,
675              BOPCol_IndexedDataMapOfShapeListOfShape& aDMSLS,
676              Handle(NCollection_IncAllocator)& aAllocator)
677 {
678   if (aDMSLS.Contains(aS1)) {
679     BOPCol_ListOfShape& aLS=aDMSLS.ChangeFromKey(aS1);
680     aLS.Append(aS2);
681   }
682   else {
683     BOPCol_ListOfShape aLS(aAllocator);
684     aLS.Append(aS2);
685     aDMSLS.Add(aS1, aLS);
686   }
687   //
688   if (aDMSLS.Contains(aS2)) {
689     BOPCol_ListOfShape& aLS=aDMSLS.ChangeFromKey(aS2);
690     aLS.Append(aS1);
691   }
692   else {
693     BOPCol_ListOfShape aLS(aAllocator);
694     aLS.Append(aS1);
695     aDMSLS.Add(aS2, aLS);
696   }
697 }
698 //=======================================================================
699 //function :HasPaveBlocksOnIn
700 //purpose  : 
701 //=======================================================================
702 Standard_Boolean HasPaveBlocksOnIn(const BOPDS_FaceInfo& aFI1,
703                                    const BOPDS_FaceInfo& aFI2)
704 {
705   Standard_Boolean bRet;
706   BOPDS_MapIteratorOfMapOfPaveBlock aItMPB;
707   //
708   bRet=Standard_False;
709   const BOPDS_IndexedMapOfPaveBlock& aMPBOn1=aFI1.PaveBlocksOn();
710   const BOPDS_IndexedMapOfPaveBlock& aMPBIn1=aFI1.PaveBlocksIn();
711   //
712   const BOPDS_IndexedMapOfPaveBlock& aMPBOn2=aFI2.PaveBlocksOn();
713   aItMPB.Initialize(aMPBOn2);
714   for (; aItMPB.More(); aItMPB.Next()) {
715     const Handle(BOPDS_PaveBlock)& aPB=aItMPB.Value();
716     bRet=aMPBOn1.Contains(aPB) || aMPBIn1.Contains(aPB);
717     if (bRet) {
718       return bRet;
719     }
720   }
721   //
722   const BOPDS_IndexedMapOfPaveBlock& aMPBIn2=aFI2.PaveBlocksIn();
723   aItMPB.Initialize(aMPBIn2);
724   for (; aItMPB.More(); aItMPB.Next()) {
725     const Handle(BOPDS_PaveBlock)& aPB=aItMPB.Value();
726     bRet=aMPBOn1.Contains(aPB) || aMPBIn1.Contains(aPB);
727     if (bRet) {
728       return bRet;
729     }
730   }
731   return bRet;
732 }
733 /*
734 //DEBf
735     {
736       TopoDS_Compound aCx;
737       BRep_Builder aBBx;
738       BOPCol_ListIteratorOfListOfShape aItx;
739       //
740       aBBx.MakeCompound(aCx);
741       aBBx.Add(aCx, aFF);
742       aItx.Initialize(aLE);
743       for (; aItx.More(); aItx.Next()) {
744       const TopoDS_Shape& aEx=aItx.Value();
745       aBBx.Add(aCx, aEx);
746       }
747       int a=0;
748     }
749     //DEBt
750 */