0026619: Tolerances of operands are modified using bop
[occt.git] / src / BOPAlgo / BOPAlgo_PaveFiller_5.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 <Precision.hxx>
20
21 #include <Bnd_Box.hxx>
22 #include <BOPAlgo_PaveFiller.hxx>
23 #include <BOPAlgo_SectionAttribute.hxx>
24 #include <BOPAlgo_Tools.hxx>
25 #include <BOPCol_MapOfInteger.hxx>
26 #include <BOPCol_NCVector.hxx>
27 #include <BOPCol_Parallel.hxx>
28 #include <BOPCol_DataMapOfShapeReal.hxx>
29 #include <BOPDS_CommonBlock.hxx>
30 #include <BOPDS_CoupleOfPaveBlocks.hxx>
31 #include <BOPDS_Curve.hxx>
32 #include <BOPDS_DataMapOfPaveBlockListOfInteger.hxx>
33 #include <BOPDS_DS.hxx>
34 #include <BOPDS_Interf.hxx>
35 #include <BOPDS_Iterator.hxx>
36 #include <BOPDS_MapOfPaveBlock.hxx>
37 #include <BOPDS_Pave.hxx>
38 #include <BOPDS_PaveBlock.hxx>
39 #include <BOPTools_AlgoTools.hxx>
40 #include <BRep_Builder.hxx>
41 #include <BRep_Tool.hxx>
42 #include <BRepAdaptor_Curve.hxx>
43 #include <BRepBndLib.hxx>
44 #include <GeomAPI_ProjectPointOnSurf.hxx>
45 #include <gp_Pnt.hxx>
46 #include <IntTools_CommonPrt.hxx>
47 #include <IntTools_Context.hxx>
48 #include <IntTools_EdgeFace.hxx>
49 #include <IntTools_Range.hxx>
50 #include <IntTools_SequenceOfCommonPrts.hxx>
51 #include <IntTools_Tools.hxx>
52 #include <TopoDS.hxx>
53 #include <TopoDS_Edge.hxx>
54 #include <TopoDS_Face.hxx>
55 #include <TopoDS_Vertex.hxx>
56
57 //=======================================================================
58 //class    : BOPAlgo_EdgeFace
59 //purpose  : 
60 //=======================================================================
61 class BOPAlgo_EdgeFace : 
62   public IntTools_EdgeFace,
63   public BOPAlgo_Algo {
64  
65  public:
66   DEFINE_STANDARD_ALLOC
67   
68   BOPAlgo_EdgeFace() : 
69     IntTools_EdgeFace(), 
70     BOPAlgo_Algo(),
71     myIE(-1), myIF(-1) {
72   };
73   //
74   virtual ~BOPAlgo_EdgeFace(){
75   };
76   //
77   void SetIndices(const Standard_Integer nE,
78                   const Standard_Integer nF) {
79     myIE=nE;
80     myIF=nF;
81   }
82   //
83   void Indices(Standard_Integer& nE,
84                Standard_Integer& nF) {
85     nE=myIE;
86     nF=myIF;
87   }
88   //
89   void SetNewSR(const IntTools_Range& aR){
90     myNewSR=aR;
91   }
92   //
93   IntTools_Range& NewSR(){
94     return myNewSR;
95   }
96   //
97   void SetPaveBlock(const Handle(BOPDS_PaveBlock)& aPB) {
98     myPB=aPB;
99   }
100   //
101   Handle(BOPDS_PaveBlock)& PaveBlock() {
102     return myPB;
103   }
104   //
105   virtual void Perform() {
106     BOPAlgo_Algo::UserBreak();
107     IntTools_EdgeFace::Perform();
108   }
109   //
110  protected:
111   Standard_Integer myIE;
112   Standard_Integer myIF;
113   IntTools_Range myNewSR;
114   Handle(BOPDS_PaveBlock) myPB;
115 };
116 //
117 //=======================================================================
118 typedef BOPCol_NCVector<BOPAlgo_EdgeFace> BOPAlgo_VectorOfEdgeFace; 
119 //
120 typedef BOPCol_ContextFunctor 
121   <BOPAlgo_EdgeFace,
122   BOPAlgo_VectorOfEdgeFace,
123   Handle(IntTools_Context), 
124   IntTools_Context> BOPAlgo_EdgeFaceFunctor;
125 //
126 typedef BOPCol_ContextCnt 
127   <BOPAlgo_EdgeFaceFunctor,
128   BOPAlgo_VectorOfEdgeFace,
129   Handle(IntTools_Context)> BOPAlgo_EdgeFaceCnt;
130 //
131 //=======================================================================
132 //function : PerformEF
133 //purpose  : 
134 //=======================================================================
135 void BOPAlgo_PaveFiller::PerformEF()
136 {
137   Standard_Integer iSize;
138   //
139   myErrorStatus=0;
140   //
141   FillShrunkData(TopAbs_EDGE, TopAbs_FACE);
142   //
143   myIterator->Initialize(TopAbs_EDGE, TopAbs_FACE);
144   iSize=myIterator->ExpectedLength();
145   if (!iSize) {
146     return; 
147   }
148   //
149   Standard_Boolean bJustAdd, bV[2];
150   Standard_Integer nE, nF, aDiscretize, i, aNbCPrts, iX, nV[2];
151   Standard_Integer aNbEdgeFace, k;
152   Standard_Real aTolE, aTolF, aTS1, aTS2, aT1, aT2, aDeflection;
153   Handle(NCollection_BaseAllocator) aAllocator;
154   TopAbs_ShapeEnum aType;
155   BOPDS_ListIteratorOfListOfPaveBlock aIt;
156   BOPAlgo_VectorOfEdgeFace aVEdgeFace; 
157   //-----------------------------------------------------scope f
158   //
159   aAllocator=NCollection_BaseAllocator::CommonBaseAllocator();
160   //
161   BOPCol_MapOfInteger aMIEFC(100, aAllocator);
162   BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks aMVCPB(100, aAllocator);
163   BOPDS_IndexedDataMapOfPaveBlockListOfInteger aMPBLI(100, aAllocator);
164   //
165   aDiscretize=35;
166   aDeflection=0.01;
167   //
168   BOPDS_VectorOfInterfEF& aEFs=myDS->InterfEF();
169   aEFs.SetIncrement(iSize);
170   //
171   for (; myIterator->More(); myIterator->Next()) {
172     myIterator->Value(nE, nF, bJustAdd);
173     if(bJustAdd) {
174       continue;
175     }
176     //
177     const BOPDS_ShapeInfo& aSIE=myDS->ShapeInfo(nE);
178     if (aSIE.HasFlag()){//degenerated 
179       continue;
180     }
181     //
182     const TopoDS_Edge& aE=(*(TopoDS_Edge *)(&aSIE.Shape()));
183     const TopoDS_Face& aF=(*(TopoDS_Face *)(&myDS->Shape(nF)));
184     const Bnd_Box& aBBF=myDS->ShapeInfo(nF).Box(); 
185     //
186     BOPDS_FaceInfo& aFI=myDS->ChangeFaceInfo(nF);
187     const BOPDS_IndexedMapOfPaveBlock& aMPBF=aFI.PaveBlocksOn();
188     //
189     aTolE=BRep_Tool::Tolerance(aE);
190     aTolF=BRep_Tool::Tolerance(aF);
191     //
192     BOPDS_ListOfPaveBlock& aLPB=myDS->ChangePaveBlocks(nE);
193     aIt.Initialize(aLPB);
194     for (; aIt.More(); aIt.Next()) {
195       Handle(BOPDS_PaveBlock)& aPB=aIt.ChangeValue();
196       //
197       const Handle(BOPDS_PaveBlock) aPBR=myDS->RealPaveBlock(aPB);
198       if (aMPBF.Contains(aPBR)) {
199         continue;
200       }
201       //
202       if (!aPB->HasShrunkData()) {
203         continue;
204       }
205       //
206       Bnd_Box aBBE;
207       aPB->ShrunkData(aTS1, aTS2, aBBE);
208       //
209       if (aBBF.IsOut (aBBE)) {
210         continue;
211       }
212       //
213       BOPAlgo_EdgeFace& aEdgeFace=aVEdgeFace.Append1();
214       //
215       aEdgeFace.SetIndices(nE, nF);
216       aEdgeFace.SetPaveBlock(aPB);
217       //
218       aEdgeFace.SetEdge (aE);
219       aEdgeFace.SetFace (aF);
220       aEdgeFace.SetTolE (aTolE);
221       aEdgeFace.SetTolF (aTolF);
222       aEdgeFace.SetDiscretize (aDiscretize);
223       aEdgeFace.SetDeflection (aDeflection);
224       //
225       IntTools_Range aSR(aTS1, aTS2);
226       IntTools_Range anewSR=aSR;
227       BOPTools_AlgoTools::CorrectRange(aE, aF, aSR, anewSR);
228       aEdgeFace.SetNewSR(anewSR);
229       //
230       aPB->Range(aT1, aT2);
231       IntTools_Range aPBRange(aT1, aT2);
232       aSR = aPBRange;
233       BOPTools_AlgoTools::CorrectRange(aE, aF, aSR, aPBRange);
234       aEdgeFace.SetRange (aPBRange);
235       aEdgeFace.SetProgressIndicator(myProgressIndicator);
236       //
237     }//for (; aIt.More(); aIt.Next()) {
238   }//for (; myIterator->More(); myIterator->Next()) {
239   //
240   aNbEdgeFace=aVEdgeFace.Extent();
241   //=================================================================
242   BOPAlgo_EdgeFaceCnt::Perform(myRunParallel, aVEdgeFace, myContext);
243   //=================================================================
244   //
245   for (k=0; k < aNbEdgeFace; ++k) {
246     BOPAlgo_EdgeFace& aEdgeFace=aVEdgeFace(k);
247     if (!aEdgeFace.IsDone()) {
248       continue;
249     }
250     //~~~
251     aEdgeFace.Indices(nE, nF);
252     //
253     const TopoDS_Edge& aE=aEdgeFace.Edge();
254     const TopoDS_Face& aF=aEdgeFace.Face();
255     //
256     aTolE=aEdgeFace.TolE();
257     aTolF=aEdgeFace.TolF();
258     const IntTools_Range& anewSR=aEdgeFace.NewSR();
259     Handle(BOPDS_PaveBlock)& aPB=aEdgeFace.PaveBlock();
260     //
261     aPB->Range(aT1, aT2);
262     aPB->Indices(nV[0], nV[1]);
263     //
264     BOPDS_FaceInfo& aFI=myDS->ChangeFaceInfo(nF);
265     const BOPCol_MapOfInteger& aMIFOn=aFI.VerticesOn();
266     const BOPCol_MapOfInteger& aMIFIn=aFI.VerticesIn();
267     //~~~
268     const IntTools_SequenceOfCommonPrts& aCPrts=aEdgeFace.CommonParts();
269     aNbCPrts = aCPrts.Length();
270     //
271     Standard_Boolean bLinePlane = Standard_False;
272     if (aNbCPrts) {
273       BRepAdaptor_Curve aBAC(aE);
274       BRepAdaptor_Surface aBAS(aF, Standard_False);
275       //
276       bLinePlane = (aBAC.GetType() == GeomAbs_Line &&
277                     aBAS.GetType() == GeomAbs_Plane);
278     }
279
280     for (i=1; i<=aNbCPrts; ++i) {
281       const IntTools_CommonPrt& aCPart=aCPrts(i);
282       aType=aCPart.Type();
283       switch (aType) {
284         case TopAbs_VERTEX:  {
285           Standard_Boolean bIsOnPave[2];
286           Standard_Integer j;
287           Standard_Real aT, aTolToDecide; 
288           TopoDS_Vertex aVnew;
289           //
290           IntTools_Tools::VertexParameter(aCPart, aT);
291           BOPTools_AlgoTools::MakeNewVertex(aE, aT, aF, aVnew);
292           //
293           const IntTools_Range& aR=aCPart.Range1();
294           aTolToDecide=5.e-8;
295           //
296           IntTools_Range aR1(aT1,anewSR.First()),aR2(anewSR.Last(), aT2);
297           //
298           bIsOnPave[0]=IntTools_Tools::IsInRange(aR1, aR, aTolToDecide); 
299           bIsOnPave[1]=IntTools_Tools::IsInRange(aR2, aR, aTolToDecide); 
300           //
301           if ((bIsOnPave[0] && bIsOnPave[1]) || 
302               (bLinePlane && (bIsOnPave[0] || bIsOnPave[1]))) {
303             bV[0]=CheckFacePaves(nV[0], aMIFOn, aMIFIn);
304             bV[1]=CheckFacePaves(nV[1], aMIFOn, aMIFIn);
305             if (bV[0] && bV[1]) {
306               IntTools_CommonPrt aCP = aCPart;
307               aCP.SetType(TopAbs_EDGE);
308               BOPDS_InterfEF& aEF=aEFs.Append1();
309               iX=aEFs.Extent()-1;
310               aEF.SetIndices(nE, nF);
311               aEF.SetCommonPart(aCP);
312               myDS->AddInterf(nE, nF);
313               //
314               aMIEFC.Add(nF);
315               //           
316               BOPAlgo_Tools::FillMap(aPB, nF, aMPBLI, aAllocator);
317               break;
318             }
319           }
320           for (j=0; j<2; ++j) {
321             if (bIsOnPave[j]) {
322               bV[j]=CheckFacePaves(nV[j], aMIFOn, aMIFIn);
323               if (bV[j]) {
324                 const TopoDS_Vertex& aV=
325                   (*(TopoDS_Vertex *)(&myDS->Shape(nV[j])));
326                 //
327                 Standard_Real f, l, aTolVnew, aDistPP, aTolPC, aTolV;
328                 //
329                 const Handle(Geom_Curve)& aCur = BRep_Tool::Curve(aE, f, l);
330                 //
331                 gp_Pnt aP1 = BRep_Tool::Pnt(aV);
332                 gp_Pnt aP2 = aCur->Value(aT);
333                 //
334                 
335                 aDistPP=aP1.Distance(aP2);
336                 
337                 aTolPC=Precision::PConfusion();
338                 aTolV=BRep_Tool::Tolerance(aV);
339                 if (aDistPP > (aTolV+aTolPC)) {
340                   aTolVnew=Max(aTolE, aDistPP);
341                   UpdateVertex(nV[j], aTolVnew);
342               }
343               }
344               else {
345                 bIsOnPave[j] = ForceInterfVF(nV[j], nF);
346               }
347             }
348           }
349           //
350           if (!bIsOnPave[0] && !bIsOnPave[1]) {
351             if (CheckFacePaves(aVnew, aMIFOn)) {
352               continue;
353             }
354             //
355             Standard_Real aTolVnew = BRep_Tool::Tolerance(aVnew);
356             aTolVnew = Max(aTolVnew, Max(aTolE, aTolF));
357             BRep_Builder().UpdateVertex(aVnew, aTolVnew);
358             if (bLinePlane) {
359               // increase tolerance for Line/Plane intersection, but do not update 
360               // the vertex till its intersection with some other shape
361               IntTools_Range aCR = aCPart.Range1();
362               aTolVnew = Max(aTolVnew, (aCR.Last() - aCR.First()) / 2.);
363             }
364             //
365             const gp_Pnt& aPnew = BRep_Tool::Pnt(aVnew);
366             //
367             if (!myContext->IsPointInFace(aPnew, aF, aTolVnew)) {
368               continue;
369             }
370             //
371             aMIEFC.Add(nF);
372             // 1
373             BOPDS_InterfEF& aEF=aEFs.Append1();
374             iX=aEFs.Extent()-1;
375             aEF.SetIndices(nE, nF);
376             aEF.SetCommonPart(aCPart);
377             // 2
378             myDS->AddInterf(nE, nF);
379             // 3
380             BOPDS_CoupleOfPaveBlocks aCPB;
381             //
382             aCPB.SetPaveBlocks(aPB, aPB);
383             aCPB.SetIndexInterf(iX);
384             aCPB.SetTolerance(aTolVnew);
385             aMVCPB.Add(aVnew, aCPB);
386           }
387         }
388           break;
389         case TopAbs_EDGE:  {
390           aMIEFC.Add(nF);
391           //
392           // 1
393           BOPDS_InterfEF& aEF=aEFs.Append1();
394           iX=aEFs.Extent()-1;
395           aEF.SetIndices(nE, nF);
396           //
397           bV[0]=CheckFacePaves(nV[0], aMIFOn, aMIFIn);
398           bV[1]=CheckFacePaves(nV[1], aMIFOn, aMIFIn);
399           if (!bV[0] || !bV[1]) {
400             myDS->AddInterf(nE, nF);
401             break;
402           }
403           aEF.SetCommonPart(aCPart);
404           // 2
405           myDS->AddInterf(nE, nF);
406           // 3
407           BOPAlgo_Tools::FillMap(aPB, nF, aMPBLI, aAllocator);
408           
409         }
410           break; 
411         default:
412           break; 
413       }//switch (aType) {
414     }//for (i=1; i<=aNbCPrts; ++i) {
415   }// for (k=0; k < aNbEdgeEdge; ++k) {
416   // 
417   //=========================================
418   // post treatment
419   //=========================================
420   BOPAlgo_Tools::PerformCommonBlocks(aMPBLI, aAllocator, myDS);
421   PerformVerticesEF(aMVCPB, aAllocator);
422   //
423   // Update FaceInfoIn for all faces having EF common parts
424   BOPCol_MapIteratorOfMapOfInteger aItMI;
425   aItMI.Initialize(aMIEFC);
426   for (; aItMI.More(); aItMI.Next()) {
427     nF=aItMI.Value();
428     myDS->UpdateFaceInfoIn(nF);
429   }
430   // Refine FaceInfoOn to remove all formal pave blocks 
431   // made during EF processing 
432   //myDS->RefineFaceInfoOn();
433   //-----------------------------------------------------scope t
434   aMIEFC.Clear();
435   aMVCPB.Clear();
436   aMPBLI.Clear();
437   ////aAllocator.Nullify();
438 }
439 //=======================================================================
440 //function : PerformVerticesEF
441 //purpose  : 
442 //=======================================================================
443 Standard_Integer BOPAlgo_PaveFiller::PerformVerticesEF
444   (BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& theMVCPB,
445    const Handle(NCollection_BaseAllocator)& theAllocator)
446 {
447   Standard_Integer aNbV, iRet;
448   //
449   iRet=0;
450   aNbV=theMVCPB.Extent();
451   if (!aNbV) {
452     return iRet;
453   }
454   //
455   Standard_Integer nVx, nVSD, iV, iErr, nE, iFlag, iX, i, aNbPBLI;
456   Standard_Real aT, dummy;
457   TopoDS_Shape aV;
458   BOPCol_ListIteratorOfListOfShape aItLS;
459   BOPCol_ListIteratorOfListOfInteger aItLI;
460   BOPDS_PDS aPDS;
461   BOPDS_ShapeInfo aSI;
462   BOPDS_Pave aPave;
463   //
464   BOPCol_ListOfShape aLS(theAllocator);
465   BOPCol_DataMapOfShapeInteger aMVI(100, theAllocator);
466   BOPDS_IndexedDataMapOfPaveBlockListOfInteger aMPBLI(100, theAllocator);
467   BOPAlgo_PaveFiller aPF(theAllocator); 
468   BOPCol_DataMapOfShapeReal aMVIniTol;
469   //
470   aSI.SetShapeType(TopAbs_VERTEX);
471   BOPDS_VectorOfInterfEF& aEFs=myDS->InterfEF();
472   //
473   // 1 prepare arguments
474   for (i=1; i<=aNbV; ++i) {
475     const TopoDS_Vertex& aV = TopoDS::Vertex(theMVCPB.FindKey(i));
476     aLS.Append(aV);
477     // if an enlarged tolerance is associated with the vertex then update it 
478     // remembering its initial tolerance
479     Standard_Real aTolEnlarged = theMVCPB.FindFromIndex(i).Tolerance();
480     Standard_Real aIniTol = BRep_Tool::Tolerance(aV);
481     if (aTolEnlarged > aIniTol) {
482       aMVIniTol.Bind(aV, aIniTol);
483       BRep_Builder().UpdateVertex(aV, aTolEnlarged);
484     }
485   }
486   //
487   // 2 Fuse vertices
488   aPF.SetIsPrimary(Standard_False);
489   aPF.SetNonDestructive(myNonDestructive);
490   aPF.SetArguments(aLS);
491   aPF.Perform();
492   iErr=aPF.ErrorStatus();
493   if (iErr) {
494     iRet=1;
495     return iRet;
496   }
497   aPDS=aPF.PDS();
498   //
499   // Recompute common vertex for each SD group containing enlarged vertex;
500   // for that first fill in the map of SD vertex -> its counterparts
501   BOPCol_IndexedDataMapOfShapeListOfShape aImages;
502   aItLS.Initialize(aLS);
503   for (; aItLS.More(); aItLS.Next()) {
504     const TopoDS_Shape& aVx = aItLS.Value();
505     nVx = aPDS->Index(aVx);
506     //
507     if (aPDS->HasShapeSD(nVx, nVSD)) {
508       aV = aPDS->Shape(nVSD);
509     }
510     else {
511       aV = aVx;
512     }
513     BOPCol_ListOfShape* pLst = aImages.ChangeSeek(aV);
514     if (!pLst) {
515       pLst = &aImages.ChangeFromIndex(aImages.Add(aV, BOPCol_ListOfShape()));
516     }
517     pLst->Append(aVx);
518   }
519   // 3 Add new vertices to theDS; 
520   for (i = 1; i <= aImages.Extent(); i++) {
521     TopoDS_Vertex aV = TopoDS::Vertex(aImages.FindKey(i));
522     const BOPCol_ListOfShape& aLVSD = aImages.FindFromIndex(i);
523     Standard_Boolean isReset = Standard_False;
524     BOPCol_ListIteratorOfListOfShape it(aLVSD);
525     for (; it.More(); it.Next()) {
526       const TopoDS_Vertex& aVx = TopoDS::Vertex(it.Value());
527       const Standard_Real* pTolIni = aMVIniTol.Seek(aVx);
528       if (pTolIni) {
529         // reset enlarged vertex tolerance to the initial value
530         reinterpret_cast<BRep_TVertex*>(aVx.TShape().operator->())->Tolerance(*pTolIni);
531         isReset = Standard_True;
532       }
533     }
534     TopoDS_Vertex aVnew = aV;
535     if (isReset && aLVSD.Extent() > 1) {
536       // make new vertex again
537       BOPTools_AlgoTools::MakeVertex(aLVSD, aVnew);
538     }
539     // index of new vertex in theDS -> iV
540     aSI.SetShape(aVnew);
541     iV = myDS->Append(aSI);
542     //
543     BOPDS_ShapeInfo& aSIDS = myDS->ChangeShapeInfo(iV);
544     Bnd_Box& aBox = aSIDS.ChangeBox();
545     BRepBndLib::Add(aVnew, aBox);
546     aBox.SetGap(aBox.GetGap() + Precision::Confusion());
547     //
548     aMVI.Bind(aV, iV);
549   }
550   //
551   // 4 Map PaveBlock/ListOfVertices to add to this PaveBlock ->aMPBLI
552   aItLS.Initialize(aLS);
553   for (; aItLS.More(); aItLS.Next()) {
554     const TopoDS_Shape& aVx=aItLS.Value();
555     nVx=aPDS->Index(aVx);
556     //
557     if (aPDS->HasShapeSD(nVx, nVSD)) {
558       aV=aPDS->Shape(nVSD);
559     }
560     else {
561       aV=aVx;
562     }
563     iV = aMVI.Find(aV);
564     //
565     BOPDS_CoupleOfPaveBlocks &aCPB=theMVCPB.ChangeFromKey(aVx);
566     aCPB.SetIndex(iV);
567     // update EF interference
568     iX=aCPB.IndexInterf();
569     BOPDS_InterfEF& aEF=aEFs(iX);
570     aEF.SetIndexNew(iV);
571     // map aMPBLI
572     const Handle(BOPDS_PaveBlock)& aPB=aCPB.PaveBlock1();
573     if (aMPBLI.Contains(aPB)) {
574       BOPCol_ListOfInteger& aLI=aMPBLI.ChangeFromKey(aPB);
575       aLI.Append(iV);
576     }
577     else {
578       BOPCol_ListOfInteger aLI(theAllocator);
579       aLI.Append(iV);
580       aMPBLI.Add(aPB, aLI);
581     }
582   }
583   //
584   // 5 
585   // 5.1  Compute Extra Paves and 
586   // 5.2. Add Extra Paves to the PaveBlocks
587   aNbPBLI=aMPBLI.Extent();
588   for (i=1; i<=aNbPBLI; ++i) {
589     Handle(BOPDS_PaveBlock) aPB=aMPBLI.FindKey(i);
590     const BOPCol_ListOfInteger& aLI=aMPBLI.FindFromIndex(i);
591     nE=aPB->OriginalEdge();
592     const TopoDS_Edge& aE=(*(TopoDS_Edge *)(&myDS->Shape(nE)));
593     // 
594     aItLI.Initialize(aLI);
595     for (; aItLI.More(); aItLI.Next()) {
596       nVx=aItLI.Value();
597       const TopoDS_Vertex& aVx=(*(TopoDS_Vertex *)(&myDS->Shape(nVx)));
598       //
599       iFlag=myContext->ComputeVE (aVx, aE, aT, dummy);
600       if (!iFlag) {
601         aPave.SetIndex(nVx);
602         aPave.SetParameter(aT);
603         aPB->AppendExtPave(aPave);
604       }
605     }
606   }
607   // 6  Split PaveBlocks
608   for (i=1; i<=aNbPBLI; ++i) {
609     Handle(BOPDS_PaveBlock) aPB=aMPBLI.FindKey(i);
610     nE=aPB->OriginalEdge();
611     // 3
612     if (!myDS->IsCommonBlock(aPB)) {
613       myDS->UpdatePaveBlock(aPB);
614     }
615     else {
616       const Handle(BOPDS_CommonBlock)& aCB=myDS->CommonBlock(aPB);
617       myDS->UpdateCommonBlock(aCB);
618     }    
619   }//for (; aItMPBLI.More(); aItMPBLI.Next()) {
620   // 
621   return iRet;
622 }
623 //=======================================================================
624 // function: CheckFacePaves
625 // purpose: 
626 //=======================================================================
627 Standard_Boolean BOPAlgo_PaveFiller::CheckFacePaves 
628   (const Standard_Integer nVx,
629    const BOPCol_MapOfInteger& aMIFOn,
630    const BOPCol_MapOfInteger& aMIFIn)
631 {
632   Standard_Boolean bRet;
633   Standard_Integer nV;
634   BOPCol_MapIteratorOfMapOfInteger aIt;
635   //
636   bRet=Standard_False;
637   //
638   aIt.Initialize(aMIFOn);
639   for (; aIt.More(); aIt.Next()) {
640     nV=aIt.Value();
641     if (nV==nVx) {
642       bRet=!bRet;
643       return bRet;
644     }
645   }
646   aIt.Initialize(aMIFIn);
647   for (; aIt.More(); aIt.Next()) {
648     nV=aIt.Value();
649     if (nV==nVx) {
650       bRet=!bRet;
651       return bRet;
652     }
653   }
654   //
655   return bRet;
656 }
657 //=======================================================================
658 // function: CheckFacePaves
659 // purpose: 
660 //=======================================================================
661 Standard_Boolean BOPAlgo_PaveFiller::CheckFacePaves 
662   (const TopoDS_Vertex& aVnew,
663    const BOPCol_MapOfInteger& aMIF)
664 {
665   Standard_Boolean bRet;
666   Standard_Integer nV, iFlag;
667   BOPCol_MapIteratorOfMapOfInteger aIt;
668   //
669   bRet=Standard_True;
670   //
671   aIt.Initialize(aMIF);
672   for (; aIt.More(); aIt.Next()) {
673     nV=aIt.Value();
674     const TopoDS_Vertex& aV=(*(TopoDS_Vertex *)(&myDS->Shape(nV)));
675     iFlag=BOPTools_AlgoTools::ComputeVV(aVnew, aV);
676     if (!iFlag) {
677       return bRet;
678     }
679   }
680   //
681   return !bRet;
682 }
683 //=======================================================================
684 //function : ForceInterfVF
685 //purpose  : 
686 //=======================================================================
687 Standard_Boolean BOPAlgo_PaveFiller::ForceInterfVF
688   (const Standard_Integer nV, 
689    const Standard_Integer nF)
690 {
691   Standard_Boolean bRet;
692   Standard_Integer iFlag, nVx;
693   Standard_Real U, V, aTolVNew;
694   //
695   bRet = Standard_False;
696   const TopoDS_Vertex& aV = *(TopoDS_Vertex*)&myDS->Shape(nV);
697   const TopoDS_Face&   aF = *(TopoDS_Face*)  &myDS->Shape(nF);
698   //
699   iFlag = myContext->ComputeVF(aV, aF, U, V, aTolVNew);
700   if (iFlag == 0 || iFlag == -2) {
701     bRet=!bRet;
702   //
703     BOPDS_VectorOfInterfVF& aVFs=myDS->InterfVF();
704     aVFs.SetIncrement(10);
705     // 1
706     BOPDS_InterfVF& aVF=aVFs.Append1();
707     //
708     aVF.SetIndices(nV, nF);
709     aVF.SetUV(U, V);
710     // 2
711     myDS->AddInterf(nV, nF);
712     //
713     // 3 update vertex V/F if necessary
714     nVx=UpdateVertex(nV, aTolVNew);
715     // 4
716     if (myDS->IsNewShape(nVx)) {
717       aVF.SetIndexNew(nVx);
718     }
719     //
720     BOPDS_FaceInfo& aFI=myDS->ChangeFaceInfo(nF);
721     BOPCol_MapOfInteger& aMVIn=aFI.ChangeVerticesIn();
722     aMVIn.Add(nVx);
723   }
724   return bRet;
725 }