Eliminate newly appeared warnings
[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_Size aNbBF;
101   TopoDS_Face aFF, aFSD;
102   TopoDS_Edge aSp, aEE;
103   TopAbs_Orientation anOriF, anOriE;
104   TopExp_Explorer aExp;
105   BOPCol_ListIteratorOfListOfShape aIt;
106   BOPCol_ListOfInteger aLIAV;
107   BOPCol_MapOfShape aMFence;
108   Handle(NCollection_BaseAllocator) aAllocator;
109   BOPCol_ListOfShape aLFIm(myAllocator);
110   BOPCol_MapIteratorOfMapOfShape aItMS;
111   BOPAlgo_VectorOfBuilderFace aVBF;
112   //
113   myErrorStatus=0;
114   //
115   //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~scope f
116   aAllocator=new NCollection_IncAllocator();
117   //
118   BOPCol_ListOfShape aLE(aAllocator);
119   BOPCol_MapOfShape aMDE(100, aAllocator);
120   //
121   aNbS=myDS->NbSourceShapes();
122   //
123   for (i=0; i<aNbS; ++i) {
124     const BOPDS_ShapeInfo& aSI=myDS->ShapeInfo(i);
125     if (aSI.ShapeType()!=TopAbs_FACE) {
126       continue;
127     }
128     //
129     const TopoDS_Face& aF=(*(TopoDS_Face*)(&aSI.Shape()));
130     //
131     bHasFaceInfo=myDS->HasFaceInfo(i);
132     if(!bHasFaceInfo) {
133       continue;
134     }
135     //
136     const BOPDS_FaceInfo& aFI=myDS->FaceInfo(i);
137     //
138     const BOPDS_IndexedMapOfPaveBlock& aMPBIn=aFI.PaveBlocksIn();
139     const BOPDS_IndexedMapOfPaveBlock& aMPBOn=aFI.PaveBlocksOn();
140     const BOPDS_IndexedMapOfPaveBlock& aMPBSc=aFI.PaveBlocksSc();
141     aLIAV.Clear();
142     myDS->AloneVertices(i, aLIAV);
143     
144     aNbPBIn=aMPBIn.Extent();
145     aNbPBOn=aMPBOn.Extent();
146     aNbPBSc=aMPBSc.Extent();
147     aNbAV=aLIAV.Extent();
148     if (!aNbPBIn && !aNbPBOn && !aNbPBSc && !aNbAV) { // not compete
149       continue;
150     }
151     //
152     aMFence.Clear();
153     //
154     anOriF=aF.Orientation();
155     aFF=aF;
156     aFF.Orientation(TopAbs_FORWARD);
157     //
158     
159     //
160     // 1. Fill the egdes set for the face aFF -> LE
161     aLE.Clear();
162     //
163     //
164     // 1.1 Bounding edges
165     aExp.Init(aFF, TopAbs_EDGE);
166     for (; aExp.More(); aExp.Next()) {
167       const TopoDS_Edge& aE=(*(TopoDS_Edge*)(&aExp.Current()));
168       anOriE=aE.Orientation();
169       bIsDegenerated=BRep_Tool::Degenerated(aE);
170       bIsClosed=BRep_Tool::IsClosed(aE, aF);
171       //
172       if (!myImages.IsBound(aE)) {
173         if (anOriE==TopAbs_INTERNAL) {
174           aEE=aE;
175           aEE.Orientation(TopAbs_FORWARD);
176           aLE.Append(aEE);
177           aEE.Orientation(TopAbs_REVERSED);
178           aLE.Append(aEE);
179         }
180         else {
181           aLE.Append(aE);
182         }
183       }
184       else {//else 1
185         const BOPCol_ListOfShape& aLIE=myImages.Find(aE);
186         aIt.Initialize(aLIE);
187         for (; aIt.More(); aIt.Next()) {
188           aSp=(*(TopoDS_Edge*)(&aIt.Value()));
189           if (bIsDegenerated) {
190             aSp.Orientation(anOriE);
191             aLE.Append(aSp);
192             continue;
193           }
194           //
195           if (anOriE==TopAbs_INTERNAL) {
196             aSp.Orientation(TopAbs_FORWARD);
197             aLE.Append(aSp);
198             aSp.Orientation(TopAbs_REVERSED);
199             aLE.Append(aSp);
200             continue;
201           }
202           //
203           if (bIsClosed) {
204             if (aMFence.Add(aSp)) {
205               if (!BRep_Tool::IsClosed(aSp, aF)){
206                 BOPTools_AlgoTools3D::DoSplitSEAMOnFace(aSp, aF);
207                 }
208               //
209               aSp.Orientation(TopAbs_FORWARD);
210               aLE.Append(aSp);
211               aSp.Orientation(TopAbs_REVERSED);
212               aLE.Append(aSp);
213             }// if (aMFence.Add(aSp))
214             continue;
215           }// if (bIsClosed){
216           //
217           aSp.Orientation(anOriE);
218           bToReverse=BOPTools_AlgoTools::IsSplitToReverse(aSp, aE, myContext);
219           if (bToReverse) {
220             aSp.Reverse();
221           }
222           aLE.Append(aSp);
223         }// for (; aIt.More(); aIt.Next()) {
224       }// else 1
225     }// for (; aExp.More(); aExp.Next()) {
226     // 
227     //
228     // 1.2 In edges
229     for (j=1; j<=aNbPBIn; ++j) {
230       const Handle(BOPDS_PaveBlock)& aPB=aMPBIn(j);
231       nSp=aPB->Edge();
232       aSp=(*(TopoDS_Edge*)(&myDS->Shape(nSp)));
233       //
234       aSp.Orientation(TopAbs_FORWARD);
235       aLE.Append(aSp);
236       aSp.Orientation(TopAbs_REVERSED);
237       aLE.Append(aSp);
238     }
239     //
240     //
241     // 1.3 Section edges
242     for (j=1; j<=aNbPBSc; ++j) {
243       const Handle(BOPDS_PaveBlock)& aPB=aMPBSc(j);
244       nSp=aPB->Edge();
245       aSp=(*(TopoDS_Edge*)(&myDS->Shape(nSp)));
246       //
247       aSp.Orientation(TopAbs_FORWARD);
248       aLE.Append(aSp);
249       aSp.Orientation(TopAbs_REVERSED);
250       aLE.Append(aSp);
251     }
252     //
253     BOPTools_AlgoTools2D::BuildPCurveForEdgesOnPlane (aLE, aFF);
254     //
255     // 3 Build split faces
256     BOPAlgo_BuilderFace& aBF=aVBF.Append1();
257     aBF.SetFace(aF);
258     aBF.SetShapes(aLE);
259     //
260   }// for (i=0; i<aNbS; ++i) {
261   //
262   aNbBF=aVBF.Extent();
263   //
264   //===================================================
265   BOPAlgo_BuilderFaceCnt::Perform(myRunParallel, aVBF);
266   //===================================================
267   //
268   for (k=0; k<(Standard_Integer)aNbBF; ++k) {
269     aLFIm.Clear();
270     //
271     BOPAlgo_BuilderFace& aBF=aVBF(k);
272     TopoDS_Face aF=aBF.Face();
273     anOriF=aBF.Orientation();
274     aF.Orientation(anOriF);
275     //
276     const BOPCol_ListOfShape& aLFR=aBF.Areas();
277     aIt.Initialize(aLFR);
278     for (; aIt.More(); aIt.Next()) {
279       TopoDS_Shape& aFR=aIt.ChangeValue();
280       if (anOriF==TopAbs_REVERSED) {
281         aFR.Orientation(TopAbs_REVERSED);
282       }
283       //aFR.Orientation(anOriF);
284       aLFIm.Append(aFR);
285     }
286     //
287     mySplits.Bind(aF, aLFIm); 
288   }// for (k=0; k<aNbBF; ++k) {
289   //
290   aAllocator.Nullify();
291   //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~scope t
292 }
293 //=======================================================================
294 //function : FillSameDomainFaces
295 //purpose  : 
296 //=======================================================================
297 void BOPAlgo_Builder::FillSameDomainFaces()
298 {
299   Standard_Boolean bFlag;
300   Standard_Integer i, j, k, aNbFFs, aNbCurves, aNbPoints, nF1, nF2, aNbS;
301   Handle(NCollection_IncAllocator) aAllocator;
302   BOPCol_ListIteratorOfListOfShape aItF;
303   BOPCol_MapOfShape aMFence;
304   BOPAlgo_IndexedDataMapOfSetInteger aIDMSS;
305   BOPAlgo_VectorOfVectorOfShape aVVS;
306 //
307   myErrorStatus=0;
308   //
309   const BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
310   //
311   aNbFFs=aFFs.Extent();
312   if (!aNbFFs) {
313     return;
314   }
315   //
316   for (i=0; i<aNbFFs; ++i) {
317     const BOPDS_InterfFF& aFF=aFFs(i);
318     aFF.Indices(nF1, nF2);
319     //
320     const BOPDS_VectorOfCurve& aCurves=aFF.Curves();
321     aNbCurves=aCurves.Extent();
322     if (aNbCurves) {
323       //
324       bFlag=Standard_False;
325       for (j=0; j<aNbCurves; ++j) {
326         const BOPDS_Curve& aNC=aCurves.Value(j);
327         bFlag=aNC.HasEdge();
328         if (bFlag) {
329           break;
330         }
331       }
332       if (bFlag) {
333         continue;
334       }
335       //continue;
336     }
337     //
338     const BOPDS_VectorOfPoint& aPoints=aFF.Points();
339     aNbPoints=aPoints.Extent();
340     if (aNbPoints) {
341       continue;
342     }
343     //
344     if (!myDS->HasFaceInfo(nF1) || !myDS->HasFaceInfo(nF2) ) {
345       continue;
346     }
347     //
348     const BOPDS_FaceInfo& aFI1=myDS->FaceInfo(nF1);
349     const BOPDS_FaceInfo& aFI2=myDS->FaceInfo(nF2);
350     //
351     const TopoDS_Shape& aF1=myDS->Shape(nF1);
352     const TopoDS_Shape& aF2=myDS->Shape(nF2);
353     //
354     bFlag=HasPaveBlocksOnIn(aFI1, aFI2);
355     bFlag=bFlag && (mySplits.IsBound(aF1) && mySplits.IsBound(aF2));
356     //
357     if (bFlag) {
358       for (k=0; k<2; ++k) {
359         const TopoDS_Shape& aF=(!k) ? aF1 : aF2;
360         const BOPCol_ListOfShape& aLF=mySplits.Find(aF);
361         //
362         aItF.Initialize(aLF);
363         for (; aItF.More(); aItF.Next()) {
364           const TopoDS_Shape& aFx=aItF.Value();
365           //
366           if (aMFence.Add(aFx)) {
367             BOPTools_Set aSTx;
368             //
369             aSTx.AddEdges(aFx);
370             //
371             if (!aIDMSS.Contains(aSTx)) {
372               BOPAlgo_VectorOfShape& aVS=aVVS.Append1(); 
373               aVS.Append(aFx);
374               //
375               j=aVVS.Extent()-1;
376               aIDMSS.Add (aSTx, j);
377             }
378             else {
379               j=aIDMSS.ChangeFromKey(aSTx);
380               BOPAlgo_VectorOfShape& aVS=aVVS(j);
381               aVS.Append(aFx);
382             }
383           }
384         }
385       }
386     }// if (bFlag) {
387     else {// if (!bFlag) 
388       BOPTools_Set aST1, aST2;
389       //
390       aST1.AddEdges(aF1);
391       aST2.AddEdges(aF2);
392       //
393       if (aST1.IsEqual(aST2)) {
394         if (!aIDMSS.Contains(aST1)) {
395           BOPAlgo_VectorOfShape& aVS=aVVS.Append1(); 
396           if (aMFence.Add(aF1)) {
397             aVS.Append(aF1);
398           }
399           if (aMFence.Add(aF2)) {
400             aVS.Append(aF2);
401           }
402           //
403           k=aVVS.Extent()-1;
404           aIDMSS.Add (aST1, k);
405         }
406         else {
407           k=aIDMSS.ChangeFromKey(aST1);
408           BOPAlgo_VectorOfShape& aVS=aVVS(k);
409           if (aMFence.Add(aF1)) {
410             aVS.Append(aF1);
411           }
412           if (aMFence.Add(aF2)) {
413             aVS.Append(aF2);
414           }
415         }
416       }//if (aST1.IsEqual(aST2)) {
417     }// else {// if (!bFlag) 
418     //
419   }// for (i=0; i<aNbFFs; ++i) {
420   //
421   aIDMSS.Clear();
422   //
423   Standard_Boolean bFlagSD;
424   Standard_Integer aNbVPSB, aNbVVS, aNbF, aNbF1;
425   BOPAlgo_VectorOfPairOfShapeBoolean aVPSB;
426   //
427   aNbVVS=aVVS.Extent();
428   for (i=0; i<aNbVVS; ++i) {
429     const BOPAlgo_VectorOfShape& aVS=aVVS(i);
430     aNbF=aVS.Extent();
431     if (aNbF<2) {
432       continue;
433     }
434     //
435     aNbF1=aNbF-1;
436     for (j=0; j<aNbF1; ++j) {
437       const TopoDS_Shape& aFj=aVS(j);
438       for (k=j+1; k<aNbF; ++k) {
439         const TopoDS_Shape& aFk=aVS(k);
440         BOPAlgo_PairOfShapeBoolean& aPSB=aVPSB.Append1();
441         aPSB.Shape1()=aFj;
442         aPSB.Shape2()=aFk;
443       }
444     }
445   }
446   //====================================================
447   BOPAlgo_BuilderSDFaceCnt::Perform(myRunParallel, aVPSB);
448   //====================================================
449   aAllocator=new NCollection_IncAllocator();
450   BOPCol_IndexedDataMapOfShapeListOfShape aDMSLS(100, aAllocator);
451   BOPCol_DataMapOfIntegerListOfShape aMBlocks(100, aAllocator);
452   //
453   aNbVPSB=aVPSB.Extent();
454   for (i=0; i<aNbVPSB; ++i) {
455     BOPAlgo_PairOfShapeBoolean& aPSB=aVPSB(i);
456     bFlagSD=aPSB.Flag();
457     if (bFlagSD) {
458       const TopoDS_Shape& aFj=aPSB.Shape1();
459       const TopoDS_Shape& aFk=aPSB.Shape2();
460       FillMap(aFj, aFk, aDMSLS, aAllocator);
461     }
462   }
463   aVPSB.Clear();
464   //
465   // 2. Make blocks
466   MakeBlocksCnx(aDMSLS, aMBlocks, aAllocator);
467   //
468   // 3. Fill same domain faces map -> aMSDF
469   aNbS = aMBlocks.Extent();
470   for (i=0; i<aNbS; ++i) {
471     const BOPCol_ListOfShape& aLSD=aMBlocks.Find(i);
472     if (aLSD.IsEmpty()) {
473       continue;
474     }
475     //
476     const TopoDS_Shape& aFSD1=aLSD.First();
477     aItF.Initialize(aLSD);
478     for (; aItF.More(); aItF.Next()) {
479       const TopoDS_Shape& aFSD=aItF.Value();
480       myShapesSD.Bind(aFSD, aFSD1);
481       //
482       // If the face has no splits but are SD face,
483       // it is considered as splitted face
484       if (!mySplits.IsBound(aFSD)) {
485         BOPCol_ListOfShape aLS;
486         aLS.Append(aFSD);
487         mySplits.Bind(aFSD, aLS);
488       }
489     }
490   }
491   aMBlocks.Clear();
492   aDMSLS.Clear();
493   aAllocator.Nullify();
494 }
495 //=======================================================================
496 // function: FillImagesFaces1
497 // purpose: 
498 //=======================================================================
499 void BOPAlgo_Builder::FillImagesFaces1()
500 {
501   Standard_Integer i, aNbS, iSense;
502   TopoDS_Face aFSD;
503   BOPCol_ListOfInteger aLIAV;
504   BOPCol_ListOfShape aLFIm;
505   BOPCol_ListIteratorOfListOfShape aItLS;
506   //
507   aNbS=myDS->NbSourceShapes();
508   for (i=0; i<aNbS; ++i) {
509     const BOPDS_ShapeInfo& aSI=myDS->ShapeInfo(i);
510     if (aSI.ShapeType()!=TopAbs_FACE) {
511       continue;
512     }
513     //
514     const TopoDS_Face& aF=(*(TopoDS_Face*)(&aSI.Shape()));
515     //
516     if (!mySplits.IsBound(aF)) {
517       continue;
518     }
519     //
520     aLIAV.Clear();
521     myDS->AloneVertices(i, aLIAV);
522     aLFIm.Clear();
523     //
524     const BOPCol_ListOfShape& aLSp=mySplits.Find(aF);
525     aItLS.Initialize(aLSp);
526     for (; aItLS.More(); aItLS.Next()) {
527       const TopoDS_Face& aFSp=(*(TopoDS_Face*)(&aItLS.Value()));
528       if (!myShapesSD.IsBound(aFSp)) {
529         aLFIm.Append(aFSp);
530       }
531       else {
532         aFSD=(*(TopoDS_Face*)(&myShapesSD.Find(aFSp)));
533         iSense=BOPTools_AlgoTools::Sense(aFSp, aFSD);
534         if (iSense<0) {
535           aFSD.Reverse();
536         }
537         aLFIm.Append(aFSD);
538       }
539     }
540     //
541     FillInternalVertices(aLFIm, aLIAV);
542     //
543     myImages.Bind(aF, aLFIm); 
544     //
545     //fill myOrigins
546     aItLS.Initialize(aLFIm);
547     for (; aItLS.More(); aItLS.Next()) {
548       const TopoDS_Face& aFSp=(*(TopoDS_Face*)(&aItLS.Value()));
549       myOrigins.Bind(aFSp, aF);
550     }
551   }// for (i=0; i<aNbS; ++i) {
552 }
553 //=======================================================================
554 // function: FillInternalVertices
555 // purpose: 
556 //=======================================================================
557 void BOPAlgo_Builder::FillInternalVertices(BOPCol_ListOfShape& aLFIm,
558                                            BOPCol_ListOfInteger& aLIAV)
559 {
560   Standard_Integer nV, iFlag;
561   Standard_Real aU1, aU2;
562   TopoDS_Vertex aV;
563   BRep_Builder aBB;
564   BOPCol_ListIteratorOfListOfInteger aItV;
565   BOPCol_ListIteratorOfListOfShape aItF;
566   //
567   aItV.Initialize(aLIAV);
568   for (; aItV.More(); aItV.Next()) {
569     nV=aItV.Value();
570     aV=(*(TopoDS_Vertex*)(&myDS->Shape(nV)));
571     aV.Orientation(TopAbs_INTERNAL);
572     //
573     aItF.Initialize(aLFIm);
574     for (; aItF.More(); aItF.Next()) {
575       TopoDS_Face& aF=(*(TopoDS_Face*)(&aItF.Value()));
576       iFlag=myContext->ComputeVF(aV, aF, aU1, aU2);
577       if (!iFlag) {
578         aBB.Add(aF, aV);
579         break;
580       }
581     }
582   }
583 }
584 //=======================================================================
585 //function : MakeBlocksCnx
586 //purpose  : 
587 //=======================================================================
588 void MakeBlocksCnx(const BOPCol_IndexedDataMapOfShapeListOfShape& aMILI,
589                    BOPCol_DataMapOfIntegerListOfShape& aMBlocks,
590                    Handle(NCollection_IncAllocator)& aAllocator)
591 {
592   Standard_Integer aNbV, aNbVS, aNbVP, aNbEC, k, i, j;
593   BOPCol_ListIteratorOfListOfShape aItLI;
594   //
595   BOPCol_MapOfShape aMVS(100, aAllocator);
596   BOPCol_IndexedMapOfShape aMEC(100, aAllocator);
597   BOPCol_IndexedMapOfShape aMVP(100, aAllocator);
598   BOPCol_IndexedMapOfShape aMVAdd(100, aAllocator);
599   //
600   aNbV=aMILI.Extent();
601   //
602   for (k=0,i=1; i<=aNbV; ++i) {
603     aNbVS=aMVS.Extent();
604     if (aNbVS==aNbV) {
605       break;
606     }
607     //
608     const TopoDS_Shape& nV=aMILI.FindKey(i);
609     if (aMVS.Contains(nV)){
610       continue;
611     }
612     aMVS.Add(nV);
613     //
614     aMEC.Clear();
615     aMVP.Clear();
616     aMVAdd.Clear();
617     //
618     aMVP.Add(nV);
619     for(;;) {
620       aNbVP=aMVP.Extent();
621       for (j=1; j<=aNbVP; ++j) {
622         const TopoDS_Shape& nVP=aMVP(j);
623         const BOPCol_ListOfShape& aLV=aMILI.FindFromKey(nVP);
624         aItLI.Initialize(aLV);
625         for (; aItLI.More(); aItLI.Next()) {
626           const TopoDS_Shape& nVx=aItLI.Value();
627           if (aMEC.Contains(nVx)) {
628             continue;
629           }
630           //
631           aMVS.Add(nVx);
632           aMEC.Add(nVx);
633           aMVAdd.Add(nVx);
634         }
635       }
636       //
637       aNbVP=aMVAdd.Extent();
638       if (!aNbVP) {
639         break; // from while(1)
640       }
641       //
642       aMVP.Clear();
643       for (j=1; j<=aNbVP; ++j) {
644         aMVP.Add(aMVAdd(j));
645       }
646       aMVAdd.Clear();
647     }//while(1) {
648     //
649     BOPCol_ListOfShape aLIx(aAllocator);
650     //
651     aNbEC = aMEC.Extent();
652     for (j=1; j<=aNbEC; ++j) {
653       const TopoDS_Shape& nVx=aMEC(j);
654       aLIx.Append(nVx);
655     }
656     //
657     aMBlocks.Bind(k, aLIx);
658     ++k;
659   }//for (k=0,i=1; i<=aNbV; ++i)
660   aMVAdd.Clear();
661   aMVP.Clear();
662   aMEC.Clear();
663   aMVS.Clear();
664 }
665
666 //=======================================================================
667 //function : FillMap
668 //purpose  : 
669 //=======================================================================
670 void FillMap(const TopoDS_Shape& aS1,
671              const TopoDS_Shape& aS2,
672              BOPCol_IndexedDataMapOfShapeListOfShape& aDMSLS,
673              Handle(NCollection_IncAllocator)& aAllocator)
674 {
675   if (aDMSLS.Contains(aS1)) {
676     BOPCol_ListOfShape& aLS=aDMSLS.ChangeFromKey(aS1);
677     aLS.Append(aS2);
678   }
679   else {
680     BOPCol_ListOfShape aLS(aAllocator);
681     aLS.Append(aS2);
682     aDMSLS.Add(aS1, aLS);
683   }
684   //
685   if (aDMSLS.Contains(aS2)) {
686     BOPCol_ListOfShape& aLS=aDMSLS.ChangeFromKey(aS2);
687     aLS.Append(aS1);
688   }
689   else {
690     BOPCol_ListOfShape aLS(aAllocator);
691     aLS.Append(aS1);
692     aDMSLS.Add(aS2, aLS);
693   }
694 }
695 //=======================================================================
696 //function :HasPaveBlocksOnIn
697 //purpose  : 
698 //=======================================================================
699 Standard_Boolean HasPaveBlocksOnIn(const BOPDS_FaceInfo& aFI1,
700                                    const BOPDS_FaceInfo& aFI2)
701 {
702   Standard_Boolean bRet;
703   BOPDS_MapIteratorOfMapOfPaveBlock aItMPB;
704   //
705   bRet=Standard_False;
706   const BOPDS_IndexedMapOfPaveBlock& aMPBOn1=aFI1.PaveBlocksOn();
707   const BOPDS_IndexedMapOfPaveBlock& aMPBIn1=aFI1.PaveBlocksIn();
708   //
709   const BOPDS_IndexedMapOfPaveBlock& aMPBOn2=aFI2.PaveBlocksOn();
710   aItMPB.Initialize(aMPBOn2);
711   for (; aItMPB.More(); aItMPB.Next()) {
712     const Handle(BOPDS_PaveBlock)& aPB=aItMPB.Value();
713     bRet=aMPBOn1.Contains(aPB) || aMPBIn1.Contains(aPB);
714     if (bRet) {
715       return bRet;
716     }
717   }
718   //
719   const BOPDS_IndexedMapOfPaveBlock& aMPBIn2=aFI2.PaveBlocksIn();
720   aItMPB.Initialize(aMPBIn2);
721   for (; aItMPB.More(); aItMPB.Next()) {
722     const Handle(BOPDS_PaveBlock)& aPB=aItMPB.Value();
723     bRet=aMPBOn1.Contains(aPB) || aMPBIn1.Contains(aPB);
724     if (bRet) {
725       return bRet;
726     }
727   }
728   return bRet;
729 }
730 /*
731 //DEBf
732     {
733       TopoDS_Compound aCx;
734       BRep_Builder aBBx;
735       BOPCol_ListIteratorOfListOfShape aItx;
736       //
737       aBBx.MakeCompound(aCx);
738       aBBx.Add(aCx, aFF);
739       aItx.Initialize(aLE);
740       for (; aItx.More(); aItx.Next()) {
741       const TopoDS_Shape& aEx=aItx.Value();
742       aBBx.Add(aCx, aEx);
743       }
744       int a=0;
745     }
746     //DEBt
747 */