0024002: Overall code and build procedure refactoring -- automatic
[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_SectionAttribute.hxx>
22 #include <BOPAlgo_Tools.hxx>
23 #include <BOPCol_BoxBndTree.hxx>
24 #include <BOPCol_DataMapOfIntegerShape.hxx>
25 #include <BOPCol_DataMapOfShapeInteger.hxx>
26 #include <BOPCol_DataMapOfShapeListOfShape.hxx>
27 #include <BOPCol_IndexedDataMapOfShapeBox.hxx>
28 #include <BOPCol_NCVector.hxx>
29 #include <BOPCol_Parallel.hxx>
30 #include <BOPDS_CommonBlock.hxx>
31 #include <BOPDS_CoupleOfPaveBlocks.hxx>
32 #include <BOPDS_Curve.hxx>
33 #include <BOPDS_DataMapOfPaveBlockListOfInteger.hxx>
34 #include <BOPDS_DataMapOfPaveBlockListOfPaveBlock.hxx>
35 #include <BOPDS_DS.hxx>
36 #include <BOPDS_Interf.hxx>
37 #include <BOPDS_Iterator.hxx>
38 #include <BOPDS_MapOfPaveBlock.hxx>
39 #include <BOPDS_Pave.hxx>
40 #include <BOPDS_PaveBlock.hxx>
41 #include <BOPDS_VectorOfInterfEE.hxx>
42 #include <BOPTools_AlgoTools.hxx>
43 #include <BRep_Builder.hxx>
44 #include <BRep_Tool.hxx>
45 #include <BRepBndLib.hxx>
46 #include <BRepTools.hxx>
47 #include <GeomAPI_ProjectPointOnCurve.hxx>
48 #include <gp_Pnt.hxx>
49 #include <IntTools_CommonPrt.hxx>
50 #include <IntTools_Context.hxx>
51 #include <IntTools_EdgeEdge.hxx>
52 #include <IntTools_Range.hxx>
53 #include <IntTools_SequenceOfCommonPrts.hxx>
54 #include <IntTools_SequenceOfRanges.hxx>
55 #include <IntTools_ShrunkRange.hxx>
56 #include <IntTools_Tools.hxx>
57 #include <NCollection_IncAllocator.hxx>
58 #include <NCollection_UBTreeFiller.hxx>
59 #include <Precision.hxx>
60 #include <TopoDS_Compound.hxx>
61 #include <TopoDS_Edge.hxx>
62 #include <TopoDS_Face.hxx>
63 #include <TopoDS_Vertex.hxx>
64
65 //
66 //
67 //
68 //
69 //
70 //
71 /////////////////////////////////////////////////////////////////////////
72 //=======================================================================
73 //class    : BOPAlgo_EdgeEdge
74 //purpose  : 
75 //=======================================================================
76 class BOPAlgo_EdgeEdge : 
77   public IntTools_EdgeEdge,
78   public BOPAlgo_Algo {
79  
80  public:
81
82   DEFINE_STANDARD_ALLOC
83   //
84   BOPAlgo_EdgeEdge(): 
85     IntTools_EdgeEdge(),
86     BOPAlgo_Algo() {
87   };
88   //
89   virtual ~BOPAlgo_EdgeEdge(){
90   };
91   //
92   void SetPaveBlock1(const Handle(BOPDS_PaveBlock)& aPB) {
93     myPB1=aPB;
94   }
95   //
96   Handle(BOPDS_PaveBlock)& PaveBlock1() {
97     return myPB1;
98   }
99   //
100   void SetPaveBlock2(const Handle(BOPDS_PaveBlock)& aPB) {
101     myPB2=aPB;
102   }
103   //
104   Handle(BOPDS_PaveBlock)& PaveBlock2() {
105     return myPB2;
106   }
107   // 
108   virtual void Perform() {
109     BOPAlgo_Algo::UserBreak();
110     IntTools_EdgeEdge::Perform();
111   }
112   //
113  protected:
114   Handle(BOPDS_PaveBlock) myPB1;
115   Handle(BOPDS_PaveBlock) myPB2;
116 };
117 //
118 //=======================================================================
119 typedef BOPCol_NCVector
120   <BOPAlgo_EdgeEdge> BOPAlgo_VectorOfEdgeEdge; 
121 //
122 typedef BOPCol_Functor 
123   <BOPAlgo_EdgeEdge,
124   BOPAlgo_VectorOfEdgeEdge> BOPAlgo_EdgeEdgeFunctor;
125 //
126 typedef BOPCol_Cnt 
127   <BOPAlgo_EdgeEdgeFunctor,
128   BOPAlgo_VectorOfEdgeEdge> BOPAlgo_EdgeEdgeCnt;
129 //
130 /////////////////////////////////////////////////////////////////////////
131 //=======================================================================
132 //class    : BOPAlgo_TNV
133 //purpose  : 
134 //=======================================================================
135 class BOPAlgo_TNV : public BOPCol_BoxBndTreeSelector{
136  public:
137   BOPAlgo_TNV() 
138     : BOPCol_BoxBndTreeSelector(), myTree(NULL) {
139   };
140   //
141   ~BOPAlgo_TNV(){
142   };
143   //
144   void SetVertex(const TopoDS_Vertex& aV) {
145     myV=aV;
146   }
147   //
148   const TopoDS_Vertex& Vertex()const {
149     return myV;
150   }
151   //
152   void SetTree(BOPCol_BoxBndTree& aTree) {
153     myTree=&aTree;
154   }
155   //
156   void Perform() {
157     myTree->Select(*this);
158   }
159   //
160  protected:
161   TopoDS_Vertex myV;
162   BOPCol_BoxBndTree *myTree;
163 };
164 //
165 //=======================================================================
166 typedef BOPCol_NCVector
167   <BOPAlgo_TNV> BOPAlgo_VectorOfTNV; 
168 //
169 typedef BOPCol_Functor 
170   <BOPAlgo_TNV,
171   BOPAlgo_VectorOfTNV> BOPAlgo_TNVFunctor;
172 //
173 typedef BOPCol_Cnt 
174   <BOPAlgo_TNVFunctor,
175   BOPAlgo_VectorOfTNV> BOPAlgo_TNVCnt;
176 /////////////////////////////////////////////////////////////////////////
177 //=======================================================================
178 //class    : BOPAlgo_PVE
179 //purpose  : 
180 //=======================================================================
181 class BOPAlgo_PVE {
182  public:
183   BOPAlgo_PVE()
184     : myIV(-1), myIE(-1), myFlag(-1), myT(-1.) {
185   };
186   //
187   ~BOPAlgo_PVE(){
188   };
189   //
190   void SetIndices(const Standard_Integer nV,
191                   const Standard_Integer nE){
192     myIV=nV;
193     myIE=nE;
194   }
195   //
196   void Indices(Standard_Integer& nV,
197                Standard_Integer& nE) const {
198     nV=myIV;
199     nE=myIE;
200   }
201   //
202   void SetVertex(const TopoDS_Vertex& aV) {
203     myV=aV;
204   }
205   //
206   const TopoDS_Vertex& Vertex()const {
207     return myV;
208   }
209   //
210   void SetEdge(const TopoDS_Edge& aE) {
211     myE=aE;
212   }
213   //
214   const TopoDS_Edge& Edge()const {
215     return myE;
216   }
217   //
218   void SetPaveBlock(const Handle(BOPDS_PaveBlock)& aPB) {
219     myPB=aPB;
220   }
221   //
222   Handle(BOPDS_PaveBlock)& PaveBlock() {
223     return myPB;
224   }
225   //
226   Standard_Integer Flag()const {
227     return myFlag;
228   }
229   //
230   Standard_Real Parameter()const {
231     return myT;
232   }
233   //
234   void SetContext(const Handle(IntTools_Context)& aContext) {
235     myContext=aContext;
236   }
237   //
238   const Handle(IntTools_Context)& Context()const {
239     return myContext;
240   }
241   //
242   void Perform() {
243     myFlag=myContext->ComputeVE (myV, myE, myT);
244   };
245   //
246  protected:
247   Standard_Integer myIV;
248   Standard_Integer myIE;
249   Standard_Integer myFlag;
250   Standard_Real myT;
251   TopoDS_Vertex myV;
252   TopoDS_Edge myE;
253   Handle(BOPDS_PaveBlock) myPB;
254   Handle(IntTools_Context) myContext;
255 };
256 //=======================================================================
257 typedef BOPCol_NCVector
258   <BOPAlgo_PVE> BOPAlgo_VectorOfPVE; 
259 //
260 typedef BOPCol_ContextFunctor 
261   <BOPAlgo_PVE,
262   BOPAlgo_VectorOfPVE,
263   Handle(IntTools_Context), 
264   IntTools_Context> BOPAlgo_PVEFunctor;
265 //
266 typedef BOPCol_ContextCnt 
267   <BOPAlgo_PVEFunctor,
268   BOPAlgo_VectorOfPVE,
269   Handle(IntTools_Context)> BOPAlgo_PVECnt;
270 /////////////////////////////////////////////////////////////////////////
271 //=======================================================================
272 // function: PerformEE
273 // purpose: 
274 //=======================================================================
275 void BOPAlgo_PaveFiller::PerformEE()
276 {
277   Standard_Integer iSize;
278   //
279   myErrorStatus=0;
280   //
281   FillShrunkData(TopAbs_EDGE, TopAbs_EDGE);
282   //
283   myIterator->Initialize(TopAbs_EDGE, TopAbs_EDGE);
284   iSize=myIterator->ExpectedLength();
285   if (!iSize) {
286     return; 
287   }
288   //
289   Standard_Boolean bJustAdd;
290   Standard_Integer i, iX, nE1, nE2, aNbCPrts, k, aNbFdgeEdge;
291   Standard_Real aTS11, aTS12, aTS21, aTS22, aT11, aT12, aT21, aT22;
292   TopAbs_ShapeEnum aType;
293   BOPDS_ListIteratorOfListOfPaveBlock aIt1, aIt2;
294   Handle(NCollection_IncAllocator) aAllocator;
295   BOPDS_MapOfPaveBlock aMPBToUpdate;
296   BOPAlgo_VectorOfEdgeEdge aVEdgeEdge;
297   BOPDS_MapIteratorOfMapOfPaveBlock aItPB; 
298   //
299   //-----------------------------------------------------scope f
300   BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock aMPBLPB(100, aAllocator);
301   BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks aMVCPB(100, aAllocator);
302   //
303   BOPDS_VectorOfInterfEE& aEEs=myDS->InterfEE();
304   aEEs.SetIncrement(iSize);
305   //
306   for (; myIterator->More(); myIterator->Next()) {
307     myIterator->Value(nE1, nE2, bJustAdd);
308     if(bJustAdd) {
309       continue;
310     }
311     //
312     const BOPDS_ShapeInfo& aSIE1=myDS->ShapeInfo(nE1);
313     if (aSIE1.HasFlag()){
314       continue;
315     }
316     const BOPDS_ShapeInfo& aSIE2=myDS->ShapeInfo(nE2);
317     if (aSIE2.HasFlag()){
318       continue;
319     }
320     //
321     const TopoDS_Edge& aE1=(*(TopoDS_Edge *)(&aSIE1.Shape()));
322     const TopoDS_Edge& aE2=(*(TopoDS_Edge *)(&aSIE2.Shape()));  
323     //
324     BOPDS_ListOfPaveBlock& aLPB1=myDS->ChangePaveBlocks(nE1);
325     BOPDS_ListOfPaveBlock& aLPB2=myDS->ChangePaveBlocks(nE2);
326     //
327     aIt1.Initialize(aLPB1);
328     for (; aIt1.More(); aIt1.Next()) {
329       Bnd_Box aBB1;
330       //
331       Handle(BOPDS_PaveBlock)& aPB1=aIt1.ChangeValue();
332       if (!aPB1->HasShrunkData()) {
333         continue;
334       }
335       aPB1->ShrunkData(aTS11, aTS12, aBB1);
336       //
337       aIt2.Initialize(aLPB2);
338       for (; aIt2.More(); aIt2.Next()) {
339         Bnd_Box aBB2;
340         //
341         Handle(BOPDS_PaveBlock)& aPB2=aIt2.ChangeValue();
342         if (!aPB2->HasShrunkData()) {
343           continue;
344         }
345         aPB2->ShrunkData(aTS21, aTS22, aBB2);
346         //
347         if (aBB1.IsOut(aBB2)) {
348           continue;
349         }
350         //
351         aPB1->Range(aT11, aT12);
352         aPB2->Range(aT21, aT22);
353         //
354         BOPAlgo_EdgeEdge& anEdgeEdge=aVEdgeEdge.Append1();
355         // 
356         anEdgeEdge.SetPaveBlock1(aPB1);
357         anEdgeEdge.SetPaveBlock2(aPB2);
358         //
359         anEdgeEdge.SetEdge1(aE1, aT11, aT12);
360         anEdgeEdge.SetEdge2(aE2, aT21, aT22);
361         anEdgeEdge.SetProgressIndicator(myProgressIndicator);
362       }//for (; aIt2.More(); aIt2.Next()) {
363     }//for (; aIt1.More(); aIt1.Next()) {
364   }//for (; myIterator->More(); myIterator->Next()) {
365   //
366   aNbFdgeEdge=aVEdgeEdge.Extent();
367   //======================================================
368   BOPAlgo_EdgeEdgeCnt::Perform(myRunParallel, aVEdgeEdge);
369   //======================================================
370   //
371   for (k=0; k < aNbFdgeEdge; ++k) {
372     Bnd_Box aBB1, aBB2;
373     //
374     BOPAlgo_EdgeEdge& anEdgeEdge=aVEdgeEdge(k);
375     if (!anEdgeEdge.IsDone()) {
376       continue;
377     }
378     //
379     //--------------------------------------------
380     Handle(BOPDS_PaveBlock)& aPB1=anEdgeEdge.PaveBlock1();
381     nE1=aPB1->OriginalEdge();
382     aPB1->Range(aT11, aT12);
383     aPB1->ShrunkData(aTS11, aTS12, aBB1);
384     //
385     Handle(BOPDS_PaveBlock)& aPB2=anEdgeEdge.PaveBlock2();
386     nE2=aPB2->OriginalEdge();
387     aPB2->Range(aT21, aT22);
388     aPB2->ShrunkData(aTS21, aTS22, aBB2);
389     //
390     //--------------------------------------------
391     IntTools_Range aR11(aT11, aTS11), aR12(aTS12, aT12),
392                    aR21(aT21, aTS21), aR22(aTS22, aT22);
393     //
394     const IntTools_SequenceOfCommonPrts& aCPrts = anEdgeEdge.CommonParts();
395     aNbCPrts=aCPrts.Length();
396     for (i=1; i<=aNbCPrts; ++i) {
397       const IntTools_CommonPrt& aCPart=aCPrts(i);
398       //
399       const TopoDS_Edge& aE1=aCPart.Edge1();
400       const TopoDS_Edge& aE2=aCPart.Edge2();
401       //
402       aType=aCPart.Type();
403       switch (aType) {
404         case TopAbs_VERTEX:  { 
405           Standard_Boolean bIsOnPave[4], bFlag;
406           Standard_Integer nV[4], j;
407           Standard_Real aT1, aT2, aTol;
408           TopoDS_Vertex aVnew;
409           IntTools_Range aCR1, aCR2;
410           //
411           IntTools_Tools::VertexParameters(aCPart, aT1, aT2);
412           aTol = Precision::Confusion();
413           aCR1 = aCPart.Range1();
414           aCR2 = aCPart.Ranges2()(1);
415           // 
416           //decide to keep the pave or not
417           bIsOnPave[0] = IntTools_Tools::IsOnPave1(aT1, aR11, aTol) ||
418             IntTools_Tools::IsOnPave1(aR11.First(), aCR1, aTol);
419           bIsOnPave[1] = IntTools_Tools::IsOnPave1(aT1, aR12, aTol) || 
420             IntTools_Tools::IsOnPave1(aR12.Last(), aCR1, aTol);
421           bIsOnPave[2] = IntTools_Tools::IsOnPave1(aT2, aR21, aTol) ||
422             IntTools_Tools::IsOnPave1(aR21.First(), aCR2, aTol);
423           bIsOnPave[3] = IntTools_Tools::IsOnPave1(aT2, aR22, aTol) ||
424             IntTools_Tools::IsOnPave1(aR22.Last(), aCR2, aTol);
425           //
426           aPB1->Indices(nV[0], nV[1]);
427           aPB2->Indices(nV[2], nV[3]);
428           //
429           if((bIsOnPave[0] && bIsOnPave[2]) || 
430              (bIsOnPave[0] && bIsOnPave[3]) ||
431              (bIsOnPave[1] && bIsOnPave[2]) || 
432              (bIsOnPave[1] && bIsOnPave[3])) {
433             continue;
434           }
435           //
436           bFlag = Standard_False;
437           for (j = 0; j < 4; ++j) {
438             if (bIsOnPave[j]) {
439               //add interf VE(nV[j], nE)
440               Handle(BOPDS_PaveBlock)& aPB = (j < 2) ? aPB2 : aPB1;
441               ForceInterfVE(nV[j], aPB, aMPBToUpdate);
442               bFlag = Standard_True;
443               break;
444             }
445           }
446           if (bFlag) {
447             continue;
448           }
449           //
450           BOPTools_AlgoTools::MakeNewVertex(aE1, aT1, aE2, aT2, aVnew);
451           // <-LXBR
452           {
453             Standard_Integer nVS[2], iFound, k;
454             Standard_Real aTolVx, aTolVnew, aD2, aDT2;
455             BOPCol_MapOfInteger aMV;
456             gp_Pnt aPnew, aPx;
457             //
458             iFound=0;
459             j=-1;
460             aMV.Add(nV[0]);
461             aMV.Add(nV[1]);
462             //
463             if (aMV.Contains(nV[2])) {
464               ++j;
465               nVS[j]=nV[2];
466             }
467             if (aMV.Contains(nV[3])) {
468               ++j;
469               nVS[j]=nV[3];
470             }
471             //
472             aTolVnew=BRep_Tool::Tolerance(aVnew);
473             aPnew=BRep_Tool::Pnt(aVnew);
474             //
475             for (k=0; k<=j; ++k) {
476               const TopoDS_Vertex& aVx= *(TopoDS_Vertex*)&(myDS->Shape(nVS[k]));
477               aTolVx=BRep_Tool::Tolerance(aVx);
478               aPx=BRep_Tool::Pnt(aVx);
479               aD2=aPnew.SquareDistance(aPx);
480               //
481               aDT2=100.*(aTolVnew+aTolVx)*(aTolVnew+aTolVx);
482               //
483               if (aD2<aDT2) {
484                 iFound=1;
485                 break;
486               }
487             }
488             //
489             if (iFound) {
490               continue;
491             }
492           }
493           //
494           // 1
495           BOPDS_InterfEE& aEE=aEEs.Append1();
496           iX=aEEs.Extent()-1;
497           aEE.SetIndices(nE1, nE2);
498           aEE.SetCommonPart(aCPart);
499           // 2
500           myDS->AddInterf(nE1, nE2);
501           //
502           BOPDS_CoupleOfPaveBlocks aCPB;
503           //
504           aCPB.SetPaveBlocks(aPB1, aPB2);
505           aCPB.SetIndexInterf(iX);
506           aMVCPB.Add(aVnew, aCPB);
507         }//case TopAbs_VERTEX: 
508           break;
509             //
510         case TopAbs_EDGE: {
511           if (aNbCPrts > 1) {
512             break;
513           }
514           //
515           Standard_Boolean bHasSameBounds;
516           bHasSameBounds=aPB1->HasSameBounds(aPB2);
517           if (!bHasSameBounds) {
518             break;
519           }
520           // 1
521           BOPDS_InterfEE& aEE=aEEs.Append1();
522           iX=aEEs.Extent()-1;
523           aEE.SetIndices(nE1, nE2);
524           aEE.SetCommonPart(aCPart);
525           // 2
526           myDS->AddInterf(nE1, nE2);
527           //
528           BOPAlgo_Tools::FillMap(aPB1, aPB2, aMPBLPB, aAllocator);
529         }//case TopAbs_EDGE
530           break;
531         default:
532           break;
533       }//switch (aType) {
534     }//for (i=1; i<=aNbCPrts; i++) {
535   }//for (k=0; k < aNbFdgeEdge; ++k) {
536   // 
537   //=========================================
538   // post treatment
539   //=========================================
540   {
541     Standard_Integer aNbV;
542     Handle(BOPDS_PaveBlock) aPB1, aPB2;
543     //
544     aNbV=aMVCPB.Extent();
545     for (i=1; i<=aNbV; ++i) {
546       const BOPDS_CoupleOfPaveBlocks& aCPB=aMVCPB.FindFromIndex(i);
547       aCPB.PaveBlocks(aPB1, aPB2); 
548       //
549       aMPBToUpdate.Remove(aPB1);
550       aMPBToUpdate.Remove(aPB2);
551     }
552   }
553   //
554   aItPB.Initialize(aMPBToUpdate);
555   for (; aItPB.More(); aItPB.Next()) {
556     Handle(BOPDS_PaveBlock) aPB=aItPB.Value();
557     if (!myDS->IsCommonBlock(aPB)) {
558       myDS->UpdatePaveBlock(aPB);
559     }
560     else {
561       const Handle(BOPDS_CommonBlock)& aCB=myDS->CommonBlock(aPB);
562       myDS->UpdateCommonBlock(aCB);
563     }
564   }
565   //
566   BOPAlgo_Tools::PerformCommonBlocks(aMPBLPB, aAllocator, myDS);
567   PerformVerticesEE(aMVCPB, aAllocator);
568   //-----------------------------------------------------scope t
569   aMPBLPB.Clear();
570   aMVCPB.Clear();
571   aMPBToUpdate.Clear();
572 }
573 //=======================================================================
574 //function : PerformVertices
575 //purpose  : 
576 //=======================================================================
577 Standard_Integer BOPAlgo_PaveFiller::PerformVerticesEE
578   (BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& theMVCPB,
579    Handle(NCollection_BaseAllocator)& theAllocator)
580 {
581   Standard_Integer aNbV, iRet;
582   //
583   iRet=0;
584   aNbV=theMVCPB.Extent();
585   if (!aNbV) {
586     return iRet;
587   }
588   //
589   Standard_Integer nVx, iV, j, nE, iFlag, iX, i, aNb; 
590   Standard_Real aT;
591   TopoDS_Shape aV;
592   BOPCol_ListIteratorOfListOfShape aItLS;
593   BOPCol_ListIteratorOfListOfInteger aItLI;
594   BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
595   BOPDS_ShapeInfo aSI;
596   BOPDS_Pave aPave;
597   //
598   BOPDS_IndexedDataMapOfPaveBlockListOfInteger aMPBLI(100, theAllocator);
599   BOPCol_ListOfShape aLS(theAllocator);
600   BOPCol_IndexedDataMapOfShapeInteger aMVI(100, theAllocator);
601   BOPCol_IndexedDataMapOfShapeListOfShape aImages;
602   //
603   aSI.SetShapeType(TopAbs_VERTEX);
604   BOPDS_VectorOfInterfEE& aEEs=myDS->InterfEE();
605   //
606   // 1 prepare arguments
607   //
608   // <- DEB
609   for (i=1; i<=aNbV; ++i) {
610     const TopoDS_Shape& aS=theMVCPB.FindKey(i);
611     const BOPDS_CoupleOfPaveBlocks& aCPB=theMVCPB.FindFromIndex(i);
612     iV=aCPB.IndexInterf();
613     aMVI.Add(aS, iV);
614   }
615   //
616   // 2 Fuse vertices
617   TreatNewVertices(aMVI, aImages);
618   //
619   // 3 Add new vertices to myDS; 
620   //   connect indices to CPB structure
621   aNb = aImages.Extent();
622   for (i=1; i<=aNb; ++i) {
623     const TopoDS_Vertex& aV=(*(TopoDS_Vertex*)(&aImages.FindKey(i)));
624     const BOPCol_ListOfShape& aLVSD=aImages.FindFromIndex(i);
625     //
626     aSI.SetShape(aV);
627     iV=myDS->Append(aSI);
628     //
629     BOPDS_ShapeInfo& aSIDS=myDS->ChangeShapeInfo(iV);
630     Bnd_Box& aBox=aSIDS.ChangeBox();
631     BRepBndLib::Add(aV, aBox);
632     //
633     aItLS.Initialize(aLVSD);
634     for (; aItLS.More(); aItLS.Next()) {
635       const TopoDS_Shape& aVx = aItLS.Value();
636       BOPDS_CoupleOfPaveBlocks &aCPB=theMVCPB.ChangeFromKey(aVx);
637       aCPB.SetIndex(iV);
638       // update EE interference
639       iX=aCPB.IndexInterf();
640       BOPDS_InterfEE& aEE=aEEs(iX);
641       aEE.SetIndexNew(iV);
642     }
643   }
644   //
645   // 4 Map PaveBlock/ListOfVertices to add to this PaveBlock ->aMPBLI
646   {
647     Handle(BOPDS_PaveBlock) aPB[2];
648     //
649     for (i=1; i<=aNbV; ++i) {
650       const BOPDS_CoupleOfPaveBlocks& aCPB=theMVCPB.FindFromIndex(i);
651       iV=aCPB.Index();
652       aCPB.PaveBlocks(aPB[0], aPB[1]);
653       for (j=0; j<2; ++j) {
654         if (aMPBLI.Contains(aPB[j])) {
655           BOPCol_ListOfInteger& aLI=aMPBLI.ChangeFromKey(aPB[j]);
656           aLI.Append(iV);
657         }
658         else {
659           BOPCol_ListOfInteger aLI(theAllocator);
660           aLI.Append(iV);
661           aMPBLI.Add(aPB[j], aLI);
662         }
663       }
664     }
665   }
666   // 5 
667   // 5.1  Compute Extra Paves and 
668   // 5.2. Add Extra Paves to the PaveBlocks
669   //-------------------------------------------------------------
670   Standard_Integer k, aNbVPVE;
671   BOPAlgo_VectorOfPVE aVPVE;
672   //
673   aNb=aMPBLI.Extent();
674   for(i=1; i<=aNb; ++i) {
675     Handle(BOPDS_PaveBlock) aPB=aMPBLI.FindKey(i);
676     nE=aPB->OriginalEdge();
677     const TopoDS_Edge& aE=(*(TopoDS_Edge *)(&myDS->Shape(nE)));
678     // 1,2
679     const BOPCol_ListOfInteger& aLI=aMPBLI.FindFromIndex(i);
680     aItLI.Initialize(aLI);
681     for (; aItLI.More(); aItLI.Next()) {
682       nVx=aItLI.Value();
683       const TopoDS_Vertex& aVx=(*(TopoDS_Vertex *)(&myDS->Shape(nVx)));
684       //
685       BOPAlgo_PVE& aPVE=aVPVE.Append1();
686       aPVE.SetIndices(nVx, nE);
687       aPVE.SetVertex(aVx);
688       aPVE.SetEdge(aE);
689       aPVE.SetPaveBlock(aPB);
690     }
691   }
692   //
693   aNbVPVE=aVPVE.Extent();
694   //=============================================================
695   BOPAlgo_PVECnt::Perform(myRunParallel, aVPVE, myContext);
696   //=============================================================
697   //
698   for (k=0; k < aNbVPVE; ++k) {
699     BOPAlgo_PVE& aPVE=aVPVE(k);
700     iFlag=aPVE.Flag();
701     if (!iFlag) {
702       aPVE.Indices(nVx, nE);
703       aT=aPVE.Parameter();
704       Handle(BOPDS_PaveBlock)& aPB=aPVE.PaveBlock();
705       //
706       aPave.SetIndex(nVx);
707       aPave.SetParameter(aT);
708       aPB->AppendExtPave(aPave);
709     }
710   }
711   // 6  Split PaveBlocksa
712   aNb=aMPBLI.Extent();
713   for(i=1; i<=aNb; ++i) {
714     Handle(BOPDS_PaveBlock) aPB=aMPBLI.FindKey(i);
715     nE=aPB->OriginalEdge();
716     // 3
717     if (!myDS->IsCommonBlock(aPB)) {
718       myDS->UpdatePaveBlock(aPB);
719     }
720     else {
721       const Handle(BOPDS_CommonBlock)& aCB=myDS->CommonBlock(aPB);
722       myDS->UpdateCommonBlock(aCB);
723     }    
724   }//for (; aItMPBLI.More(); aItMPBLI.Next()) {
725   //
726   return iRet;
727 }
728 //=======================================================================
729 //function : TreatNewVertices
730 //purpose  : 
731 //=======================================================================
732 void BOPAlgo_PaveFiller::TreatNewVertices
733   (const BOPCol_IndexedDataMapOfShapeInteger& aMapVI,
734    BOPCol_IndexedDataMapOfShapeListOfShape& myImages)
735 {
736   Standard_Integer  i, aNbV;//, aNbVSD;
737   Standard_Real aTol;
738   TopoDS_Vertex aVnew;
739   TopoDS_Shape aVF;
740   BOPCol_IndexedMapOfShape aMVProcessed;
741   BOPCol_MapOfInteger aMFence;
742   BOPCol_ListIteratorOfListOfInteger aIt;
743   BOPCol_DataMapOfShapeListOfShape aDMVLV;
744   BOPCol_DataMapIteratorOfDataMapOfShapeListOfShape aItDMVLV;
745   //
746   BOPCol_BoxBndTreeSelector aSelector;
747   BOPCol_BoxBndTree aBBTree;
748   NCollection_UBTreeFiller <Standard_Integer, 
749                             Bnd_Box> aTreeFiller(aBBTree);
750   BOPAlgo_VectorOfTNV aVTNV;
751   //
752   aNbV = aMapVI.Extent();
753   for (i=1; i<=aNbV; ++i) {
754     const TopoDS_Vertex& aV=*((TopoDS_Vertex*)&aMapVI.FindKey(i));
755     Bnd_Box aBox;
756     //
757     aTol=BRep_Tool::Tolerance(aV);
758     aBox.SetGap(aTol);
759     aBox.Add(BRep_Tool::Pnt(aV));
760     aBox.Enlarge(aTol);
761     //
762     aTreeFiller.Add(i, aBox);
763     //
764     BOPAlgo_TNV& aTNV=aVTNV.Append1();
765     aTNV.SetTree(aBBTree);
766     aTNV.SetBox(aBox);
767     aTNV.SetVertex(aV);
768   }
769   //
770   aTreeFiller.Fill();
771   //
772   //===========================================
773   BOPAlgo_TNVCnt::Perform(myRunParallel, aVTNV);
774   //===========================================
775   //
776   // Chains
777   for (i=1; i<=aNbV; ++i) {
778     if (!aMFence.Add(i)) {
779       continue;
780     }
781     //
782     Standard_Integer aIP, aNbIP1, aIP1;
783     BOPCol_ListOfShape aLVSD;
784     BOPCol_MapIteratorOfMapOfInteger aItMI;
785     BOPCol_ListOfInteger aLIP, aLIP1, aLIPC;
786     BOPCol_ListIteratorOfListOfInteger aItLIP;
787     //
788     aLIPC.Append(i);
789     aLIP.Append(i);
790     for(;;) {
791       aItLIP.Initialize(aLIP);
792       for(; aItLIP.More(); aItLIP.Next()) {
793         aIP=aItLIP.Value();
794         //
795         BOPAlgo_TNV& aTNV=aVTNV(aIP-1);
796         const BOPCol_ListOfInteger& aLI=aTNV.Indices();
797         aIt.Initialize(aLI);
798         for (; aIt.More(); aIt.Next()) {
799           aIP1=aIt.Value();
800           if (!aMFence.Add(aIP1)) {
801             continue;
802           }
803           aLIP1.Append(aIP1);
804         } //for (; aIt.More(); aIt.Next()) {
805       }//for(; aIt1.More(); aIt1.Next()) {
806       //
807       aNbIP1=aLIP1.Extent();
808       if (!aNbIP1) {
809         break; // from for(;;) 
810       }
811       //
812       aLIP.Clear();
813       aItLIP.Initialize(aLIP1);
814       for(; aItLIP.More(); aItLIP.Next()) {
815         aIP=aItLIP.Value();
816         aLIP.Append(aIP);
817         aLIPC.Append(aIP);
818       }
819       aLIP1.Clear();
820     }// for(;;) {
821     //
822     aItLIP.Initialize(aLIPC);
823     for(; aItLIP.More(); aItLIP.Next()) {
824       aIP=aItLIP.Value();
825       const TopoDS_Vertex& aVP=aVTNV(aIP-1).Vertex(); 
826       aLVSD.Append(aVP);
827     }
828     aVF=aLVSD.First();
829     aDMVLV.Bind(aVF, aLVSD);
830   }// for (i=1; i<=aNbV; ++i) {
831
832   // Make new vertices
833   aItDMVLV.Initialize(aDMVLV);
834   for(; aItDMVLV.More(); aItDMVLV.Next()) {
835     const TopoDS_Shape& aV=aItDMVLV.Key();
836     const BOPCol_ListOfShape& aLVSD=aItDMVLV.Value();
837     if (aLVSD.IsEmpty()) {
838       myImages.Add(aV, aLVSD);
839     }
840     else {
841       BOPCol_ListOfShape* pLVSD=(BOPCol_ListOfShape*)&aLVSD;
842       BOPTools_AlgoTools::MakeVertex(*pLVSD, aVnew);
843       myImages.Add(aVnew, aLVSD);
844     } 
845   }
846 }
847 //=======================================================================
848 //function : FillShrunkData
849 //purpose  : 
850 //=======================================================================
851 void BOPAlgo_PaveFiller::FillShrunkData(Handle(BOPDS_PaveBlock)& thePB)
852 {
853   Standard_Integer nE, nV1, nV2, iErr;
854   Standard_Real aT1, aT2, aTS1, aTS2;
855   IntTools_ShrunkRange aSR;
856   //
857   myErrorStatus=0;
858   myWarningStatus = 0;
859   //
860   const BOPDS_Pave& aPave1=thePB->Pave1();
861   nV1=aPave1.Index();
862   aT1=aPave1.Parameter();
863   const TopoDS_Vertex& aV1=(*(TopoDS_Vertex *)(&myDS->Shape(nV1))); 
864   //
865   const BOPDS_Pave& aPave2=thePB->Pave2();
866   nV2=aPave2.Index();
867   aT2=aPave2.Parameter();
868   const TopoDS_Vertex& aV2=(*(TopoDS_Vertex *)(&myDS->Shape(nV2))); 
869   //
870   nE=thePB->OriginalEdge();
871   const TopoDS_Edge& aE=(*(TopoDS_Edge *)(&myDS->Shape(nE))); 
872   //
873   aSR.SetContext(myContext);
874   aSR.SetData(aE, aT1, aT2, aV1, aV2);
875   //
876   aSR.Perform();
877   iErr=aSR.ErrorStatus();
878   if (iErr) {
879     myWarningStatus = 1;
880     //myErrorStatus=40;
881     return;
882   }
883   //
884   aSR.ShrunkRange(aTS1, aTS2);
885   const Bnd_Box& aBox=aSR.BndBox();
886   //
887   thePB->SetShrunkData(aTS1, aTS2, aBox);
888 }
889 //=======================================================================
890 //function : ForceInterfVE
891 //purpose  : 
892 //=======================================================================
893 void BOPAlgo_PaveFiller::ForceInterfVE(const Standard_Integer nV,
894                                        Handle(BOPDS_PaveBlock)& aPB,
895                                        BOPDS_MapOfPaveBlock& aMPBToUpdate)
896 {
897   Standard_Integer aNbPnt, nE;
898   gp_Pnt aP;
899   //
900   nE = aPB->OriginalEdge();
901   //
902   const BOPDS_ShapeInfo& aSIE=myDS->ShapeInfo(nE);
903   if (aSIE.HasSubShape(nV)) {
904     return;
905   }
906   //
907   if (myDS->HasInterf(nV, nE)) {
908     return;
909   }   
910   //
911   if (myDS->HasInterfShapeSubShapes(nV, nE)) {
912     return;
913   }
914   //
915   if (aPB->Pave1().Index() == nV || aPB->Pave2().Index() == nV) {
916     return;
917   }
918   //
919   const TopoDS_Vertex& aV = *(TopoDS_Vertex*)&myDS->Shape(nV);
920   const TopoDS_Edge&   aE = *(TopoDS_Edge*)  &myDS->Shape(nE);
921   aP=BRep_Tool::Pnt(aV);
922   //
923   GeomAPI_ProjectPointOnCurve& aProjector=myContext->ProjPC(aE);
924   aProjector.Perform(aP);
925   //
926   aNbPnt = aProjector.NbPoints();
927   if (aNbPnt) {
928     Standard_Real aT, aDist;
929     //Standard_Integer i;
930     BRep_Builder aBB;
931     BOPDS_Pave aPave;
932     //
933     aDist=aProjector.LowerDistance();
934     aT=aProjector.LowerDistanceParameter();
935     //
936     BOPDS_VectorOfInterfVE& aVEs=myDS->InterfVE();
937     aVEs.SetIncrement(10);
938     BOPDS_InterfVE& aVE=aVEs.Append1();
939     aVE.SetIndices(nV, nE);
940     aVE.SetParameter(aT);
941     //
942     myDS->AddInterf(nV, nE);
943     //
944     aBB.UpdateVertex(aV, aDist);
945     BOPDS_ShapeInfo& aSIDS=myDS->ChangeShapeInfo(nV);
946     Bnd_Box& aBox=aSIDS.ChangeBox();
947     BRepBndLib::Add(aV, aBox);
948     //
949     aPave.SetIndex(nV);
950     aPave.SetParameter(aT);
951     aPB->AppendExtPave(aPave);
952     //
953     aMPBToUpdate.Add(aPB);
954   }
955 }
956
957  /*
958   // DEBf
959   { 
960     TopoDS_Compound aCx;
961     BRep_Builder aBBx;
962     aBBx.MakeCompound(aCx);
963     aItMVCPB.Initialize(theMVCPB);
964     for (; aItMVCPB.More(); aItMVCPB.Next()) {
965       const TopoDS_Shape& aS=aItMVCPB.Key();
966       aBBx.Add(aCx, aS);
967     }
968     BRepTools::Write(aCx, "cx");
969   }
970   // DEBt
971   */