0025748: Parallel version of progress indicator
[occt.git] / src / BOPAlgo / BOPAlgo_PaveFiller_3.cxx
1 // Created by: Peter KURNEV
2 // Copyright (c) 2010-2014 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 // This file is part of Open CASCADE Technology software library.
8 //
9 // This library is free software; you can redistribute it and/or modify it under
10 // the terms of the GNU Lesser General Public License version 2.1 as published
11 // by the Free Software Foundation, with special exception defined in the file
12 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
13 // distribution for complete text of the license and disclaimer of any warranty.
14 //
15 // Alternatively, this file may be used under the terms of Open CASCADE
16 // commercial license or contractual agreement.
17
18
19 #include <Bnd_Box.hxx>
20 #include <BOPAlgo_PaveFiller.hxx>
21 #include <BOPAlgo_Tools.hxx>
22 #include <BOPAlgo_Alerts.hxx>
23 #include <BOPDS_CommonBlock.hxx>
24 #include <BOPDS_CoupleOfPaveBlocks.hxx>
25 #include <BOPDS_DS.hxx>
26 #include <BOPDS_Interf.hxx>
27 #include <BOPDS_Iterator.hxx>
28 #include <BOPDS_MapOfPaveBlock.hxx>
29 #include <BOPDS_Pave.hxx>
30 #include <BOPDS_PaveBlock.hxx>
31 #include <BOPDS_VectorOfInterfEE.hxx>
32 #include <BOPTools_AlgoTools.hxx>
33 #include <BOPTools_AlgoTools2D.hxx>
34 #include <BOPTools_Parallel.hxx>
35 #include <BndLib_Add3dCurve.hxx>
36 #include <BRep_Tool.hxx>
37 #include <BRep_Builder.hxx>
38 #include <BRepAdaptor_Curve.hxx>
39 #include <GeomAPI_ProjectPointOnCurve.hxx>
40 #include <gp_Pnt.hxx>
41 #include <IntTools_CommonPrt.hxx>
42 #include <IntTools_Context.hxx>
43 #include <IntTools_EdgeEdge.hxx>
44 #include <IntTools_Range.hxx>
45 #include <IntTools_SequenceOfCommonPrts.hxx>
46 #include <IntTools_SequenceOfRanges.hxx>
47 #include <IntTools_ShrunkRange.hxx>
48 #include <IntTools_Tools.hxx>
49 #include <NCollection_IncAllocator.hxx>
50 #include <NCollection_Vector.hxx>
51 #include <Precision.hxx>
52 #include <TopoDS.hxx>
53 #include <TopoDS_Edge.hxx>
54 #include <TopoDS_Vertex.hxx>
55
56 /////////////////////////////////////////////////////////////////////////
57 //=======================================================================
58 //class    : BOPAlgo_EdgeEdge
59 //purpose  : 
60 //=======================================================================
61 class BOPAlgo_EdgeEdge : 
62   public IntTools_EdgeEdge,
63   public BOPAlgo_Algo {
64  
65  public:
66
67   DEFINE_STANDARD_ALLOC
68   //
69   BOPAlgo_EdgeEdge(): 
70     IntTools_EdgeEdge(),
71     BOPAlgo_Algo() {
72   };
73   //
74   virtual ~BOPAlgo_EdgeEdge(){
75   };
76   //
77   void SetPaveBlock1(const Handle(BOPDS_PaveBlock)& aPB) {
78     myPB1=aPB;
79   }
80   //
81   Handle(BOPDS_PaveBlock)& PaveBlock1() {
82     return myPB1;
83   }
84   //
85   void SetPaveBlock2(const Handle(BOPDS_PaveBlock)& aPB) {
86     myPB2=aPB;
87   }
88   //
89   Handle(BOPDS_PaveBlock)& PaveBlock2() {
90     return myPB2;
91   }
92   //
93   void SetBoxes (const Bnd_Box& theBox1,
94                  const Bnd_Box& theBox2)
95   {
96     myBox1 = theBox1;
97     myBox2 = theBox2;
98   }
99   //
100   void SetFuzzyValue(const Standard_Real theFuzz) {
101     IntTools_EdgeEdge::SetFuzzyValue(theFuzz);
102   }
103   //
104   virtual void Perform() {
105     BOPAlgo_Algo::UserBreak();
106     TopoDS_Edge anE1 = myEdge1, anE2 = myEdge2;
107     Standard_Boolean hasTrsf = false;
108     try
109     {
110       OCC_CATCH_SIGNALS
111
112       gp_Trsf aTrsf;
113       if (BOPAlgo_Tools::TrsfToPoint (myBox1, myBox2, aTrsf))
114       {
115         // Shapes are located far from origin, move the shapes to the origin,
116         // to increase the accuracy of intersection.
117         TopLoc_Location aLoc (aTrsf);
118         myEdge1.Move (aLoc);
119         myEdge2.Move (aLoc);
120         hasTrsf = Standard_True;
121       }
122
123       IntTools_EdgeEdge::Perform();
124     }
125     catch (Standard_Failure const&)
126     {
127       AddError(new BOPAlgo_AlertIntersectionFailed);
128     }
129
130     myEdge1 = anE1;
131     myEdge2 = anE2;
132     if (hasTrsf)
133     {
134       for (Standard_Integer i = 1; i <= myCommonParts.Length(); ++i)
135       {
136         IntTools_CommonPrt& aCPart = myCommonParts (i);
137         aCPart.SetEdge1 (myEdge1);
138         aCPart.SetEdge2 (myEdge2);
139       }
140     }
141
142   }
143   //
144  protected:
145   Handle(BOPDS_PaveBlock) myPB1;
146   Handle(BOPDS_PaveBlock) myPB2;
147   Bnd_Box myBox1;
148   Bnd_Box myBox2;
149 };
150 //
151 //=======================================================================
152 typedef NCollection_Vector<BOPAlgo_EdgeEdge> BOPAlgo_VectorOfEdgeEdge;
153
154 //=======================================================================
155 // function: PerformEE
156 // purpose: 
157 //=======================================================================
158 void BOPAlgo_PaveFiller::PerformEE()
159 {
160   FillShrunkData(TopAbs_EDGE, TopAbs_EDGE);
161   //
162   myIterator->Initialize(TopAbs_EDGE, TopAbs_EDGE);
163   Standard_Integer iSize = myIterator->ExpectedLength();
164   if (!iSize) {
165     return; 
166   }
167   //
168   Standard_Boolean bExpressCompute, bIsPBSplittable1, bIsPBSplittable2;
169   Standard_Integer i, iX, nE1, nE2, aNbCPrts, k, aNbEdgeEdge;
170   Standard_Integer nV11, nV12, nV21, nV22;
171   Standard_Real aTS11, aTS12, aTS21, aTS22, aT11, aT12, aT21, aT22;
172   TopAbs_ShapeEnum aType;
173   BOPDS_ListIteratorOfListOfPaveBlock aIt1, aIt2;
174   Handle(NCollection_BaseAllocator) aAllocator;
175   BOPAlgo_VectorOfEdgeEdge aVEdgeEdge;
176   BOPDS_MapIteratorOfMapOfPaveBlock aItPB; 
177   // keep modified edges for further update
178   TColStd_MapOfInteger aMEdges;
179   //
180   aAllocator=NCollection_BaseAllocator::CommonBaseAllocator();
181   //-----------------------------------------------------scope f
182   BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock aMPBLPB(100, aAllocator);
183   BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks aMVCPB(100, aAllocator);
184   BOPAlgo_DataMapOfPaveBlockBndBox aDMPBBox(100, aAllocator);
185   //
186   BOPDS_VectorOfInterfEE& aEEs=myDS->InterfEE();
187   aEEs.SetIncrement(iSize);
188   //
189   for (; myIterator->More(); myIterator->Next()) {
190     myIterator->Value(nE1, nE2);
191     //
192     const BOPDS_ShapeInfo& aSIE1=myDS->ShapeInfo(nE1);
193     if (aSIE1.HasFlag()){
194       continue;
195     }
196     const BOPDS_ShapeInfo& aSIE2=myDS->ShapeInfo(nE2);
197     if (aSIE2.HasFlag()){
198       continue;
199     }
200     //
201     BOPDS_ListOfPaveBlock& aLPB1 = myDS->ChangePaveBlocks(nE1);
202     if (aLPB1.IsEmpty()) {
203       continue;
204     }
205     //
206     BOPDS_ListOfPaveBlock& aLPB2 = myDS->ChangePaveBlocks(nE2);
207     if (aLPB2.IsEmpty()) {
208       continue;
209     }
210     //
211     const TopoDS_Edge& aE1=(*(TopoDS_Edge *)(&aSIE1.Shape()));
212     const TopoDS_Edge& aE2=(*(TopoDS_Edge *)(&aSIE2.Shape()));
213     //
214     aIt1.Initialize(aLPB1);
215     for (; aIt1.More(); aIt1.Next()) {
216       Bnd_Box aBB1;
217       //
218       Handle(BOPDS_PaveBlock)& aPB1=aIt1.ChangeValue();
219       //
220       if (!GetPBBox(aE1, aPB1, aDMPBBox, aT11, aT12, aTS11, aTS12, aBB1)) {
221         continue;
222       }
223       //
224       aPB1->Indices(nV11, nV12);
225       //
226       aIt2.Initialize(aLPB2);
227       for (; aIt2.More(); aIt2.Next()) {
228         Bnd_Box aBB2;
229         //
230         Handle(BOPDS_PaveBlock)& aPB2=aIt2.ChangeValue();
231         //
232         if (!GetPBBox(aE2, aPB2, aDMPBBox, aT21, aT22, aTS21, aTS22, aBB2)) {
233           continue;
234         }
235         //
236         if (aBB1.IsOut(aBB2)) {
237           continue;
238         }
239         //
240         aPB2->Indices(nV21, nV22);
241         //
242         bExpressCompute=((nV11==nV21 && nV12==nV22) ||
243                          (nV12==nV21 && nV11==nV22));
244         //
245         BOPAlgo_EdgeEdge& anEdgeEdge=aVEdgeEdge.Appended();
246         //
247         anEdgeEdge.UseQuickCoincidenceCheck(bExpressCompute);
248         //
249         anEdgeEdge.SetPaveBlock1(aPB1);
250         anEdgeEdge.SetPaveBlock2(aPB2);
251         //
252         anEdgeEdge.SetEdge1(aE1, aT11, aT12);
253         anEdgeEdge.SetEdge2(aE2, aT21, aT22);
254         anEdgeEdge.SetBoxes (aBB1, aBB2);
255         anEdgeEdge.SetFuzzyValue(myFuzzyValue);
256         anEdgeEdge.SetProgressIndicator(*myProgressScope);
257       }//for (; aIt2.More(); aIt2.Next()) {
258     }//for (; aIt1.More(); aIt1.Next()) {
259   }//for (; myIterator->More(); myIterator->Next()) {
260   //
261   aNbEdgeEdge=aVEdgeEdge.Length();
262   //======================================================
263   BOPTools_Parallel::Perform (myRunParallel, aVEdgeEdge);
264   //======================================================
265   //
266   for (k = 0; k < aNbEdgeEdge; ++k) {
267     Bnd_Box aBB1, aBB2;
268     //
269     BOPAlgo_EdgeEdge& anEdgeEdge=aVEdgeEdge(k);
270     if (!anEdgeEdge.IsDone() || anEdgeEdge.HasErrors()) {
271       // Warn about failed intersection of sub-shapes
272       const TopoDS_Shape& aE1 = myDS->Shape(anEdgeEdge.PaveBlock1()->OriginalEdge());
273       const TopoDS_Shape& aE2 = myDS->Shape(anEdgeEdge.PaveBlock2()->OriginalEdge());
274       AddIntersectionFailedWarning(aE1, aE2);
275       continue;
276     }
277     //
278     const IntTools_SequenceOfCommonPrts& aCPrts = anEdgeEdge.CommonParts();
279     aNbCPrts = aCPrts.Length();
280     if (!aNbCPrts) {
281       continue;
282     }
283     //--------------------------------------------
284     Handle(BOPDS_PaveBlock)& aPB1=anEdgeEdge.PaveBlock1();
285     nE1=aPB1->OriginalEdge();
286     aPB1->Range(aT11, aT12);
287     if (!aPB1->HasShrunkData()) {
288       aTS11 = aT11;
289       aTS12 = aT12;
290       bIsPBSplittable1 = Standard_False;
291     }
292     else {
293       aPB1->ShrunkData(aTS11, aTS12, aBB1, bIsPBSplittable1);
294     }
295     //
296     Handle(BOPDS_PaveBlock)& aPB2=anEdgeEdge.PaveBlock2();
297     nE2=aPB2->OriginalEdge();
298     aPB2->Range(aT21, aT22);
299     if (!aPB2->HasShrunkData()) {
300       aTS21 = aT21;
301       aTS22 = aT22;
302       bIsPBSplittable2 = Standard_False;
303     }
304     else {
305       aPB2->ShrunkData(aTS21, aTS22, aBB2, bIsPBSplittable2);
306     }
307     //
308     //--------------------------------------------
309     IntTools_Range aR11(aT11, aTS11), aR12(aTS12, aT12),
310                    aR21(aT21, aTS21), aR22(aTS22, aT22);
311     //
312     Standard_Boolean bAnalytical = Standard_False;
313     {
314       const TopoDS_Edge& aOE1 = *(TopoDS_Edge*)&myDS->Shape(nE1);
315       const TopoDS_Edge& aOE2 = *(TopoDS_Edge*)&myDS->Shape(nE2);
316       //
317       BRepAdaptor_Curve aBAC1(aOE1), aBAC2(aOE2);
318       //
319       GeomAbs_CurveType aType1 = aBAC1.GetType();
320       GeomAbs_CurveType aType2 = aBAC2.GetType();
321       //
322       bAnalytical = (((aType1 == GeomAbs_Line) &&
323                       (aType2 == GeomAbs_Line ||
324                        aType2 == GeomAbs_Circle)) ||
325                      ((aType2 == GeomAbs_Line) &&
326                       (aType1 == GeomAbs_Line ||
327                        aType1 == GeomAbs_Circle)));
328     }
329     //
330     for (i=1; i<=aNbCPrts; ++i) {
331       const IntTools_CommonPrt& aCPart=aCPrts(i);
332       //
333       const TopoDS_Edge& aE1=aCPart.Edge1();
334       const TopoDS_Edge& aE2=aCPart.Edge2();
335       //
336       aType=aCPart.Type();
337       switch (aType) {
338         case TopAbs_VERTEX:  { 
339           if (!bIsPBSplittable1 || !bIsPBSplittable2) {
340             continue;
341           }
342           //
343           Standard_Boolean bIsOnPave[4];
344           Standard_Integer nV[4], j;
345           Standard_Real aT1, aT2, aTol;
346           TopoDS_Vertex aVnew;
347           IntTools_Range aCR1, aCR2;
348           //
349           IntTools_Tools::VertexParameters(aCPart, aT1, aT2);
350           aTol = Precision::Confusion();
351           aCR1 = aCPart.Range1();
352           aCR2 = aCPart.Ranges2()(1);
353           // 
354           //decide to keep the pave or not
355           bIsOnPave[0] = IntTools_Tools::IsOnPave1(aT1, aR11, aTol) ||
356             IntTools_Tools::IsOnPave1(aR11.First(), aCR1, aTol);
357           bIsOnPave[1] = IntTools_Tools::IsOnPave1(aT1, aR12, aTol) || 
358             IntTools_Tools::IsOnPave1(aR12.Last(), aCR1, aTol);
359           bIsOnPave[2] = IntTools_Tools::IsOnPave1(aT2, aR21, aTol) ||
360             IntTools_Tools::IsOnPave1(aR21.First(), aCR2, aTol);
361           bIsOnPave[3] = IntTools_Tools::IsOnPave1(aT2, aR22, aTol) ||
362             IntTools_Tools::IsOnPave1(aR22.Last(), aCR2, aTol);
363           //
364           aPB1->Indices(nV[0], nV[1]);
365           aPB2->Indices(nV[2], nV[3]);
366           //
367           if((bIsOnPave[0] && bIsOnPave[2]) || 
368              (bIsOnPave[0] && bIsOnPave[3]) ||
369              (bIsOnPave[1] && bIsOnPave[2]) || 
370              (bIsOnPave[1] && bIsOnPave[3])) {
371             continue;
372           }
373           //
374           Standard_Boolean isVExists = Standard_False;
375           for (j = 0; j < 4; ++j)
376           {
377             if (bIsOnPave[j])
378             {
379               Handle(BOPDS_PaveBlock)& aPB = (j < 2) ? aPB2 : aPB1;
380               bIsOnPave[j] = ForceInterfVE(nV[j], aPB, aMEdges);
381               if (bIsOnPave[j]) isVExists = Standard_True;
382             }
383           }
384
385           BOPTools_AlgoTools::MakeNewVertex(aE1, aT1, aE2, aT2, aVnew);
386           const gp_Pnt aPnew = BRep_Tool::Pnt(aVnew);
387
388           if (isVExists)
389           {
390             // The found intersection point is located closely to one of the
391             // pave blocks bounds. So, do not create the new vertex in this point.
392             // Check if this point is a real intersection point or just a touching point.
393             // If it is a touching point, do nothing.
394             // If it is an intersection point, update the existing vertex to cover the
395             // intersection point.
396             const gp_Pnt aPOnE1 = BRepAdaptor_Curve(aE1).Value(aT1);
397             const gp_Pnt aPOnE2 = BRepAdaptor_Curve(aE2).Value(aT2);
398             if (aPOnE1.Distance(aPOnE2) > Precision::Intersection())
399               // No intersection point
400               continue;
401
402             // Real intersection is present.
403             // Update the existing vertex to cover the intersection point.
404             for (j = 0; j < 4; ++j)
405             {
406               if (bIsOnPave[j])
407               {
408                 const TopoDS_Vertex& aV = TopoDS::Vertex(myDS->Shape(nV[j]));
409                 const gp_Pnt aP = BRep_Tool::Pnt(aV);
410                 Standard_Real aDistPP = aP.Distance(aPnew);
411                 // Just update the vertex
412                 UpdateVertex(nV[j], aDistPP);
413                 myVertsToAvoidExtension.Add(nV[j]);
414               }
415             }
416           }
417
418           Standard_Real aTolVnew = BRep_Tool::Tolerance(aVnew);
419           if (bAnalytical) {
420             // increase tolerance for Line/Line intersection, but do not update 
421             // the vertex till its intersection with some other shape
422             Standard_Real aTolMin = (BRepAdaptor_Curve(aE1).GetType() == GeomAbs_Line) ?
423               (aCR1.Last() - aCR1.First()) / 2. : (aCR2.Last() - aCR2.First()) / 2.;
424             if (aTolMin > aTolVnew) {
425               aTolVnew = aTolMin;
426             }
427           }
428           // <-LXBR
429           {
430             Standard_Integer nVS[2], iFound;
431             Standard_Real aTolVx, aD2, aDT2;
432             TColStd_MapOfInteger aMV;
433             gp_Pnt aPx;
434             //
435             iFound=0;
436             j=-1;
437             aMV.Add(nV[0]);
438             aMV.Add(nV[1]);
439             //
440             if (aMV.Contains(nV[2])) {
441               ++j;
442               nVS[j]=nV[2];
443             }
444             if (aMV.Contains(nV[3])) {
445               ++j;
446               nVS[j]=nV[3];
447             }
448             //
449             for (Standard_Integer k1=0; k1<=j; ++k1) {
450               const TopoDS_Vertex& aVx= *(TopoDS_Vertex*)&(myDS->Shape(nVS[k1]));
451               aTolVx=BRep_Tool::Tolerance(aVx);
452               aPx=BRep_Tool::Pnt(aVx);
453               aD2=aPnew.SquareDistance(aPx);
454               //
455               aDT2=100.*(aTolVnew+aTolVx)*(aTolVnew+aTolVx);
456               //
457               if (aD2<aDT2) {
458                 iFound=1;
459                 break;
460               }
461             }
462             //
463             if (iFound) {
464               continue;
465             }
466           }
467           //
468           // 1
469           BOPDS_InterfEE& aEE=aEEs.Appended();
470           iX=aEEs.Length()-1;
471           aEE.SetIndices(nE1, nE2);
472           aEE.SetCommonPart(aCPart);
473           // 2
474           myDS->AddInterf(nE1, nE2);
475           //
476           BOPDS_CoupleOfPaveBlocks aCPB;
477           //
478           aCPB.SetPaveBlocks(aPB1, aPB2);
479           aCPB.SetIndexInterf(iX);
480           aCPB.SetTolerance(aTolVnew);
481           aMVCPB.Add(aVnew, aCPB);
482         }//case TopAbs_VERTEX: 
483           break;
484             //
485         case TopAbs_EDGE: {
486           if (aNbCPrts > 1) {
487             break;
488           }
489           //
490           Standard_Boolean bHasSameBounds;
491           bHasSameBounds=aPB1->HasSameBounds(aPB2);
492           if (!bHasSameBounds) {
493             break;
494           }
495           // 1
496           BOPDS_InterfEE& aEE=aEEs.Appended();
497           iX=aEEs.Length()-1;
498           aEE.SetIndices(nE1, nE2);
499           aEE.SetCommonPart(aCPart);
500           // 2
501           myDS->AddInterf(nE1, nE2);
502           //
503           BOPAlgo_Tools::FillMap<Handle(BOPDS_PaveBlock), TColStd_MapTransientHasher>(aPB1, aPB2, aMPBLPB, aAllocator);
504         }//case TopAbs_EDGE
505           break;
506         default:
507           break;
508       }//switch (aType) {
509     }//for (i=1; i<=aNbCPrts; i++) {
510   }//for (k=0; k < aNbFdgeEdge; ++k) {
511   // 
512   //=========================================
513   // post treatment
514   //=========================================
515   BOPAlgo_Tools::PerformCommonBlocks(aMPBLPB, aAllocator, myDS, myContext);
516   // Update vertices of common blocks with real CB tolerances
517   UpdateVerticesOfCB();
518
519   PerformNewVertices(aMVCPB, aAllocator);
520   //
521   if (aMEdges.Extent()) {
522     Standard_Integer aNbV = aMVCPB.Extent();
523     for (i = 1; i <= aNbV; ++i) {
524       Handle(BOPDS_PaveBlock) aPB1, aPB2;
525       const BOPDS_CoupleOfPaveBlocks& aCPB = aMVCPB.FindFromIndex(i);
526       aCPB.PaveBlocks(aPB1, aPB2);
527       //
528       aMEdges.Remove(aPB1->OriginalEdge());
529       aMEdges.Remove(aPB2->OriginalEdge());
530     }
531     //
532     SplitPaveBlocks(aMEdges, Standard_False);
533   }
534   //
535   //-----------------------------------------------------scope t
536   aMPBLPB.Clear();
537   aMVCPB.Clear();
538 }
539 //=======================================================================
540 //function : PerformVerticesEE
541 //purpose  : 
542 //=======================================================================
543 void BOPAlgo_PaveFiller::PerformNewVertices
544   (BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& theMVCPB,
545    const Handle(NCollection_BaseAllocator)& theAllocator,
546    const Standard_Boolean bIsEEIntersection)
547 {
548   Standard_Integer aNbV = theMVCPB.Extent();
549   if (!aNbV) {
550     return;
551   }
552   //
553   Standard_Real aTolAdd = myFuzzyValue / 2.;
554   //
555   // 1. Fuse the new vertices
556   TopTools_IndexedDataMapOfShapeListOfShape aImages;
557   TreatNewVertices(theMVCPB, aImages);
558   //
559   // 2. Add new vertices to myDS and connect indices to CPB structure
560   BOPDS_VectorOfInterfEE& aEEs = myDS->InterfEE();
561   BOPDS_VectorOfInterfEF& aEFs = myDS->InterfEF();
562   //
563   Standard_Integer i, aNb = aImages.Extent();
564   for (i = 1; i <= aNb; ++i) {
565     const TopoDS_Vertex& aV = TopoDS::Vertex(aImages.FindKey(i));
566     const TopTools_ListOfShape& aLVSD = aImages.FindFromIndex(i);
567     //
568     BOPDS_ShapeInfo aSI;
569     aSI.SetShapeType(TopAbs_VERTEX);
570     aSI.SetShape(aV);
571     Standard_Integer iV = myDS->Append(aSI);
572     //
573     BOPDS_ShapeInfo& aSIDS = myDS->ChangeShapeInfo(iV);
574     Bnd_Box& aBox = aSIDS.ChangeBox();
575     aBox.Add(BRep_Tool::Pnt(aV));
576     aBox.SetGap(BRep_Tool::Tolerance(aV) + aTolAdd);
577     //
578     TopTools_ListIteratorOfListOfShape aItLS(aLVSD);
579     for (; aItLS.More(); aItLS.Next()) {
580       const TopoDS_Shape& aVx = aItLS.Value();
581       BOPDS_CoupleOfPaveBlocks &aCPB = theMVCPB.ChangeFromKey(aVx);
582       aCPB.SetIndex(iV);
583       // update interference
584       Standard_Integer iX = aCPB.IndexInterf();
585       BOPDS_Interf *aInt = bIsEEIntersection ? (BOPDS_Interf*)(&aEEs(iX)) : (BOPDS_Interf*) (&aEFs(iX));
586       aInt->SetIndexNew(iV);
587     }
588   }
589   //
590   // 3. Map PaveBlock/ListOfVertices to add to this PaveBlock ->aMPBLI
591   BOPDS_IndexedDataMapOfPaveBlockListOfInteger aMPBLI(100, theAllocator);
592   for (i = 1; i <= aNbV; ++i) {
593     const BOPDS_CoupleOfPaveBlocks& aCPB = theMVCPB.FindFromIndex(i);
594     Standard_Integer iV = aCPB.Index();
595     //
596     Handle(BOPDS_PaveBlock) aPB[2];
597     aCPB.PaveBlocks(aPB[0], aPB[1]);
598     for (Standard_Integer j = 0; j < 2; ++j) {
599       TColStd_ListOfInteger *pLI = aMPBLI.ChangeSeek(aPB[j]);
600       if (!pLI) {
601         pLI = &aMPBLI(aMPBLI.Add(aPB[j], TColStd_ListOfInteger(theAllocator)));
602       }
603       pLI->Append(iV);
604       //
605       if (aPB[0] == aPB[1]) {
606         break;
607       }
608     }
609   }
610   //
611   // 4. Compute Extra Paves and split Pave blocks by the Extra paves
612   IntersectVE(aMPBLI, Standard_False);
613 }
614 //=======================================================================
615 //function : TreatNewVertices
616 //purpose  : 
617 //=======================================================================
618 void BOPAlgo_PaveFiller::TreatNewVertices
619   (const BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& theMVCPB,
620    TopTools_IndexedDataMapOfShapeListOfShape& myImages)
621 {
622   //
623   // Prepare for intersection
624   TopTools_IndexedDataMapOfShapeReal aVerts;
625   Standard_Integer i, aNbV = theMVCPB.Extent();
626   for (i = 1; i <= aNbV; ++i) {
627     const TopoDS_Shape& aV = theMVCPB.FindKey(i);
628     Standard_Real aTol = theMVCPB.FindFromIndex(i).Tolerance();
629     aVerts.Add(aV, aTol);
630   }
631   //
632   // Perform intersection
633   TopTools_ListOfListOfShape aChains;
634   BOPAlgo_Tools::IntersectVertices(aVerts, myFuzzyValue, aChains);
635   //
636   // Treat the results - make new vertices for each chain
637   TopTools_ListOfListOfShape::Iterator aItC(aChains);
638   for (; aItC.More(); aItC.Next()) {
639     const TopTools_ListOfShape& aLVSD = aItC.Value();
640     //
641     TopoDS_Vertex aVNew;
642     BOPTools_AlgoTools::MakeVertex(aLVSD, aVNew);
643     myImages.Add(aVNew, aLVSD);
644   }
645 }
646 //=======================================================================
647 //function : FillShrunkData
648 //purpose  : 
649 //=======================================================================
650 void BOPAlgo_PaveFiller::FillShrunkData(Handle(BOPDS_PaveBlock)& thePB)
651 {
652   // Vertices
653   Standard_Integer nV1, nV2;
654   thePB->Indices(nV1, nV2);
655   const TopoDS_Vertex& aV1=(*(TopoDS_Vertex *)(&myDS->Shape(nV1))); 
656   const TopoDS_Vertex& aV2=(*(TopoDS_Vertex *)(&myDS->Shape(nV2))); 
657   // Get the edge
658   Standard_Integer nE = -1;
659   if (!thePB->HasEdge(nE))
660   {
661     nE = thePB->OriginalEdge();
662     if (nE < 0)
663       return;
664   }
665
666   const TopoDS_Edge& aE=(*(TopoDS_Edge *)(&myDS->Shape(nE))); 
667   // Range
668   Standard_Real aT1, aT2;
669   thePB->Range(aT1, aT2);
670   //
671   IntTools_ShrunkRange aSR;
672   aSR.SetContext(myContext);
673   aSR.SetData(aE, aT1, aT2, aV1, aV2);
674   aSR.Perform();
675   // Analyze the results of computations
676   AnalyzeShrunkData(thePB, aSR);
677 }
678 //=======================================================================
679 // function: AnalyzeShrunkData
680 // purpose: 
681 //=======================================================================
682 void BOPAlgo_PaveFiller::AnalyzeShrunkData(const Handle(BOPDS_PaveBlock)& thePB,
683                                            const IntTools_ShrunkRange& theSR)
684 {
685   // in case of error treat the warning status
686   Standard_Boolean bWholeEdge = Standard_False;
687   TopoDS_Shape aWarnShape;
688   //
689   if (!theSR.IsDone() || !theSR.IsSplittable()) {
690     Standard_Real aEFirst, aELast, aPBFirst, aPBLast;
691     BRep_Tool::Range(theSR.Edge(), aEFirst, aELast);
692     thePB->Range(aPBFirst, aPBLast);
693     bWholeEdge = !(aPBFirst > aEFirst || aPBLast < aELast);
694     if (bWholeEdge && thePB->OriginalEdge() >= 0) {
695       aWarnShape = theSR.Edge();
696     }
697     else {
698       const TopoDS_Shape& aV1 = myDS->Shape(thePB->Pave1().Index());
699       const TopoDS_Shape& aV2 = myDS->Shape(thePB->Pave2().Index());
700       BRep_Builder().MakeCompound(TopoDS::Compound(aWarnShape));
701       BRep_Builder().Add(aWarnShape, theSR.Edge());
702       BRep_Builder().Add(aWarnShape, aV1);
703       BRep_Builder().Add(aWarnShape, aV2);
704     }
705     //
706     if (!theSR.IsDone()) {
707       if (bWholeEdge)
708         AddWarning (new BOPAlgo_AlertTooSmallEdge (aWarnShape));
709       else
710         AddWarning (new BOPAlgo_AlertBadPositioning (aWarnShape));
711       Standard_Real aTS1, aTS2;
712       theSR.ShrunkRange(aTS1, aTS2);
713       thePB->SetShrunkData(aTS1, aTS2, Bnd_Box(), Standard_False);
714       return;
715     }
716     //
717     if (bWholeEdge)
718       AddWarning (new BOPAlgo_AlertNotSplittableEdge (aWarnShape));
719     else
720       AddWarning (new BOPAlgo_AlertBadPositioning (aWarnShape));
721   }
722   //
723   Standard_Real aTS1, aTS2;
724   theSR.ShrunkRange(aTS1, aTS2);
725   Bnd_Box aBox = theSR.BndBox();
726   aBox.SetGap(aBox.GetGap() + myFuzzyValue / 2.);
727   thePB->SetShrunkData(aTS1, aTS2, aBox, theSR.IsSplittable());
728 }
729 //=======================================================================
730 //function : ForceInterfVE
731 //purpose  : 
732 //=======================================================================
733 Standard_Boolean BOPAlgo_PaveFiller::ForceInterfVE(const Standard_Integer nV,
734                                                    Handle(BOPDS_PaveBlock)& aPB,
735                                                    TColStd_MapOfInteger& theMEdges)
736 {
737   Standard_Integer nE, nVx, nVSD, iFlag;
738   Standard_Real aT, aTolVNew;
739   //
740   nE = aPB->OriginalEdge();
741   //
742   const BOPDS_ShapeInfo& aSIE=myDS->ShapeInfo(nE);
743   if (aSIE.HasSubShape(nV)) {
744     return Standard_True;
745   }
746   //
747   if (myDS->HasInterf(nV, nE)) {
748     return Standard_True;
749   }
750   //
751   if (myDS->HasInterfShapeSubShapes(nV, nE)) {
752     return Standard_True;
753   }
754   //
755   if (aPB->Pave1().Index() == nV || 
756       aPB->Pave2().Index() == nV) {
757     return Standard_True;
758   }
759   //
760   nVx = nV;
761   if (myDS->HasShapeSD(nV, nVSD)) {
762     nVx = nVSD;
763   }
764   //
765   const TopoDS_Vertex& aV = *(TopoDS_Vertex*)&myDS->Shape(nVx);
766   const TopoDS_Edge&   aE = *(TopoDS_Edge*)  &myDS->Shape(nE);
767   //
768   iFlag = myContext->ComputeVE(aV, aE, aT, aTolVNew, myFuzzyValue);
769   if (iFlag == 0 || iFlag == -4) {
770     BOPDS_Pave aPave;
771     //
772     //
773     BOPDS_VectorOfInterfVE& aVEs=myDS->InterfVE();
774     aVEs.SetIncrement(10);
775     // 1
776     BOPDS_InterfVE& aVE=aVEs.Appended();
777     aVE.SetIndices(nV, nE);
778     aVE.SetParameter(aT);
779     // 2
780     myDS->AddInterf(nV, nE);
781     //
782     // 3 update vertex V/E if necessary
783     nVx=UpdateVertex(nV, aTolVNew);
784     // 4
785     if (myDS->IsNewShape(nVx)) {
786       aVE.SetIndexNew(nVx);
787     }
788     // 5 append ext pave to pave block
789     aPave.SetIndex(nVx);
790     aPave.SetParameter(aT);
791     aPB->AppendExtPave(aPave);
792     //
793     theMEdges.Add(nE);
794     //
795     // check for self-interference
796     Standard_Integer iRV = myDS->Rank(nV);
797     if (iRV >= 0 && iRV == myDS->Rank(nE)) {
798       // add warning status
799       TopoDS_Compound aWC;
800       BRep_Builder().MakeCompound(aWC);
801       BRep_Builder().Add(aWC, aV);
802       BRep_Builder().Add(aWC, aE);
803       AddWarning (new BOPAlgo_AlertSelfInterferingShape (aWC));
804     }
805     return Standard_True;
806   }
807   return Standard_False;
808 }
809
810 //=======================================================================
811 //function : GetPBBox
812 //purpose  : 
813 //=======================================================================
814 Standard_Boolean BOPAlgo_PaveFiller::GetPBBox(const TopoDS_Edge& theE,
815                                               const Handle(BOPDS_PaveBlock)& thePB,
816                                               BOPAlgo_DataMapOfPaveBlockBndBox& thePBBox,
817                                               Standard_Real& theFirst,
818                                               Standard_Real& theLast,
819                                               Standard_Real& theSFirst,
820                                               Standard_Real& theSLast,
821                                               Bnd_Box& theBox)
822 {
823   thePB->Range(theFirst, theLast);
824   // check the validity of PB's range
825   Standard_Boolean bValid = theLast - theFirst > Precision::PConfusion();
826   if (!bValid) {
827     return bValid;
828   }
829   //
830   // check shrunk data
831   if (thePB->HasShrunkData()) {
832     Standard_Boolean bIsSplittable;
833     thePB->ShrunkData(theSFirst, theSLast, theBox, bIsSplittable);
834     return bValid;
835   }
836   //
837   theSFirst = theFirst;
838   theSLast = theLast;
839   // check the map
840   if (thePBBox.IsBound(thePB)) {
841     theBox = thePBBox.Find(thePB);
842   }
843   else {
844     // build bounding box
845     BRepAdaptor_Curve aBAC(theE);
846     Standard_Real aTol = BRep_Tool::Tolerance(theE) + Precision::Confusion();
847     BndLib_Add3dCurve::Add(aBAC, theSFirst, theSLast, aTol, theBox);
848     thePBBox.Bind(thePB, theBox);
849   }
850   return bValid;
851 }
852
853 //=======================================================================
854 //function : UpdateVerticesOfCB
855 //purpose  : 
856 //=======================================================================
857 void BOPAlgo_PaveFiller::UpdateVerticesOfCB()
858 {
859   // Fence map to avoid checking same Common block twice
860   BOPDS_MapOfPaveBlock aMPBFence;
861
862   BOPDS_VectorOfListOfPaveBlock& aPBP = myDS->ChangePaveBlocksPool();
863   const Standard_Integer aNbPBP = aPBP.Length();
864   for (Standard_Integer i = 0; i < aNbPBP; ++i)
865   {
866     const BOPDS_ListOfPaveBlock& aLPB = aPBP(i);
867     BOPDS_ListIteratorOfListOfPaveBlock itPB(aLPB);
868     for (; itPB.More(); itPB.Next())
869     {
870       const Handle(BOPDS_CommonBlock)& aCB = myDS->CommonBlock(itPB.Value());
871       if (aCB.IsNull())
872         continue;
873
874       const Handle(BOPDS_PaveBlock)& aPBR = aCB->PaveBlock1();
875       if (!aMPBFence.Add(aPBR))
876         continue;
877
878       Standard_Real aTolCB = aCB->Tolerance();
879       if (aTolCB > 0.)
880       {
881         UpdateVertex(aPBR->Pave1().Index(), aTolCB);
882         UpdateVertex(aPBR->Pave2().Index(), aTolCB);
883       }
884     }
885   }
886 }
887
888 //=======================================================================
889 //function : ForceInterfEE
890 //purpose  : 
891 //=======================================================================
892 void BOPAlgo_PaveFiller::ForceInterfEE()
893 {
894   // Now that we have vertices increased and unified, try to find additional
895   // common blocks among the pairs of edges.
896   // Since all real intersections should have already happened, here we
897   // are interested in common blocks only, thus we need to check only
898   // those pairs of pave blocks with the same bounding vertices.
899
900   Handle(NCollection_IncAllocator) anAlloc = new NCollection_IncAllocator;
901
902   // Initialize pave blocks for all vertices which participated in intersections
903   const Standard_Integer aNbS = myDS->NbSourceShapes();
904   for (Standard_Integer i = 0; i < aNbS; ++i)
905   {
906     const BOPDS_ShapeInfo& aSI = myDS->ShapeInfo(i);
907     if (aSI.ShapeType() == TopAbs_VERTEX)
908     {
909       if (myDS->HasInterf(i))
910         myDS->InitPaveBlocksForVertex(i);
911     }
912   }
913
914   // Fill the connection map from bounding vertices to pave blocks
915   // having those bounding vertices
916   NCollection_IndexedDataMap<BOPDS_Pair,
917                              BOPDS_ListOfPaveBlock,
918                              BOPDS_PairMapHasher> aPBMap(1, anAlloc);
919   // Fence map of pave blocks
920   BOPDS_MapOfPaveBlock aMPBFence(1, anAlloc);
921
922   for (Standard_Integer i = 0; i < aNbS; ++i)
923   {
924     const BOPDS_ShapeInfo& aSI = myDS->ShapeInfo(i);
925     if (aSI.ShapeType() != TopAbs_EDGE)
926       // Not an edge
927       continue;
928
929     if (!aSI.HasReference())
930       // Edge has no pave blocks
931       continue;
932
933     if (aSI.HasFlag())
934       // Degenerated edge
935       continue;
936
937     const BOPDS_ListOfPaveBlock& aLPB = myDS->PaveBlocks(i);
938     BOPDS_ListIteratorOfListOfPaveBlock aItLPB(aLPB);
939     for (; aItLPB.More(); aItLPB.Next())
940     {
941       const Handle(BOPDS_PaveBlock)& aPB = aItLPB.Value();
942       const Handle(BOPDS_PaveBlock)& aPBR = myDS->RealPaveBlock(aPB);
943       if (!aMPBFence.Add(aPBR))
944         continue;
945
946       // Get indices
947       Standard_Integer nV1, nV2;
948       aPBR->Indices(nV1, nV2);
949
950       // Add pave block to a map
951       BOPDS_Pair aPair(nV1, nV2);
952       BOPDS_ListOfPaveBlock *pList = aPBMap.ChangeSeek(aPair);
953       if (!pList)
954         pList = &aPBMap(aPBMap.Add(aPair, BOPDS_ListOfPaveBlock(anAlloc)));
955       pList->Append(aPBR);
956     }
957   }
958
959   Standard_Integer aNbPB = aPBMap.Extent();
960   if (!aNbPB)
961     return;
962
963   const Standard_Boolean bSICheckMode = (myArguments.Extent() == 1);
964
965   // Prepare pave blocks with the same vertices for intersection.
966   BOPAlgo_VectorOfEdgeEdge aVEdgeEdge;
967
968   for (Standard_Integer i = 1; i <= aNbPB; ++i)
969   {
970     const BOPDS_ListOfPaveBlock& aLPB = aPBMap(i);
971     if (aLPB.Extent() < 2)
972       continue;
973
974     const BOPDS_Pair& aPair = aPBMap.FindKey(i);
975     Standard_Integer nV1, nV2;
976     aPair.Indices(nV1, nV2);
977
978     const TopoDS_Vertex& aV1 = TopoDS::Vertex(myDS->Shape(nV1));
979     const TopoDS_Vertex& aV2 = TopoDS::Vertex(myDS->Shape(nV2));
980
981     // Use the max tolerance of vertices as Fuzzy value for intersection of edges.
982     // In the Self-Interference check mode we are interested in real
983     // intersections only, so use only the real tolerance of edges,
984     // no need to use the extended tolerance.
985     Standard_Real aTolAdd = (bSICheckMode ? myFuzzyValue :
986       2 * Max(BRep_Tool::Tolerance(aV1), BRep_Tool::Tolerance(aV2)));
987
988     // All possible pairs combined from the list <aLPB> should be checked
989     BOPDS_ListIteratorOfListOfPaveBlock aItLPB1(aLPB);
990     for (; aItLPB1.More(); aItLPB1.Next())
991     {
992       const Handle(BOPDS_PaveBlock)& aPB1 = aItLPB1.Value();
993       const Handle(BOPDS_CommonBlock)& aCB1 = myDS->CommonBlock(aPB1);
994       const Standard_Integer nE1 = aPB1->OriginalEdge();
995       const Standard_Integer iR1 = myDS->Rank(nE1);
996       const TopoDS_Edge& aE1 = TopoDS::Edge(myDS->Shape(nE1));
997       Standard_Real aT11, aT12;
998       aPB1->Range(aT11, aT12);
999       BRepAdaptor_Curve aBAC1(aE1);
1000       gp_Pnt aPm;
1001       gp_Vec aVTgt1;
1002       aBAC1.D1((aT11 + aT12) * 0.5, aPm, aVTgt1);
1003       if (aVTgt1.SquareMagnitude() < gp::Resolution())
1004         continue;
1005       aVTgt1.Normalize();
1006
1007       BOPDS_ListIteratorOfListOfPaveBlock aItLPB2 = aItLPB1;
1008       for (aItLPB2.Next(); aItLPB2.More(); aItLPB2.Next())
1009       {
1010         const Handle(BOPDS_PaveBlock)& aPB2 = aItLPB2.Value();
1011         const Handle(BOPDS_CommonBlock)& aCB2 = myDS->CommonBlock(aPB2);
1012         const Standard_Integer nE2 = aPB2->OriginalEdge();
1013         const Standard_Integer iR2 = myDS->Rank(nE2);
1014
1015         // Check that the edges came from different arguments
1016         if (iR1 == iR2)
1017         {
1018           // If the sharing of the vertices is not original, but has been acquired
1019           // during the operation, check the coincidence of the edges even if
1020           // they came from the same argument
1021           if ((!myDS->IsNewShape(nV1) && (myDS->Rank(nV1) == iR1)) ||
1022               (!myDS->IsNewShape(nV2) && (myDS->Rank(nV2) == iR2)))
1023             continue;
1024         }
1025
1026         // Check that the Pave blocks do not form the Common block already
1027         if (!aCB1.IsNull() && !aCB2.IsNull())
1028         {
1029           if (aCB1 == aCB2)
1030             continue;
1031         }
1032
1033         const TopoDS_Edge& aE2 = TopoDS::Edge(myDS->Shape(nE2));
1034         Standard_Real aT21, aT22;
1035         aPB2->Range(aT21, aT22);
1036
1037         // Check the angle between edges in the middle point.
1038         // If the angle is more than 25 degrees, do not use the additional
1039         // tolerance, as it may lead to undesired unification of edges
1040         Standard_Boolean bUseAddTol = Standard_True;
1041         {
1042           BRepAdaptor_Curve aBAC2(aE2);
1043           if (aBAC1.GetType() != GeomAbs_Line ||
1044               aBAC2.GetType() != GeomAbs_Line)
1045           {
1046             GeomAPI_ProjectPointOnCurve& aProjPC = myContext->ProjPC(aE2);
1047             aProjPC.Perform(aPm);
1048             if (!aProjPC.NbPoints())
1049               continue;
1050
1051             gp_Pnt aPm2;
1052             gp_Vec aVTgt2;
1053             aBAC2.D1(aProjPC.LowerDistanceParameter(), aPm2, aVTgt2);
1054             if (aVTgt2.SquareMagnitude() < gp::Resolution())
1055               continue;
1056
1057             // The angle should be close to zero
1058             Standard_Real aCos = aVTgt1.Dot (aVTgt2.Normalized());
1059             if (Abs(aCos) < 0.9063)
1060               bUseAddTol = Standard_False;
1061           }
1062         }
1063
1064         // Add pair for intersection
1065         BOPAlgo_EdgeEdge& anEdgeEdge = aVEdgeEdge.Appended();
1066         anEdgeEdge.UseQuickCoincidenceCheck(Standard_True);
1067         anEdgeEdge.SetPaveBlock1(aPB1);
1068         anEdgeEdge.SetPaveBlock2(aPB2);
1069         anEdgeEdge.SetEdge1(aE1, aT11, aT12);
1070         anEdgeEdge.SetEdge2(aE2, aT21, aT22);
1071         anEdgeEdge.SetBoxes (myDS->ShapeInfo(nE1).Box(), myDS->ShapeInfo (nE2).Box());
1072         if (bUseAddTol)
1073           anEdgeEdge.SetFuzzyValue(myFuzzyValue + aTolAdd);
1074         else
1075           anEdgeEdge.SetFuzzyValue(myFuzzyValue);
1076         anEdgeEdge.SetProgressIndicator(*myProgressScope);
1077       }
1078     }
1079   }
1080
1081   Standard_Integer aNbPairs = aVEdgeEdge.Length();
1082   if (!aNbPairs)
1083     return;
1084
1085   aPBMap.Clear();
1086   aMPBFence.Clear();
1087   anAlloc->Reset();
1088
1089   // Perform intersection of the found pairs
1090   BOPTools_Parallel::Perform (myRunParallel, aVEdgeEdge);
1091
1092   BOPDS_VectorOfInterfEE& aEEs = myDS->InterfEE();
1093   if (aEEs.IsEmpty())
1094     aEEs.SetIncrement(10);
1095
1096   // Analyze the results of intersection looking for TopAbs_EDGE
1097   // intersection type only.
1098
1099   BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock aMPBLPB(1, anAlloc);
1100
1101   for (Standard_Integer i = 0; i < aNbPairs; ++i)
1102   {
1103     BOPAlgo_EdgeEdge& anEdgeEdge = aVEdgeEdge(i);
1104     if (!anEdgeEdge.IsDone() || anEdgeEdge.HasErrors())
1105     {
1106       // Warn about failed intersection of sub-shapes
1107       const TopoDS_Shape& aE1 = myDS->Shape(anEdgeEdge.PaveBlock1()->OriginalEdge());
1108       const TopoDS_Shape& aE2 = myDS->Shape(anEdgeEdge.PaveBlock2()->OriginalEdge());
1109       AddIntersectionFailedWarning(aE1, aE2);
1110       continue;
1111     }
1112
1113     const IntTools_SequenceOfCommonPrts& aCParts = anEdgeEdge.CommonParts();
1114     if (aCParts.Length() != 1)
1115       continue;
1116
1117     const IntTools_CommonPrt& aCP = aCParts(1);
1118     if (aCP.Type() != TopAbs_EDGE)
1119       continue;
1120
1121     Handle(BOPDS_PaveBlock) aPB[] = {anEdgeEdge.PaveBlock1(), anEdgeEdge.PaveBlock2()};
1122     const Standard_Integer nE1 = aPB[0]->OriginalEdge();
1123     const Standard_Integer nE2 = aPB[1]->OriginalEdge();
1124
1125     if (myDS->Rank(nE1) == myDS->Rank(nE2))
1126     {
1127       // Add acquired self-interference warning
1128       TopoDS_Compound aWC;
1129       BRep_Builder().MakeCompound(aWC);
1130       BRep_Builder().Add(aWC, myDS->Shape(nE1));
1131       BRep_Builder().Add(aWC, myDS->Shape(nE2));
1132       AddWarning(new BOPAlgo_AlertAcquiredSelfIntersection(aWC));
1133     }
1134
1135     BOPDS_InterfEE& aEE = aEEs.Appended();
1136     aEE.SetIndices(nE1, nE2);
1137     aEE.SetCommonPart(aCP);
1138     myDS->AddInterf(nE1, nE2);
1139
1140     // Fill map for common blocks creation
1141     for (Standard_Integer j = 0; j < 2; ++j)
1142     {
1143       if (myDS->IsCommonBlock(aPB[j]))
1144       {
1145         const BOPDS_ListOfPaveBlock& aLPBCB = myDS->CommonBlock(aPB[j])->PaveBlocks();
1146         BOPDS_ListIteratorOfListOfPaveBlock aItLPB(aLPBCB);
1147         for (; aItLPB.More(); aItLPB.Next())
1148           BOPAlgo_Tools::FillMap<Handle(BOPDS_PaveBlock),
1149                            TColStd_MapTransientHasher>(aPB[j], aItLPB.Value(), aMPBLPB, anAlloc);
1150       }
1151     }
1152     BOPAlgo_Tools::FillMap<Handle(BOPDS_PaveBlock),
1153                            TColStd_MapTransientHasher>(aPB[0], aPB[1], aMPBLPB, anAlloc);
1154   }
1155
1156   // Create new common blocks of coinciding pairs.
1157   BOPAlgo_Tools::PerformCommonBlocks(aMPBLPB, anAlloc, myDS);
1158 }