0023901: Memory leaks in tests
[occt.git] / src / BOPAlgo / BOPAlgo_PaveFiller_6.cxx
1 // Created by: Peter KURNEV
2 // Copyright (c) 2010-2012 OPEN CASCADE SAS
3 // Copyright (c) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
4 // Copyright (c) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, CEDRAT,
5 //                         EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 //
7 // The content of this file is subject to the Open CASCADE Technology Public
8 // License Version 6.5 (the "License"). You may not use the content of this file
9 // except in compliance with the License. Please obtain a copy of the License
10 // at http://www.opencascade.org and read it completely before using this file.
11 //
12 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
13 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
14 //
15 // The Original Code and all software distributed under the License is
16 // distributed on an "AS IS" basis, without warranty of any kind, and the
17 // Initial Developer hereby disclaims all such warranties, including without
18 // limitation, any warranties of merchantability, fitness for a particular
19 // purpose or non-infringement. Please see the License for the specific terms
20 // and conditions governing the rights and limitations under the License.
21
22
23 #include <BOPAlgo_PaveFiller.ixx>
24
25 #include <Precision.hxx>
26 #include <NCollection_IncAllocator.hxx>
27 #include <Bnd_Box.hxx>
28
29 #include <Geom_Curve.hxx>
30 #include <Geom2d_Curve.hxx>
31
32 #include <GeomAPI_ProjectPointOnCurve.hxx>
33 #include <GeomAPI_ProjectPointOnSurf.hxx>
34
35 #include <TopoDS_Edge.hxx>
36 #include <TopoDS_Face.hxx>
37 #include <TopoDS_Vertex.hxx>
38 #include <TopoDS_Compound.hxx>
39
40 #include <TopExp_Explorer.hxx>
41
42 #include <BRep_Builder.hxx>
43 #include <BRep_Tool.hxx>
44
45 #include <BRepBndLib.hxx>
46 #include <BRepTools.hxx>
47
48 #include <BRepAdaptor_Curve.hxx>
49 #include <BRepAdaptor_Surface.hxx>
50
51 #include <IntTools_FaceFace.hxx>
52 #include <IntTools_SequenceOfCurves.hxx>
53 #include <IntTools_SequenceOfPntOn2Faces.hxx>
54 #include <IntTools_Curve.hxx>
55 #include <IntTools_PntOn2Faces.hxx>
56 #include <IntTools_Tools.hxx>
57
58 #include <IntSurf_ListOfPntOn2S.hxx>
59 #include <IntSurf_PntOn2S.hxx>
60
61 #include <BOPTools_AlgoTools.hxx>
62 #include <BOPTools_AlgoTools3D.hxx>
63
64 #include <BOPCol_MapOfInteger.hxx>
65 #include <BOPCol_ListOfShape.hxx>
66 #include <BOPCol_DataMapOfShapeInteger.hxx>
67 #include <BOPCol_ListOfInteger.hxx>
68 #include <BOPCol_IndexedMapOfInteger.hxx>
69
70 #include <BOPInt_Context.hxx>
71 #include <BOPInt_Tools.hxx>
72
73 #include <BOPDS_Interf.hxx>
74 #include <BOPDS_Iterator.hxx>
75 #include <BOPDS_Curve.hxx>
76 #include <BOPDS_Point.hxx>
77 #include <BOPDS_FaceInfo.hxx>
78 #include <BOPDS_Curve.hxx>
79 #include <BOPDS_MapOfPaveBlock.hxx>
80 #include <BOPDS_PaveBlock.hxx>
81 #include <BOPDS_VectorOfCurve.hxx>
82 #include <BOPDS_VectorOfPoint.hxx>
83 #include <BOPDS_ShapeInfo.hxx>
84 #include <BOPDS_PaveBlock.hxx>
85 #include <BOPDS_ListOfPave.hxx>
86 #include <BOPDS_ListOfPaveBlock.hxx>
87 #include <BOPDS_CoupleOfPaveBlocks.hxx>
88 #include <BOPDS_FaceInfo.hxx>
89 #include <BOPDS_CommonBlock.hxx>
90
91 #include <BOPAlgo_Tools.hxx>
92 #include <BRepBuilderAPI_MakeVertex.hxx>
93 #include <TopExp.hxx>
94 #include <BOPInt_ShrunkRange.hxx>
95 #include <BOPDS_DataMapOfPaveBlockListOfPaveBlock.hxx>
96
97 static void ToleranceFF(const TopoDS_Face& aF1,
98                         const TopoDS_Face& aF2,
99                         Standard_Real& aTolFF);
100
101 //=======================================================================
102 //function : PerformFF
103 //purpose  : 
104 //=======================================================================
105   void BOPAlgo_PaveFiller::PerformFF()
106 {
107   Standard_Integer iSize;
108   Standard_Boolean bValid;
109   //
110   myErrorStatus=0;
111   //
112   myIterator->Initialize(TopAbs_FACE, TopAbs_FACE);
113   iSize=myIterator->ExpectedLength();
114   if (!iSize) {
115     return; 
116   }
117   //
118   Standard_Boolean bJustAdd, bApp, bCompC2D1, bCompC2D2, bIsDone;
119   Standard_Boolean bToSplit;
120   Standard_Integer nF1, nF2, aNbCurves, aNbPoints, iX, i, iP, iC, aNbLP;
121   Standard_Real aApproxTol, aTolR3D, aTolR2D, aTolFF;
122   //
123   BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
124   aFFs.SetStartSize(iSize);
125   aFFs.SetIncrement(iSize);
126   aFFs.Init();
127   //
128   bApp=mySectionAttribute.Approximation();
129   bCompC2D1=mySectionAttribute.PCurveOnS1();
130   bCompC2D2=mySectionAttribute.PCurveOnS2();
131   aApproxTol=1.e-7;
132   bToSplit = Standard_False;
133   //
134   for (; myIterator->More(); myIterator->Next()) {
135     myIterator->Value(nF1, nF2, bJustAdd);
136     if(bJustAdd) {
137       continue;
138     }
139     //
140     const TopoDS_Face& aF1=(*(TopoDS_Face *)(&myDS->Shape(nF1)));
141     const TopoDS_Face& aF2=(*(TopoDS_Face *)(&myDS->Shape(nF2)));
142     //
143     IntTools_FaceFace aFaceFace;
144     //
145     IntSurf_ListOfPntOn2S aListOfPnts;
146     GetEFPnts(nF1, nF2, aListOfPnts);
147     aNbLP = aListOfPnts.Extent();
148     if (aNbLP) {
149       aFaceFace.SetList(aListOfPnts);
150     }
151
152     aFaceFace.SetParameters(bApp, bCompC2D1, bCompC2D2, aApproxTol);
153     //
154     aFaceFace.Perform(aF1, aF2);
155     //
156     bIsDone=aFaceFace.IsDone();
157     if (bIsDone) {
158       aTolR3D=aFaceFace.TolReached3d();
159       aTolR2D=aFaceFace.TolReached2d();
160       //
161       ToleranceFF(aF1, aF2, aTolFF);
162       //
163       if (aTolR3D < aTolFF){
164         aTolR3D=aTolFF;
165       }
166       if (aTolR2D < 1.e-7){
167         aTolR2D=1.e-7;
168       }
169       //
170       aFaceFace.PrepareLines3D(bToSplit);
171       //
172       const IntTools_SequenceOfCurves& aCvsX=aFaceFace.Lines();
173       const IntTools_SequenceOfPntOn2Faces& aPntsX=aFaceFace.Points();
174       //
175       aNbCurves=aCvsX.Length();
176       aNbPoints=aPntsX.Length();
177       //
178       myDS->AddInterf(nF1, nF2);
179       //
180       iX=aFFs.Append()-1;
181       BOPDS_InterfFF& aFF=aFFs(iX);
182       aFF.SetIndices(nF1, nF2);
183       //
184       aFF.SetTolR3D(aTolR3D);
185       aFF.SetTolR2D(aTolR2D);
186       //
187       // Curves, Points 
188       aFF.Init(aNbCurves, aNbPoints);
189       //
190       // Curves
191       BOPDS_VectorOfCurve& aVNC=aFF.ChangeCurves();
192       for (i=1; i<=aNbCurves; ++i) {
193         Bnd_Box aBox;
194         //
195         const IntTools_Curve& aIC=aCvsX(i);
196         const Handle(Geom_Curve)& aC3D= aIC.Curve();
197         bValid=BOPInt_Tools::CheckCurve(aC3D, aTolR3D, aBox);
198         if (bValid) {
199           iC=aVNC.Append()-1;
200           BOPDS_Curve& aNC=aVNC(iC);
201           aNC.SetCurve(aIC);
202           aNC.SetBox(aBox);
203         }
204       }
205       //
206       // Points
207       BOPDS_VectorOfPoint& aVNP=aFF.ChangePoints();
208       for (i=1; i<=aNbPoints; ++i) {
209         const IntTools_PntOn2Faces& aPi=aPntsX(i);
210         const gp_Pnt& aP=aPi.P1().Pnt();
211         //
212         iP=aVNP.Append()-1;
213         BOPDS_Point& aNP=aVNP(iP);
214         aNP.SetPnt(aP);
215       }
216     //}// if (aNbCs || aNbPs)
217     }// if (bIsDone) {
218     else {// 904/L1
219       iX=aFFs.Append()-1;
220       BOPDS_InterfFF& aFF=aFFs(iX);
221       aFF.SetIndices(nF1, nF2);
222       aNbCurves=0;
223       aNbPoints=0;
224       aFF.Init(aNbCurves, aNbPoints);
225     }
226   }// for (; myIterator->More(); myIterator->Next()) {
227 }
228 //=======================================================================
229 //function : MakeBlocks
230 //purpose  : 
231 //=======================================================================
232
233   void BOPAlgo_PaveFiller::MakeBlocks()
234 {
235   Standard_Integer aNbFF;
236   //
237   myErrorStatus=0;
238   //
239   BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
240   aNbFF=aFFs.Extent();
241   if (!aNbFF) {
242     return;
243   }
244   //
245   Standard_Boolean bExist, bValid2D;
246   Standard_Integer i, nF1, nF2, aNbC, aNbP, j;
247   Standard_Integer nV1, nV2;
248   Standard_Real aTolR3D, aTolR2D, aT1, aT2;
249   Handle(NCollection_IncAllocator) aAllocator;
250   BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
251   TopoDS_Edge aES;
252   Handle(BOPDS_PaveBlock) aPBOut;
253   //
254   //-----------------------------------------------------scope f
255   aAllocator=new NCollection_IncAllocator();
256   //
257   BOPCol_ListOfInteger aLSE(aAllocator);
258   BOPCol_MapOfInteger aMVOnIn(100, aAllocator), aMF(100, aAllocator),
259                       aMVStick(100,aAllocator), aMVEF(100, aAllocator),
260                       aMVB(100, aAllocator);
261   BOPDS_MapOfPaveBlock aMPBOnIn(100, aAllocator),
262                        aMPBAdd(100, aAllocator);
263   BOPDS_ListOfPaveBlock aLPB(aAllocator);
264   BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks aMSCPB(100, aAllocator); 
265   BOPCol_DataMapOfShapeInteger aMVI(100, aAllocator);
266   BOPDS_DataMapOfPaveBlockListOfPaveBlock aDMExEdges;
267   //
268   for (i=0; i<aNbFF; ++i) {
269     BOPDS_InterfFF& aFF=aFFs(i);
270     aFF.Indices(nF1, nF2);
271     //
272     BOPDS_VectorOfPoint& aVP=aFF.ChangePoints();
273     aNbP=aVP.Extent();
274     BOPDS_VectorOfCurve& aVC=aFF.ChangeCurves();
275     aNbC=aVC.Extent();
276     if (!aNbP && !aNbC) {
277       continue;
278     }
279     //
280     const TopoDS_Face& aF1=(*(TopoDS_Face *)(&myDS->Shape(nF1)));
281     const TopoDS_Face& aF2=(*(TopoDS_Face *)(&myDS->Shape(nF2)));
282     //
283     aTolR3D=aFF.TolR3D();
284     aTolR2D=aFF.TolR2D();
285     //
286     // Update face info
287     if (aMF.Add(nF1)) {
288       myDS->UpdateFaceInfoOn(nF1);
289     }
290     if (aMF.Add(nF2)) {
291       myDS->UpdateFaceInfoOn(nF2);
292     }
293    
294     BOPDS_FaceInfo& aFI1=myDS->ChangeFaceInfo(nF1);
295     BOPDS_FaceInfo& aFI2=myDS->ChangeFaceInfo(nF2);
296     //
297     aMVOnIn.Clear();
298     aMPBOnIn.Clear();
299     aMVB.Clear();
300     //
301     myDS->VerticesOnIn(nF1, nF2, aMVOnIn, aMPBOnIn);
302     myDS->SharedEdges(nF1, nF2, aLSE, aAllocator);
303     
304     // 1. Treat Points
305     for (j=0; j<aNbP; ++j) {
306       TopoDS_Vertex aV;
307       BOPDS_CoupleOfPaveBlocks aCPB;
308       //
309       BOPDS_Point& aNP=aVP.ChangeValue(j);
310       const gp_Pnt& aP=aNP.Pnt();
311       //
312       bExist=IsExistingVertex(aP, aTolR3D, aMVOnIn);
313       if (!bExist) {
314         BOPTools_AlgoTools::MakeNewVertex(aP, aTolR3D, aV);
315         //
316         aCPB.SetIndexInterf(i);
317         aCPB.SetIndex(j);
318         aMSCPB.Add(aV, aCPB);
319       }
320     }
321     //
322     // 2. Treat Curves
323     aMVStick.Clear();
324     aMVEF.Clear();
325     GetStickVertices(nF1, nF2, aMVStick, aMVEF);
326     //
327     for (j=0; j<aNbC; ++j) {
328       BOPDS_Curve& aNC=aVC.ChangeValue(j);
329       const IntTools_Curve& aIC=aNC.Curve();
330       // DEBf
331       const Handle(Geom_Curve)& aC3D=aIC.Curve();
332       // DEBt
333       aNC.InitPaveBlock1();
334       //
335       PutPaveOnCurve(aMVOnIn, aTolR3D, aNC, nF1, nF2, aMVEF);
336       //
337       PutStickPavesOnCurve(nF1, nF2, aNC, aMVStick);
338       //pkv/904/F7
339       if (aNbC == 1) {
340         PutEFPavesOnCurve(nF1, nF2, aNC, aMVEF);
341       }
342       //
343       if (aIC.HasBounds()) {
344         PutBoundPaveOnCurve(aF1, aF2, aTolR3D, aNC, aMVOnIn, aMVB);
345       }
346     }//for (j=0; j<aNbC; ++j) {
347     //
348     // Put closing pave if needed
349     for (j=0; j<aNbC; ++j) {
350       BOPDS_Curve& aNC=aVC.ChangeValue(j);
351       PutClosingPaveOnCurve (aNC);
352     }
353     //
354     // 3. Make section edges
355     for (j=0; j<aNbC; ++j) {
356       BOPDS_Curve& aNC=aVC.ChangeValue(j);
357       const IntTools_Curve& aIC=aNC.Curve();
358       //
359       BOPDS_ListOfPaveBlock& aLPBC=aNC.ChangePaveBlocks();
360       Handle(BOPDS_PaveBlock)& aPB1=aNC.ChangePaveBlock1();
361       //
362       aLPB.Clear();
363       aPB1->Update(aLPB, Standard_False);
364       //
365       aItLPB.Initialize(aLPB);
366       for (; aItLPB.More(); aItLPB.Next()) {
367         Handle(BOPDS_PaveBlock)& aPB=aItLPB.ChangeValue();
368         aPB->Indices(nV1, nV2);
369         aPB->Range  (aT1, aT2);
370         //
371         if (fabs(aT1 - aT2) < Precision::PConfusion()) {
372           continue;
373         }
374         //
375         bValid2D=myContext->IsValidBlockForFaces(aT1, aT2, aIC, aF1, aF2, aTolR3D);
376         if (!bValid2D) {
377           continue;
378         }
379         //
380         bExist=IsExistingPaveBlock(aPB, aNC, aTolR3D, aLSE);
381         if (bExist) {
382           continue;
383         }
384         //
385         bExist=IsExistingPaveBlock(aPB, aNC, aTolR3D, aMPBOnIn, aPBOut);
386         if (bExist) {
387           if (aMPBAdd.Add(aPBOut)) {
388             Standard_Boolean bInBothFaces = Standard_True;
389             if (!aPBOut->IsCommonBlock()) {
390               Standard_Integer nE;
391               Standard_Real aTolE;
392               //
393               nE = aPBOut->Edge();
394               const TopoDS_Edge& aE = *(TopoDS_Edge*)&myDS->Shape(nE);
395               aTolE = BRep_Tool::Tolerance(aE);
396               if (aTolR3D > aTolE) {
397                 myDS->UpdateEdgeTolerance(nE, aTolR3D);
398               }
399               bInBothFaces = Standard_False;
400             } else {
401               bInBothFaces = (aFI1.PaveBlocksOn().Contains(aPBOut) ||
402                               aFI1.PaveBlocksIn().Contains(aPBOut))&&
403                              (aFI2.PaveBlocksOn().Contains(aPBOut) ||
404                               aFI2.PaveBlocksIn().Contains(aPBOut));
405             }
406             if (!bInBothFaces) {
407               PreparePostTreatFF(i, aPBOut, aMSCPB, aMVI, aVC);
408             }
409           }
410           continue;
411         }
412         //
413         // Make Edge
414         const TopoDS_Vertex& aV1=(*(TopoDS_Vertex *)(&myDS->Shape(nV1)));
415         const TopoDS_Vertex& aV2=(*(TopoDS_Vertex *)(&myDS->Shape(nV2)));
416         //
417         BOPTools_AlgoTools::MakeEdge (aIC, aV1, aT1, aV2, aT2, aTolR3D, aES);
418         BOPTools_AlgoTools::MakePCurve(aES, aF1, aF2, aIC, 
419                                        mySectionAttribute.PCurveOnS1(),
420                                        mySectionAttribute.PCurveOnS2());
421         //
422         if (BOPTools_AlgoTools::IsMicroEdge(aES, myContext)) {
423           continue;
424         }
425         //
426         // Append the Pave Block to the Curve j
427         aLPBC.Append(aPB);
428         //
429         // Keep info for post treatment 
430         BOPDS_CoupleOfPaveBlocks aCPB;
431         aCPB.SetIndexInterf(i);
432         aCPB.SetIndex(j);
433         aCPB.SetPaveBlock1(aPB);
434         //
435         aMSCPB.Add(aES, aCPB);
436         aMVI.Bind(aV1, nV1);
437         aMVI.Bind(aV2, nV2);
438       }
439       //
440       aLPBC.RemoveFirst();
441     }//for (j=0; j<aNbC; ++j) {
442     ProcessExistingPaveBlocks(i, aMPBOnIn, aMSCPB, aMVI, aMVB, aMPBAdd);
443   }//for (i=0; i<aNbFF; ++i) {
444   // 
445   // post treatment
446   myErrorStatus=PostTreatFF(aMSCPB, aMVI, aDMExEdges, aAllocator);
447   if (myErrorStatus) {
448     return;
449   }
450   //
451   // update face info
452   UpdateFaceInfo(aDMExEdges);
453   //-----------------------------------------------------scope t
454   aMF.Clear();
455   aMVStick.Clear();
456   aMPBOnIn.Clear();
457   aMVOnIn.Clear();
458   aDMExEdges.Clear();
459   aAllocator.Nullify();
460 }
461
462 //=======================================================================
463 //function : PostTreatFF
464 //purpose  : 
465 //=======================================================================
466   Standard_Integer BOPAlgo_PaveFiller::PostTreatFF
467     (BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& theMSCPB,
468      BOPCol_DataMapOfShapeInteger& aMVI,
469      BOPDS_DataMapOfPaveBlockListOfPaveBlock& aDMExEdges,
470      Handle(NCollection_BaseAllocator)& theAllocator)
471 {
472   Standard_Integer iRet, aNbS;
473   //
474   iRet=0;
475   aNbS=theMSCPB.Extent();
476   if (!aNbS) {
477     return iRet;
478   }
479   //
480   Standard_Boolean bHasPaveBlocks, bOld;
481   Standard_Integer iErr, nSx, nVSD, iX, iP, iC, j, nV, iV, iE, k;
482   Standard_Integer jx;
483   Standard_Real aT;
484   Standard_Integer aNbLPBx;
485   TopAbs_ShapeEnum aType;
486   TopoDS_Shape aV, aE;
487   BOPCol_ListIteratorOfListOfShape aItLS;
488   BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
489   BOPDS_PDS aPDS;
490   Handle(BOPDS_PaveBlock) aPB1;
491   BOPDS_Pave aPave[2], aPave1[2];
492   BOPDS_ShapeInfo aSI;
493   //
494   BOPCol_ListOfShape aLS(theAllocator);
495   BOPAlgo_PaveFiller aPF(theAllocator);
496   //
497   BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
498   //
499   // <-DEB f
500   //
501   // 0
502   if (aNbS==1) {
503     const TopoDS_Shape& aS=theMSCPB.FindKey(1);
504     const BOPDS_CoupleOfPaveBlocks &aCPB=theMSCPB.FindFromIndex(1);
505     
506     //
507     aType=aS.ShapeType();
508     if (aType==TopAbs_VERTEX) {
509       aSI.SetShapeType(aType);
510       aSI.SetShape(aS);
511       iV=myDS->Append(aSI);
512       //
513       iX=aCPB.IndexInterf();
514       iP=aCPB.Index();
515       BOPDS_InterfFF& aFF=aFFs(iX); 
516       BOPDS_VectorOfPoint& aVNP=aFF.ChangePoints();
517       BOPDS_Point& aNP=aVNP(iP);
518       aNP.SetIndex(iV);
519     }
520     else if (aType==TopAbs_EDGE) {
521       aPB1=aCPB.PaveBlock1();
522       //
523       if (aPB1->HasEdge()) {
524         BOPDS_ListOfPaveBlock aLPBx;
525         aLPBx.Append(aPB1);
526         aDMExEdges.Bind(aPB1, aLPBx);
527       } else {
528         aSI.SetShapeType(aType);
529         aSI.SetShape(aS);
530         iE=myDS->Append(aSI);
531         //
532         aPB1->SetEdge(iE);
533       }
534     }
535     return iRet;
536   }
537   //
538   // 1 prepare arguments
539   for (k=1; k<=aNbS; ++k) {
540     const TopoDS_Shape& aS=theMSCPB.FindKey(k);
541     aLS.Append(aS);
542   }
543   //
544   // 2 Fuse shapes
545   aPF.SetArguments(aLS);
546   aPF.Perform();
547   iErr=aPF.ErrorStatus();
548   if (iErr) {
549     iRet=1;
550     return iRet;
551   }
552   aPDS=aPF.PDS();
553   //
554   aItLS.Initialize(aLS);
555   for (; aItLS.More(); aItLS.Next()) {
556     const TopoDS_Shape& aSx=aItLS.Value();
557     nSx=aPDS->Index(aSx);
558     const BOPDS_ShapeInfo& aSIx=aPDS->ShapeInfo(nSx);
559     //
560     aType=aSIx.ShapeType();
561     //
562     if (aType==TopAbs_VERTEX) {
563       if (aPDS->HasShapeSD(nSx, nVSD)) {
564         aV=aPDS->Shape(nVSD);
565       }
566       else {
567         aV=aSx;
568       }
569       // index of new vertex in theDS -> iV
570       if (!aMVI.IsBound(aV)) {
571         aSI.SetShapeType(aType);
572         aSI.SetShape(aV);
573         iV=myDS->Append(aSI);
574         //
575         aMVI.Bind(aV, iV);
576       }
577       else {
578         iV=aMVI.Find(aV);
579       }
580       // update FF interference
581       const BOPDS_CoupleOfPaveBlocks &aCPB=theMSCPB.FindFromKey(aSx);
582       iX=aCPB.IndexInterf();
583       iP=aCPB.Index();
584       BOPDS_InterfFF& aFF=aFFs(iX);
585       BOPDS_VectorOfPoint& aVNP=aFF.ChangePoints();
586       BOPDS_Point& aNP=aVNP(iP);
587       aNP.SetIndex(iV);
588     }//if (aType==TopAbs_VERTEX) {
589     //
590     else if (aType==TopAbs_EDGE) {
591       bHasPaveBlocks=aPDS->HasPaveBlocks(nSx);
592       const BOPDS_CoupleOfPaveBlocks &aCPB=theMSCPB.FindFromKey(aSx);
593       iX=aCPB.IndexInterf();
594       iC=aCPB.Index();
595       aPB1=aCPB.PaveBlock1();
596       //
597       bOld = aPB1->HasEdge();
598       if (bOld) {
599         BOPDS_ListOfPaveBlock aLPBx;
600         aDMExEdges.Bind(aPB1, aLPBx);
601       }
602       //
603       if (!bHasPaveBlocks) {
604         if (bOld) {
605           aDMExEdges.ChangeFind(aPB1).Append(aPB1);
606         } else {
607           aSI.SetShapeType(aType);
608           aSI.SetShape(aSx);
609           iE=myDS->Append(aSI);
610           //
611           aPB1->SetEdge(iE);
612         }
613       }
614       else {
615         BOPDS_InterfFF& aFF=aFFs(iX);
616         BOPDS_VectorOfCurve& aVNC=aFF.ChangeCurves();
617         BOPDS_Curve& aNC=aVNC(iC);
618         BOPDS_ListOfPaveBlock& aLPBC=aNC.ChangePaveBlocks();
619         //
620         const BOPDS_ListOfPaveBlock& aLPBx=aPDS->PaveBlocks(nSx);
621         aNbLPBx=aLPBx.Extent();
622         //
623         if (bOld && !aNbLPBx) {
624           aDMExEdges.ChangeFind(aPB1).Append(aPB1);
625           continue;
626         }
627         //
628         if (!bOld) {
629           aItLPB.Initialize(aLPBC);
630           for (; aItLPB.More(); aItLPB.Next()) {
631             const Handle(BOPDS_PaveBlock)& aPBC=aItLPB.Value();
632             if (aPBC==aPB1) {
633               aLPBC.Remove(aItLPB);
634               break;
635             }
636           } 
637         }
638         //
639         if (!aNbLPBx) {
640           aE=aSx;
641           //
642           if (!aMVI.IsBound(aE)) {
643             aSI.SetShapeType(aType);
644             aSI.SetShape(aE);
645             iE=myDS->Append(aSI);
646             aMVI.Bind(aE, iE);
647           }
648           else {
649             iE=aMVI.Find(aE);
650           }
651           // append new PaveBlock to aLPBC
652           Handle(BOPDS_PaveBlock) aPBC=new BOPDS_PaveBlock();
653           //
654           aPB1->SetEdge(iE);
655           aLPBC.Append(aPB1);
656         } // if (!aNbLPBx) {
657         //
658         else {
659           aItLPB.Initialize(aLPBx);
660           if (bOld) {
661             aPave1[0] = aPB1->Pave1();
662             aPave1[1] = aPB1->Pave2();
663           }
664           for (; aItLPB.More(); aItLPB.Next()) {
665             const Handle(BOPDS_PaveBlock)& aPBx=aItLPB.Value();
666             const Handle(BOPDS_PaveBlock) aPBRx=aPBx->RealPaveBlock();
667             //
668             // update vertices of paves
669             aPave[0]=aPBx->Pave1();
670             aPave[1]=aPBx->Pave2();
671             for (j=0; j<2; ++j) {
672               jx = 0;
673               if (bOld) {
674                 aT = aPave[j].Parameter();
675                 if (aT == aPave1[0].Parameter()) {
676                   jx = 1;
677                 } else if (aT == aPave1[1].Parameter()) {
678                   jx = 2;
679                 }
680                 //
681                 if (jx) {
682                   iV = aPave1[jx-1].Index();
683                 }
684               } 
685               if (!jx) {
686                 nV=aPave[j].Index();
687                 aV=aPDS->Shape(nV);
688                 //
689                 if (!aMVI.IsBound(aV)) {// index of new vertex in theDS -> iV
690                   aSI.SetShapeType(TopAbs_VERTEX);
691                   aSI.SetShape(aV);
692                   iV=myDS->Append(aSI);
693                   aMVI.Bind(aV, iV);
694                 }
695                 else {
696                   iV=aMVI.Find(aV);
697                 }
698               }
699               aPave[j].SetIndex(iV);
700             }
701             //
702             // add edge
703             aE=aPDS->Shape(aPBRx->Edge());
704             //
705             if (!aMVI.IsBound(aE)) {
706               aSI.SetShapeType(aType);
707               aSI.SetShape(aE);
708               iE=myDS->Append(aSI);
709               aMVI.Bind(aE, iE);
710             }
711             else {
712               iE=aMVI.Find(aE);
713             }
714             // append new PaveBlock to aLPBC
715             Handle(BOPDS_PaveBlock) aPBC=new BOPDS_PaveBlock();
716             //
717             aPBC->SetPave1(aPave[0]);
718             aPBC->SetPave2(aPave[1]);
719             aPBC->SetEdge(iE);
720             if (bOld) {
721               aPBC->SetOriginalEdge(aPB1->OriginalEdge());
722               aDMExEdges.ChangeFind(aPB1).Append(aPBC);
723             }
724             else {
725               aLPBC.Append(aPBC);
726             }
727           }
728         }
729       }
730     }//else if (aType==TopAbs_EDGE)
731   }//for (; aItLS.More(); aItLS.Next()) {
732   return iRet;
733 }
734
735 //=======================================================================
736 //function : UpdateFaceInfo
737 //purpose  : 
738 //=======================================================================
739   void BOPAlgo_PaveFiller::UpdateFaceInfo(
740        BOPDS_DataMapOfPaveBlockListOfPaveBlock& theDME)
741 {
742   Standard_Integer i, j, nV1, nF1, nF2, 
743                    aNbFF, aNbC, aNbP, aNbS, aNbPBIn;
744   BOPDS_IndexedMapOfPaveBlock aMPBCopy;
745   BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
746   //
747   BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
748   aNbFF=aFFs.Extent();
749   //
750   //1. Sections (curves, points);
751   for (i=0; i<aNbFF; ++i) {
752     BOPDS_InterfFF& aFF=aFFs(i);
753     aFF.Indices(nF1, nF2);
754     //
755     BOPDS_FaceInfo& aFI1=myDS->ChangeFaceInfo(nF1);
756     BOPDS_FaceInfo& aFI2=myDS->ChangeFaceInfo(nF2);
757     //
758     BOPDS_VectorOfCurve& aVNC=aFF.ChangeCurves();
759     aNbC=aVNC.Extent();
760     for (j=0; j<aNbC; ++j) {
761       BOPDS_Curve& aNC=aVNC(j);
762       BOPDS_ListOfPaveBlock& aLPBC=aNC.ChangePaveBlocks();
763       aItLPB.Initialize(aLPBC);
764       //
765       if (aItLPB.More() && theDME.IsBound(aLPBC.First())) {
766         const Handle(BOPDS_PaveBlock)& aPB=aLPBC.First();
767         BOPDS_ListOfPaveBlock& aLPB = theDME.ChangeFind(aPB);
768         UpdateExistingPaveBlocks(aPB, aLPB, nF1, nF2);
769         aLPBC.Clear();
770         continue;
771       }
772       //
773       for(; aItLPB.More(); aItLPB.Next()) {
774         const Handle(BOPDS_PaveBlock)& aPB=aItLPB.Value();
775         aFI1.ChangePaveBlocksSc().Add(aPB);
776         aFI2.ChangePaveBlocksSc().Add(aPB);
777       }
778     }
779     // VerticesSc
780     const BOPDS_VectorOfPoint& aVNP=aFF.Points();
781     aNbP=aVNP.Extent();
782     for (j=0; j<aNbP; ++j) {
783       const BOPDS_Point& aNP=aVNP(j);
784       nV1=aNP.Index();
785       aFI1.ChangeVerticesSc().Add(nV1);
786       aFI2.ChangeVerticesSc().Add(nV1);
787     }
788   }
789   //
790   //2. PaveBlocksIn
791   if (theDME.IsEmpty()) {
792     return;
793   }
794   //
795   aNbS=myDS->NbSourceShapes();
796   for (i=0; i<aNbS; ++i) {
797     const BOPDS_ShapeInfo& aSI=myDS->ShapeInfo(i);
798     if (aSI.ShapeType()!=TopAbs_FACE) {
799       continue;
800     }
801     //
802     const TopoDS_Face& aF=(*(TopoDS_Face*)(&aSI.Shape()));
803     //
804     if(!myDS->HasFaceInfo(i)) {
805       continue;
806     }
807     BOPDS_FaceInfo& aFI=myDS->ChangeFaceInfo(i);
808     //
809     BOPDS_IndexedMapOfPaveBlock& aMPBIn=aFI.ChangePaveBlocksIn();
810     aMPBCopy.Assign(aMPBIn);
811     aMPBIn.Clear();
812     //
813     aNbPBIn=aMPBCopy.Extent();
814     for (j=1; j<=aNbPBIn; ++j) {
815       const Handle(BOPDS_PaveBlock)& aPB = aMPBCopy(j);
816       if (theDME.IsBound(aPB)) {
817         const BOPDS_ListOfPaveBlock& aLPB = theDME.Find(aPB);
818         aItLPB.Initialize(aLPB);
819         for (; aItLPB.More(); aItLPB.Next()) {
820           const Handle(BOPDS_PaveBlock)& aPB1 = aItLPB.Value();
821           aMPBIn.Add(aPB1);
822         }
823       } else {
824         aMPBIn.Add(aPB);
825       }
826     }//for (j=1; j<=aNbPBIn; ++j) {
827   }//for (i=0; i<aNbS; ++i) {
828 }
829
830 //=======================================================================
831 //function : IsExistingVertex
832 //purpose  : 
833 //=======================================================================
834   Standard_Boolean BOPAlgo_PaveFiller::IsExistingVertex
835     (const gp_Pnt& aP,
836      const Standard_Real theTolR3D,
837      const BOPCol_MapOfInteger& aMVOnIn)const
838 {
839   Standard_Boolean bRet;
840   Standard_Integer nV, iFlag;
841   Standard_Real aTolV;
842   gp_Pnt aPV;
843   Bnd_Box aBoxP;
844   BOPCol_MapIteratorOfMapOfInteger aIt;
845   //
846   bRet=Standard_True;
847   //
848   aBoxP.Add(aP);
849   aBoxP.Enlarge(theTolR3D);
850   //
851   aIt.Initialize(aMVOnIn);
852   for (; aIt.More(); aIt.Next()) {
853     Bnd_Box aBoxV;
854     //
855     nV=aIt.Value();
856     const TopoDS_Vertex& aV=(*(TopoDS_Vertex *)(&myDS->Shape(nV)));
857     aPV=BRep_Tool::Pnt(aV);
858     aTolV=BRep_Tool::Tolerance(aV);
859     aBoxV.Add(aP);
860     aBoxV.Enlarge(aTolV);
861     //
862     if (!aBoxP.IsOut(aBoxV)) {
863       iFlag=BOPTools_AlgoTools::ComputeVV(aV, aP, theTolR3D);
864       if (!iFlag) {
865         return bRet;
866       }
867     }
868   }
869   return !bRet;
870 }
871 //=======================================================================
872 //function : IsExistingPaveBlock
873 //purpose  : 
874 //=======================================================================
875   Standard_Boolean BOPAlgo_PaveFiller::IsExistingPaveBlock
876     (const Handle(BOPDS_PaveBlock)& thePB,
877      const BOPDS_Curve& theNC,
878      const Standard_Real theTolR3D,
879      const BOPCol_ListOfInteger& theLSE)
880 {
881   Standard_Boolean bRet=Standard_True;
882   //
883   if (theLSE.IsEmpty()) {
884     return !bRet;
885   } 
886   //
887   Standard_Real aT1, aT2, aTm, aTx, aTol;
888   Standard_Integer nE, iFlag;
889   gp_Pnt aPm;
890   Bnd_Box aBoxPm;
891   BOPCol_ListIteratorOfListOfInteger aItLI;
892   //
893   thePB->Range(aT1, aT2);
894   aTm=IntTools_Tools::IntermediatePoint (aT1, aT2);
895   theNC.Curve().D0(aTm, aPm);
896   aBoxPm.Add(aPm);
897   aBoxPm.Enlarge(theTolR3D);
898   //
899   aItLI.Initialize(theLSE);
900   for (; aItLI.More(); aItLI.Next()) {
901     nE=aItLI.Value();
902     const BOPDS_ShapeInfo& aSIE=myDS->ChangeShapeInfo(nE);
903     const Bnd_Box& aBoxE=aSIE.Box();
904     if (!aBoxE.IsOut(aBoxPm)) {
905       const TopoDS_Edge& aE=(*(TopoDS_Edge *)(&aSIE.Shape()));
906       aTol = BRep_Tool::Tolerance(aE);
907       aTol = aTol > theTolR3D ? aTol : theTolR3D;
908       iFlag=myContext->ComputePE(aPm, aTol, aE, aTx);
909       if (!iFlag) {
910         return bRet;
911       }
912     }
913   }
914   return !bRet;
915 }
916
917 //=======================================================================
918 //function : IsExistingPaveBlock
919 //purpose  : 
920 //=======================================================================
921   Standard_Boolean BOPAlgo_PaveFiller::IsExistingPaveBlock
922     (const Handle(BOPDS_PaveBlock)& thePB,
923      const BOPDS_Curve& theNC,
924      const Standard_Real theTolR3D,
925      const BOPDS_MapOfPaveBlock& theMPBOnIn,
926      Handle(BOPDS_PaveBlock&) aPBOut)
927 {
928   Standard_Boolean bRet;
929   Standard_Real aT1, aT2, aTm, aTx;
930   Standard_Integer nSp, iFlag, nV11, nV12, nV21, nV22;
931   gp_Pnt aP1, aPm, aP2;
932   Bnd_Box aBoxP1, aBoxPm, aBoxP2;
933   BOPDS_MapIteratorOfMapOfPaveBlock aIt;
934   //
935   bRet=Standard_True;
936   const IntTools_Curve& aIC=theNC.Curve();
937   //
938   thePB->Range(aT1, aT2);
939   thePB->Indices(nV11, nV12);
940   //first point
941   aIC.D0(aT1, aP1);
942   aBoxP1.Add(aP1);
943   aBoxP1.Enlarge(theTolR3D);
944   //intermediate point
945   aTm=IntTools_Tools::IntermediatePoint (aT1, aT2);
946   aIC.D0(aTm, aPm);
947   aBoxPm.Add(aPm);
948   aBoxPm.Enlarge(theTolR3D);
949   //last point
950   aIC.D0(aT2, aP2);
951   aBoxP2.Add(aP2);
952   aBoxP2.Enlarge(theTolR3D);
953   //
954   aIt.Initialize(theMPBOnIn);
955   for (; aIt.More(); aIt.Next()) {
956     const Handle(BOPDS_PaveBlock)& aPB=aIt.Value();
957     aPB->Indices(nV21, nV22);
958     nSp=aPB->Edge();
959     const BOPDS_ShapeInfo& aSISp=myDS->ChangeShapeInfo(nSp);
960     const Bnd_Box& aBoxSp=aSISp.Box();
961     if (!aBoxSp.IsOut(aBoxP1) && !aBoxSp.IsOut(aBoxPm) && !aBoxSp.IsOut(aBoxP2)) {
962       const TopoDS_Edge& aSp=(*(TopoDS_Edge *)(&aSISp.Shape()));
963       iFlag=(nV11 == nV21 || nV11 == nV22) ? 0 : 
964                      myContext->ComputePE(aP1, theTolR3D, aSp, aTx);
965       if (!iFlag) {
966         iFlag=(nV12 == nV21 || nV12 == nV22) ? 0 :
967                        myContext->ComputePE(aP2, theTolR3D, aSp, aTx);
968         if (!iFlag) {
969           iFlag=myContext->ComputePE(aPm, theTolR3D, aSp, aTx);
970           if (!iFlag) {
971             aPBOut = aPB;
972             return bRet;
973           }
974         }
975       }
976     }
977   }
978   return !bRet;
979 }
980
981 //=======================================================================
982 //function : PutBoundPaveOnCurve
983 //purpose  : 
984 //=======================================================================
985   void BOPAlgo_PaveFiller::PutBoundPaveOnCurve(const TopoDS_Face& aF1,
986                                                const TopoDS_Face& aF2,
987                                                const Standard_Real aTolR3D,
988                                                BOPDS_Curve& aNC,
989                                                BOPCol_MapOfInteger& aMVOnIn,
990                                                BOPCol_MapOfInteger& aMVB)
991 {
992   Standard_Boolean bVF;
993   Standard_Integer nV, iFlag, nVn, j, aNbEP;
994   Standard_Real aT[2], aTmin, aTmax, aTV, aTol, aTolVnew;
995   gp_Pnt aP[2];
996   TopoDS_Vertex aVn;
997   BOPDS_ListIteratorOfListOfPave aItLP;
998   BOPDS_Pave aPn, aPMM[2];
999   //
1000   aTolVnew = Precision::Confusion();
1001   //
1002   const IntTools_Curve& aIC=aNC.Curve();
1003   aIC.Bounds(aT[0], aT[1], aP[0], aP[1]);
1004   //
1005   Handle(BOPDS_PaveBlock)& aPB=aNC.ChangePaveBlock1();
1006   const BOPDS_ListOfPave& aLP=aPB->ExtPaves();
1007   //
1008   aNbEP=aLP.Extent();
1009   if (aNbEP) {
1010     aTmin=1.e10;
1011     aTmax=-aTmin;
1012     //
1013     aItLP.Initialize(aLP);
1014     for (; aItLP.More(); aItLP.Next()) {
1015       const BOPDS_Pave& aPv=aItLP.Value();
1016       aPv.Contents(nV, aTV);
1017       if (aTV<aTmin) {
1018         aPMM[0]=aPv;
1019         aTmin=aTV;
1020       }
1021       if (aTV>aTmax) {
1022         aPMM[1]=aPv;
1023         aTmax=aTV;
1024       }
1025     }
1026   }
1027   //
1028   for (j=0; j<2; ++j) {
1029     //if curve is closed, process only one bound
1030     if (j && aP[1].IsEqual(aP[0], aTolVnew)) {
1031       continue;
1032     }
1033     //
1034     iFlag=1;
1035     //
1036     if (aNbEP) {
1037       Bnd_Box aBoxP;
1038       //
1039       aBoxP.Set(aP[j]);
1040       aTol = aTolR3D+Precision::Confusion();
1041       aBoxP.Enlarge(aTol);
1042       const BOPDS_Pave& aPV=aPMM[j];
1043       nV=aPV.Index();
1044       const BOPDS_ShapeInfo& aSIV=myDS->ShapeInfo(nV);
1045       const TopoDS_Vertex& aV=(*(TopoDS_Vertex *)(&aSIV.Shape()));
1046       const Bnd_Box& aBoxV=aSIV.Box();
1047       if (!aBoxP.IsOut(aBoxV)){
1048         iFlag=BOPTools_AlgoTools::ComputeVV(aV, aP[j], aTol);
1049       }
1050     }
1051     if (iFlag) {
1052       // 900/L5
1053       bVF=myContext->IsValidPointForFaces (aP[j], aF1, aF2, aTolR3D);
1054       if (!bVF) {
1055         continue;
1056       }
1057       //
1058       BOPDS_ShapeInfo aSIVn;
1059       //
1060       BOPTools_AlgoTools::MakeNewVertex(aP[j], aTolR3D, aVn);
1061       aSIVn.SetShapeType(TopAbs_VERTEX);
1062       aSIVn.SetShape(aVn);
1063       //
1064       nVn=myDS->Append(aSIVn);
1065       //
1066       aPn.SetIndex(nVn);
1067       aPn.SetParameter(aT[j]);
1068       aPB->AppendExtPave(aPn);
1069       //
1070       aVn=(*(TopoDS_Vertex *)(&myDS->Shape(nVn)));
1071       BOPTools_AlgoTools::UpdateVertex (aIC, aT[j], aVn);
1072       //
1073       aTolVnew = BRep_Tool::Tolerance(aVn);
1074       //
1075       BOPDS_ShapeInfo& aSIDS=myDS->ChangeShapeInfo(nVn);
1076       Bnd_Box& aBoxDS=aSIDS.ChangeBox();
1077       BRepBndLib::Add(aVn, aBoxDS);
1078       aMVOnIn.Add(nVn);
1079       aMVB.Add(nVn);
1080     }
1081   }
1082 }
1083
1084 //=======================================================================
1085 //function : PutPaveOnCurve
1086 //purpose  : 
1087 //=======================================================================
1088   void BOPAlgo_PaveFiller::PutPaveOnCurve(const BOPCol_MapOfInteger& aMVOnIn,
1089                                           const Standard_Real aTolR3D,
1090                                           BOPDS_Curve& aNC,
1091                                           const Standard_Integer nF1,
1092                                           const Standard_Integer nF2,
1093                                           const BOPCol_MapOfInteger& aMVEF)
1094 {
1095   Standard_Boolean bIsVertexOnLine, bInBothFaces;
1096   Standard_Integer nV;
1097   Standard_Real aT;
1098   BOPDS_Pave aPave;
1099   //
1100   BOPCol_MapIteratorOfMapOfInteger aIt;
1101   //
1102   Handle(BOPDS_PaveBlock)& aPB=aNC.ChangePaveBlock1();
1103   const IntTools_Curve& aIC=aNC.Curve();
1104   const Bnd_Box& aBoxC=aNC.Box();
1105   //
1106   aIt.Initialize(aMVOnIn);
1107   for (; aIt.More(); aIt.Next()) {
1108     nV=aIt.Value();
1109     const BOPDS_ShapeInfo& aSIV=myDS->ShapeInfo(nV);
1110     const TopoDS_Vertex& aV=(*(TopoDS_Vertex *)(&aSIV.Shape()));
1111     //
1112     if (!aMVEF.Contains(nV)) {
1113       const Bnd_Box& aBoxV=aSIV.Box();
1114       //
1115       if (aBoxC.IsOut(aBoxV)){
1116         continue; 
1117       }
1118       if (!myDS->IsNewShape(nV)) {
1119         const BOPDS_FaceInfo& aFI1 = myDS->FaceInfo(nF1);
1120         const BOPDS_FaceInfo& aFI2 = myDS->FaceInfo(nF2);
1121         //
1122         bInBothFaces = (aFI1.VerticesOn().Contains(nV) ||
1123                         aFI1.VerticesIn().Contains(nV))&&
1124                           (aFI2.VerticesOn().Contains(nV) ||
1125                            aFI2.VerticesIn().Contains(nV));
1126         if (!bInBothFaces) {
1127           continue;
1128         }
1129       }
1130     }
1131     //
1132     bIsVertexOnLine=myContext->IsVertexOnLine(aV, aIC, aTolR3D, aT);
1133     if (!bIsVertexOnLine) {
1134       Standard_Real aTolVExt;
1135       BOPCol_MapOfInteger aMI;
1136       //
1137       aTolVExt = BRep_Tool::Tolerance(aV);
1138       //
1139       GetFullFaceMap(nF1, aMI);
1140       GetFullFaceMap(nF2, aMI);
1141       //
1142       ExtendedTolerance(nV, aMI, aTolVExt);
1143       bIsVertexOnLine=myContext->IsVertexOnLine(aV, aTolVExt, aIC, aTolR3D, aT);
1144     }   
1145     //
1146     if (bIsVertexOnLine) {
1147       aPave.SetIndex(nV);
1148       aPave.SetParameter(aT);
1149       //
1150       aPB->AppendExtPave(aPave);
1151       //
1152       BOPTools_AlgoTools::UpdateVertex (aIC, aT, aV);
1153       // 
1154       BOPDS_ShapeInfo& aSIDS=myDS->ChangeShapeInfo(nV);
1155       Bnd_Box& aBoxDS=aSIDS.ChangeBox();
1156       BRepBndLib::Add(aV, aBoxDS);
1157     }
1158   }
1159 }
1160
1161 //=======================================================================
1162 //function : ExtendedTolerance
1163 //purpose  : 
1164 //=======================================================================
1165   Standard_Boolean BOPAlgo_PaveFiller::ExtendedTolerance(const Standard_Integer nV,
1166                                                          const BOPCol_MapOfInteger& aMI,
1167                                                          Standard_Real& aTolVExt)
1168 {
1169   Standard_Boolean bFound = Standard_False;
1170   if (!(myDS->IsNewShape(nV))) {
1171     return bFound;
1172   }
1173
1174   Standard_Integer i, k, aNbLines;
1175   Standard_Real aT11, aT12, aD1, aD2, aD;
1176   TopoDS_Vertex aV;
1177   gp_Pnt aPV, aP11, aP12;
1178
1179   aV = (*(TopoDS_Vertex *)(&myDS->Shape(nV)));
1180   aPV=BRep_Tool::Pnt(aV);
1181   //
1182   BOPDS_VectorOfInterfEE& aEEs=myDS->InterfEE();
1183   BOPDS_VectorOfInterfEF& aEFs=myDS->InterfEF();
1184
1185   for (k=0; k<2; ++k) {
1186     aNbLines = !k ? aEEs.Extent() : aEFs.Extent();
1187     for (i = 0; i < aNbLines; ++i) {
1188       BOPDS_Interf *aInt = !k ? (BOPDS_Interf*) (&aEEs(i)) :
1189                                 (BOPDS_Interf*) (&aEFs(i));
1190       if (aInt->IndexNew() == nV) {
1191         if (aMI.Contains(aInt->Index1()) && aMI.Contains(aInt->Index2())) {
1192           const IntTools_CommonPrt& aComPrt = !k ? aEEs(i).CommonPart() :
1193                                                    aEFs(i).CommonPart();
1194           //
1195           const TopoDS_Edge& aE1=aComPrt.Edge1();
1196           aComPrt.Range1(aT11, aT12);
1197           BOPTools_AlgoTools::PointOnEdge(aE1, aT11, aP11);
1198           BOPTools_AlgoTools::PointOnEdge(aE1, aT12, aP12);
1199           aD1=aPV.Distance(aP11);
1200           aD2=aPV.Distance(aP12);
1201           aD=(aD1>aD2)? aD1 : aD2;
1202           if (aD>aTolVExt) {
1203             aTolVExt=aD;
1204           }
1205           return !bFound;
1206         }//if (aMI.Contains(aEF.Index1()) && aMI.Contains(aEF.Index2())) {
1207       }//if (aInt->IndexNew() == nV) {
1208     }//for (i = 0; i < aNbLines; ++i) {
1209   }//for (k=0; k<2; ++k) {
1210
1211   return bFound;
1212 }
1213
1214 //=======================================================================
1215 //function : GetEFPnts
1216 //purpose  : 
1217 //=======================================================================
1218   void BOPAlgo_PaveFiller::GetEFPnts(const Standard_Integer nF1,
1219                                      const Standard_Integer nF2,
1220                                      IntSurf_ListOfPntOn2S& aListOfPnts)
1221 {
1222   Standard_Integer nE, nF, nFOpposite, aNbEFs, i;
1223   Standard_Real U1, U2, V1, V2, f, l;
1224   BOPCol_MapOfInteger aMIF1, aMIF2;
1225   //
1226   //collect indexes of all shapes from nF1 and nF2.
1227   GetFullFaceMap(nF1, aMIF1);
1228   GetFullFaceMap(nF2, aMIF2);
1229   //
1230   BOPDS_VectorOfInterfEF& aEFs=myDS->InterfEF();
1231   aNbEFs = aEFs.Extent();
1232   //
1233   for(i = 0; i < aNbEFs; ++i) {
1234     const BOPDS_InterfEF& aEF = aEFs(i);
1235     nE = aEF.Index1();
1236     nFOpposite = aEF.Index2();
1237     if(aMIF1.Contains(nE) && aMIF2.Contains(nFOpposite) ||
1238        aMIF1.Contains(nFOpposite) && aMIF2.Contains(nE)) {
1239       //
1240       IntTools_CommonPrt aCP = aEF.CommonPart();
1241       if(aCP.Type() == TopAbs_VERTEX) {
1242         Standard_Real aPar = aCP.VertexParameter1();
1243         const TopoDS_Edge& aE = (*(TopoDS_Edge*)(&myDS->Shape(nE)));
1244         const TopoDS_Face& aFOpposite = (*(TopoDS_Face*)(&myDS->Shape(nFOpposite)));
1245         //
1246         const Handle(Geom_Curve)& aCurve = BRep_Tool::Curve(aE, f, l);
1247         //
1248         nF = (nFOpposite == nF1) ? nF2 : nF1;
1249         const TopoDS_Face& aF = (*(TopoDS_Face*)(&myDS->Shape(nF)));
1250         Handle(Geom2d_Curve) aPCurve = BRep_Tool::CurveOnSurface(aE, aF, f, l);
1251         //
1252         GeomAPI_ProjectPointOnSurf& aProj = myContext->ProjPS(aFOpposite);
1253         //
1254         gp_Pnt aPoint;
1255         aCurve->D0(aPar, aPoint);
1256         IntSurf_PntOn2S aPnt;
1257         if(!aPCurve.IsNull()) {
1258           gp_Pnt2d aP2d = aPCurve->Value(aPar);
1259           aProj.Perform(aPoint);
1260           if(aProj.IsDone()) {
1261             aProj.LowerDistanceParameters(U1,V1);
1262             if (nF == nF1) {
1263               aPnt.SetValue(aP2d.X(),aP2d.Y(),U1,V1);
1264             } else {
1265               aPnt.SetValue(U1,V1,aP2d.X(),aP2d.Y());
1266             }
1267             aListOfPnts.Append(aPnt);
1268           }
1269         }
1270         else {
1271           GeomAPI_ProjectPointOnSurf& aProj1 = myContext->ProjPS(aF);
1272           aProj1.Perform(aPoint);
1273           aProj.Perform(aPoint);
1274           if(aProj1.IsDone() && aProj.IsDone()){
1275             aProj1.LowerDistanceParameters(U1,V1);
1276             aProj.LowerDistanceParameters(U2,V2);
1277             if (nF == nF1) {
1278               aPnt.SetValue(U1,V1,U2,V2);
1279             } else {
1280               aPnt.SetValue(U2,V2,U1,V1);
1281             }
1282             aListOfPnts.Append(aPnt);
1283           }
1284         }
1285       }
1286     }
1287   }
1288 }
1289
1290 //=======================================================================
1291 //function : ProcessUnUsedVertices
1292 //purpose  : 
1293 //=======================================================================
1294   void BOPAlgo_PaveFiller::PutEFPavesOnCurve(const Standard_Integer nF1,
1295                                              const Standard_Integer nF2,
1296                                              BOPDS_Curve& aNC,
1297                                              const BOPCol_MapOfInteger& aMVEF)
1298 {
1299   if (!aMVEF.Extent()) {
1300     return;
1301   }
1302   //
1303   const IntTools_Curve& aIC=aNC.Curve();
1304   GeomAbs_CurveType aTypeC;
1305   aTypeC=aIC.Type();
1306   if (!(aTypeC==GeomAbs_BezierCurve || aTypeC==GeomAbs_BSplineCurve)) {
1307     return;
1308   }
1309   //
1310   Standard_Integer nV;
1311   BOPCol_MapOfInteger aMV;
1312   //
1313   aMV.Assign(aMVEF);
1314   RemoveUsedVertices(aNC, aMV);
1315   if (!aMV.Extent()) {
1316     return;
1317   }
1318   //
1319   Standard_Real aDist;
1320   BOPDS_Pave aPave;
1321   //
1322   const Handle(Geom_Curve)& aC3D=aIC.Curve();
1323   Handle(BOPDS_PaveBlock)& aPB = aNC.ChangePaveBlock1();
1324
1325   GeomAPI_ProjectPointOnCurve& aProjPT = myContext->ProjPT(aC3D);
1326   
1327   BOPCol_MapIteratorOfMapOfInteger aItMI;
1328   aItMI.Initialize(aMV);
1329   for (; aItMI.More(); aItMI.Next()) {
1330     nV = aItMI.Value();
1331     const TopoDS_Vertex& aV = (*(TopoDS_Vertex *)(&myDS->Shape(nV)));
1332     gp_Pnt aPV = BRep_Tool::Pnt(aV);
1333     aProjPT.Perform(aPV);
1334     Standard_Integer aNbPoints = aProjPT.NbPoints();
1335     if (aNbPoints) {
1336       aDist = aProjPT.LowerDistance();
1337       PutPaveOnCurve(nV, aDist, aNC, aPB);
1338     }
1339   }
1340 }
1341
1342 //=======================================================================
1343 //function : ProcessUnUsedVertices
1344 //purpose  : 
1345 //=======================================================================
1346   void BOPAlgo_PaveFiller::PutStickPavesOnCurve(const Standard_Integer nF1,
1347                                                 const Standard_Integer nF2,
1348                                                 BOPDS_Curve& aNC,
1349                                                 const BOPCol_MapOfInteger& aMVStick)
1350 {
1351   BOPCol_MapOfInteger aMV;
1352   aMV.Assign(aMVStick);
1353   RemoveUsedVertices(aNC, aMV);
1354   //
1355   if (!aMV.Extent()) {
1356     return;
1357   }
1358   //
1359   GeomAbs_SurfaceType aType1, aType2;
1360   const TopoDS_Face& aF1 = (*(TopoDS_Face*)(&myDS->Shape(nF1)));  
1361   const TopoDS_Face& aF2 = (*(TopoDS_Face*)(&myDS->Shape(nF2)));  
1362   Handle(Geom_Surface) aS1=BRep_Tool::Surface(aF1);
1363   Handle(Geom_Surface) aS2=BRep_Tool::Surface(aF2);
1364   GeomAdaptor_Surface aGAS1(aS1);
1365   GeomAdaptor_Surface aGAS2(aS2);
1366   
1367   //
1368   aType1=aGAS1.GetType();
1369   aType2=aGAS2.GetType();
1370   //
1371   if(aType1==GeomAbs_Torus  || aType2==GeomAbs_Torus) {
1372     Standard_Integer nV, m, n;
1373     Standard_Real aTC[2], aD, aD2, u, v, aDT2, aScPr, aDScPr;
1374     GeomAbs_CurveType aTypeC;
1375     gp_Pnt aPC[2], aPV;
1376     gp_Dir aDN[2];
1377     gp_Pnt2d aP2D;
1378     
1379     Handle(Geom2d_Curve) aC2D[2];
1380     //
1381     aDT2=2e-7;     // the rich criteria
1382     aDScPr=5.e-9;  // the creasing criteria
1383     //
1384     const IntTools_Curve& aIC=aNC.Curve();
1385     //Handle(Geom_Curve) aC3D=aIC.Curve(); //DEB
1386     aTypeC=aIC.Type();
1387     if (aTypeC==GeomAbs_BezierCurve || aTypeC==GeomAbs_BSplineCurve) {
1388       //
1389       aIC.Bounds(aTC[0], aTC[1], aPC[0], aPC[1]);
1390       aC2D[0]=aIC.FirstCurve2d();
1391       aC2D[1]=aIC.SecondCurve2d();
1392       if (!aC2D[0].IsNull() && !aC2D[1].IsNull()) {
1393         BOPCol_MapIteratorOfMapOfInteger aItMI, aItMI1;
1394         aItMI.Initialize(aMV);
1395         for (; aItMI.More(); aItMI.Next()) {
1396           nV = aItMI.Value();
1397           const TopoDS_Vertex& aV=*((TopoDS_Vertex*)&myDS->Shape(nV));
1398           aPV=BRep_Tool::Pnt(aV);
1399           //
1400           for (m=0; m<2; ++m) {
1401             aD2=aPC[m].SquareDistance(aPV);
1402             if (aD2>aDT2) {// no rich
1403               continue; 
1404             }
1405             //
1406             for (n=0; n<2; ++n) {
1407               Handle(Geom_Surface)& aS=(!n)? aS1 : aS2;
1408               aC2D[n]->D0(aTC[m], aP2D);
1409               aP2D.Coord(u, v);
1410               BOPTools_AlgoTools3D::GetNormalToSurface(aS, u, v, aDN[n]);
1411             }
1412             // 
1413             aScPr=aDN[0]*aDN[1];
1414             if (aScPr<0.) {
1415               aScPr=-aScPr;
1416             }
1417             aScPr=1.-aScPr;
1418             //
1419             if (aScPr>aDScPr) {
1420               continue;
1421             }
1422             //
1423             // The intersection curve aIC is vanishing curve (the crease)
1424             aD=sqrt(aD2);
1425             //
1426             Handle(BOPDS_PaveBlock)& aPB=aNC.ChangePaveBlock1();
1427             PutPaveOnCurve(nV, aD, aNC, aPB);
1428           }
1429         }//for (jVU=1; jVU=aNbVU; ++jVU) {
1430       }
1431     }//if (aTypeC==GeomAbs_BezierCurve || aTypeC==GeomAbs_BSplineCurve) {
1432   }//if(aType1==GeomAbs_Torus  || aType2==GeomAbs_Torus) {
1433 }
1434
1435 //=======================================================================
1436 //function : GetStickVertices
1437 //purpose  : 
1438 //=======================================================================
1439   void BOPAlgo_PaveFiller::GetStickVertices(const Standard_Integer nF1,
1440                                             const Standard_Integer nF2,
1441                                             BOPCol_MapOfInteger& aMVStick,
1442                                             BOPCol_MapOfInteger& aMVEF)
1443 {
1444   BOPCol_MapOfInteger aMIF1, aMIF2;
1445   Standard_Integer nV1, nV2, nE1, nE2, nV, nE, nF, nVNew, i;
1446   //
1447   BOPDS_VectorOfInterfVV& aVVs=myDS->InterfVV();
1448   BOPDS_VectorOfInterfVE& aVEs=myDS->InterfVE();
1449   BOPDS_VectorOfInterfEE& aEEs=myDS->InterfEE();
1450   BOPDS_VectorOfInterfVF& aVFs=myDS->InterfVF();
1451   BOPDS_VectorOfInterfEF& aEFs=myDS->InterfEF();
1452   //
1453   Standard_Integer aNbVVs, aNbVEs, aNbEEs, aNbVFs, aNbEFs;
1454   aNbVVs = aVVs.Extent();
1455   aNbVEs = aVEs.Extent();
1456   aNbEEs = aEEs.Extent();
1457   aNbVFs = aVFs.Extent();
1458   aNbEFs = aEFs.Extent();
1459   //
1460   //collect indexes of all shapes from nF1 and nF2.
1461   GetFullFaceMap(nF1, aMIF1);
1462   GetFullFaceMap(nF2, aMIF2);
1463   //collect VV interferences
1464   for(i = 0; i < aNbVVs; ++i) {
1465     const BOPDS_InterfVV& aVV = aVVs(i);
1466     nV1 = aVV.Index1();
1467     nV2 = aVV.Index2();
1468     if(aMIF1.Contains(nV1) && aMIF2.Contains(nV2) ||
1469        aMIF1.Contains(nV2) && aMIF2.Contains(nV1)) {
1470       if (aVV.HasIndexNew()) {
1471         nVNew = aVV.IndexNew();
1472         aMVStick.Add(nVNew);
1473       }
1474     }
1475   }
1476   //collect VE interferences
1477   for(i = 0; i < aNbVEs; ++i) {
1478     const BOPDS_InterfVE& aVE = aVEs(i);
1479     nV = aVE.Index1();
1480     nE = aVE.Index2();
1481     if(aMIF1.Contains(nV) && aMIF2.Contains(nE) ||
1482        aMIF1.Contains(nE) && aMIF2.Contains(nV)) {
1483       aMVStick.Add(nV);
1484     }
1485   }
1486   //collect EE interferences
1487   for(i = 0; i < aNbEEs; ++i) {
1488     const BOPDS_InterfEE& aEE = aEEs(i);
1489     nE1 = aEE.Index1();
1490     nE2 = aEE.Index2();
1491     if(aMIF1.Contains(nE1) && aMIF2.Contains(nE2) ||
1492        aMIF1.Contains(nE2) && aMIF2.Contains(nE1)) {
1493       IntTools_CommonPrt aCP = aEE.CommonPart();
1494       if(aCP.Type() == TopAbs_VERTEX) {
1495         nVNew = aEE.IndexNew();
1496         aMVStick.Add(nVNew);
1497       }
1498     }
1499   }
1500   //collect VF interferences
1501   for(i = 0; i < aNbVFs; ++i) {
1502     const BOPDS_InterfVF& aVF = aVFs(i);
1503     nV = aVF.Index1();
1504     nF = aVF.Index2();
1505     if(aMIF1.Contains(nV) && aMIF2.Contains(nF) ||
1506        aMIF1.Contains(nF) && aMIF2.Contains(nV)) {
1507       aMVStick.Add(nV);
1508     }
1509   }
1510   //collect EF interferences
1511   for(i = 0; i < aNbEFs; ++i) {
1512     const BOPDS_InterfEF& aEF = aEFs(i);
1513     nE = aEF.Index1();
1514     nF = aEF.Index2();
1515     if(aMIF1.Contains(nE) && aMIF2.Contains(nF) ||
1516        aMIF1.Contains(nF) && aMIF2.Contains(nE)) {
1517       IntTools_CommonPrt aCP = aEF.CommonPart();
1518       if(aCP.Type() == TopAbs_VERTEX) {
1519         nVNew = aEF.IndexNew();
1520         aMVStick.Add(nVNew);
1521         aMVEF.Add(nVNew);
1522       }
1523     }
1524   }
1525 }
1526
1527 //=======================================================================
1528 // function: GetFullFaceMap
1529 // purpose: 
1530 //=======================================================================
1531 void BOPAlgo_PaveFiller::GetFullFaceMap(const Standard_Integer nF,
1532                                         BOPCol_MapOfInteger& aMI)
1533 {
1534   Standard_Integer nV, nE;
1535   TopoDS_Edge aE;
1536   TopoDS_Vertex aV;
1537   //face
1538   aMI.Add(nF);
1539   //edges
1540   const TopoDS_Face& aF = (*(TopoDS_Face*)(&myDS->Shape(nF)));
1541   TopExp_Explorer anExp(aF, TopAbs_EDGE);
1542   for (; anExp.More(); anExp.Next()) {
1543     aE = (*(TopoDS_Edge *)(&anExp.Current()));
1544     nE = myDS->Index(aE);
1545     aMI.Add(nE);
1546   }
1547   //vertices
1548   TopExp_Explorer anExpV(aF, TopAbs_VERTEX);
1549   for (; anExpV.More(); anExpV.Next()) {
1550     aV = (*(TopoDS_Vertex *)(&anExpV.Current()));
1551     nV = myDS->Index(aV);
1552     aMI.Add(nV);
1553   }
1554 }
1555
1556 //=======================================================================
1557 // function: RemoveUsedVertices
1558 // purpose: 
1559 //=======================================================================
1560 void BOPAlgo_PaveFiller::RemoveUsedVertices(BOPDS_Curve& aNC,
1561                                             BOPCol_MapOfInteger& aMV)
1562 {
1563   if (!aMV.Extent()) {
1564     return;
1565   }
1566   Standard_Integer nV;
1567   BOPDS_Pave aPave;
1568   BOPDS_ListIteratorOfListOfPave aItLP;
1569   //
1570   Handle(BOPDS_PaveBlock)& aPB=aNC.ChangePaveBlock1();
1571   const BOPDS_ListOfPave& aLP = aPB->ExtPaves();
1572   aItLP.Initialize(aLP);
1573   for (;aItLP.More();aItLP.Next()) {
1574     aPave = aItLP.Value();
1575     nV = aPave.Index();
1576     aMV.Remove(nV);
1577   }
1578 }
1579
1580 //=======================================================================
1581 //function : PutPaveOnCurve
1582 //purpose  : 
1583 //=======================================================================
1584   void BOPAlgo_PaveFiller::PutPaveOnCurve(const Standard_Integer nV,
1585                                           const Standard_Real aTolR3D,
1586                                           const BOPDS_Curve& aNC, 
1587                                           Handle(BOPDS_PaveBlock)& aPB)
1588 {
1589   Standard_Boolean bIsVertexOnLine;
1590   Standard_Real aT;
1591   BOPDS_Pave aPave;
1592   //
1593   const TopoDS_Vertex aV = (*(TopoDS_Vertex *)(&myDS->Shape(nV)));
1594   const IntTools_Curve& aIC = aNC.Curve();
1595   //
1596   bIsVertexOnLine=myContext->IsVertexOnLine(aV, aIC, aTolR3D, aT);
1597   if (bIsVertexOnLine) {
1598     aPave.SetIndex(nV);
1599     aPave.SetParameter(aT);
1600     //
1601     aPB->AppendExtPave(aPave);
1602     //
1603     BOPTools_AlgoTools::UpdateVertex (aIC, aT, aV);
1604     // 
1605     BOPDS_ShapeInfo& aSIDS=myDS->ChangeShapeInfo(nV);
1606     Bnd_Box& aBoxDS=aSIDS.ChangeBox();
1607     BRepBndLib::Add(aV, aBoxDS);
1608   }
1609 }
1610
1611 //=======================================================================
1612 //function : ProcessOldPaveBlocks
1613 //purpose  : 
1614 //=======================================================================
1615   void BOPAlgo_PaveFiller::ProcessExistingPaveBlocks
1616     (const Standard_Integer theInt,
1617      const BOPDS_MapOfPaveBlock& aMPBOnIn,
1618      BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& aMSCPB,
1619      BOPCol_DataMapOfShapeInteger& aMVI,
1620      const BOPCol_MapOfInteger& aMVB,
1621      BOPDS_MapOfPaveBlock& aMPB)
1622 {
1623   Standard_Integer nV, nE, iFlag;
1624   Standard_Real aT;
1625   BOPCol_MapIteratorOfMapOfInteger aItB;
1626   BOPDS_MapIteratorOfMapOfPaveBlock aItPB;
1627   //
1628   BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
1629   BOPDS_InterfFF& aFF = aFFs(theInt);
1630   BOPDS_VectorOfCurve& aVC=aFF.ChangeCurves();
1631   //  
1632   aItB.Initialize(aMVB);
1633   for (; aItB.More(); aItB.Next()) {
1634     nV = aItB.Value();
1635     const BOPDS_ShapeInfo& aSIV=myDS->ShapeInfo(nV);
1636     const Bnd_Box& aBoxV=aSIV.Box();
1637     const TopoDS_Vertex& aV = *(TopoDS_Vertex*)&aSIV.Shape();
1638     if (!aMVI.IsBound(aV)) {
1639       continue;
1640     }
1641     //
1642     aItPB.Initialize(aMPBOnIn);
1643     for (; aItPB.More(); aItPB.Next()) {
1644       const Handle(BOPDS_PaveBlock)& aPB = aItPB.Value();
1645       if (aPB->Pave1().Index() == nV || aPB->Pave2().Index() == nV) {
1646         continue;
1647       }
1648       //
1649       if (aMPB.Contains(aPB)) {
1650         continue;
1651       }
1652       nE=aPB->Edge();
1653       const BOPDS_ShapeInfo& aSIE=myDS->ShapeInfo(nE);
1654       const Bnd_Box& aBoxE=aSIE.Box();
1655       //
1656       if (!aBoxV.IsOut(aBoxE)) {
1657         const TopoDS_Edge& aE = *(TopoDS_Edge*)&aSIE.Shape();
1658         //
1659         iFlag=myContext->ComputeVE (aV, aE, aT);
1660         if (!iFlag) {
1661           aMPB.Add(aPB);
1662           //
1663           PreparePostTreatFF(theInt, aPB, aMSCPB, aMVI, aVC);
1664         }
1665       }
1666     }
1667   }
1668 }
1669
1670 //=======================================================================
1671 //function : UpdateExistingPaveBlocks
1672 //purpose  : 
1673 //=======================================================================
1674   void BOPAlgo_PaveFiller::UpdateExistingPaveBlocks
1675     (const Handle(BOPDS_PaveBlock)& aPBf,
1676      BOPDS_ListOfPaveBlock& aLPB,
1677      const Standard_Integer nF1,
1678      const Standard_Integer nF2) 
1679 {
1680   Standard_Integer nE;
1681   Standard_Boolean bCB;
1682   Handle(BOPDS_PaveBlock) aPB, aPB1, aPB2, aPB2n;
1683   Handle(BOPDS_CommonBlock) aCB;
1684   BOPDS_ListIteratorOfListOfPaveBlock aIt, aIt1, aIt2;
1685   BOPDS_IndexedMapOfPaveBlock aMPB;
1686   //
1687   //remove micro edges from aLPB
1688   aIt.Initialize(aLPB);
1689   for (; aIt.More();) {
1690     aPB = aIt.Value();
1691     const TopoDS_Edge& aE = *(TopoDS_Edge*)&myDS->Shape(aPB->Edge());
1692     if (BOPTools_AlgoTools::IsMicroEdge(aE, myContext)) {
1693       aLPB.Remove(aIt);
1694       continue;
1695     }
1696     aIt.Next();
1697   }
1698   //
1699   if (!aLPB.Extent()) {
1700     return;
1701   }
1702   //update face info
1703   myDS->UpdateFaceInfoOn(nF1);
1704   //
1705   myDS->UpdateFaceInfoOn(nF2);
1706   //
1707   BOPDS_FaceInfo& aFI1 = myDS->ChangeFaceInfo(nF1);
1708   BOPDS_FaceInfo& aFI2 = myDS->ChangeFaceInfo(nF2);
1709   //
1710   BOPDS_IndexedMapOfPaveBlock& aMPBOn1 = aFI1.ChangePaveBlocksOn();
1711   BOPDS_IndexedMapOfPaveBlock& aMPBIn1 = aFI1.ChangePaveBlocksIn();
1712   BOPDS_IndexedMapOfPaveBlock& aMPBOn2 = aFI2.ChangePaveBlocksOn();
1713   BOPDS_IndexedMapOfPaveBlock& aMPBIn2 = aFI2.ChangePaveBlocksIn();
1714   //
1715   // remove old pave blocks
1716   const Handle(BOPDS_CommonBlock)& aCB1 = aPBf->CommonBlock();
1717   bCB = !aCB1.IsNull();
1718   BOPDS_ListOfPaveBlock aLPB1;
1719   //
1720   if (bCB) {
1721     aLPB1.Assign(aCB1->PaveBlocks());
1722   } else {
1723     aLPB1.Append(aPBf);
1724   }
1725   aIt1.Initialize(aLPB1);
1726   for (; aIt1.More(); aIt1.Next()) {
1727     aPB1 = aIt1.Value();
1728     nE = aPB1->OriginalEdge();
1729     //
1730     BOPDS_ListOfPaveBlock& aLPB2 = myDS->ChangePaveBlocks(nE);
1731     aIt2.Initialize(aLPB2);
1732     for (; aIt2.More(); aIt2.Next()) {
1733       aPB2 = aIt2.Value();
1734       if (aPB1 == aPB2) {
1735         aLPB2.Remove(aIt2);
1736         break;
1737       }
1738     }
1739   }
1740   //
1741   if (bCB) {
1742     //create new pave blocks
1743     const BOPCol_ListOfInteger& aFaces = aCB1->Faces();
1744     aIt.Initialize(aLPB);
1745     for (; aIt.More(); aIt.Next()) {
1746       Handle(BOPDS_PaveBlock)& aPB = aIt.ChangeValue();
1747       //
1748       aCB = new BOPDS_CommonBlock;
1749       aIt1.Initialize(aLPB1);
1750       for (; aIt1.More(); aIt1.Next()) {
1751         aPB2 = aIt1.Value();
1752         nE = aPB2->OriginalEdge();
1753         //
1754         aPB2n = new BOPDS_PaveBlock;
1755         aPB2n->SetPave1(aPB->Pave1());
1756         aPB2n->SetPave2(aPB->Pave2());
1757         aPB2n->SetEdge(aPB->Edge());
1758         aPB2n->SetOriginalEdge(nE);
1759         aCB->AddPaveBlock(aPB2n);
1760         aPB2n->SetCommonBlock(aCB);
1761         myDS->ChangePaveBlocks(nE).Append(aPB2n);
1762       }
1763       aCB->AddFaces(aFaces);
1764       myDS->SortPaveBlocks(aCB);
1765       //
1766       aPB=aCB->PaveBlocks().First();
1767     }
1768   } 
1769   //
1770   aIt.Initialize(aLPB);
1771   for (; aIt.More(); aIt.Next()) {
1772     Handle(BOPDS_PaveBlock)& aPB = aIt.ChangeValue();
1773     nE = aPB->OriginalEdge();
1774     //
1775     Standard_Integer nF = (aMPBOn1.Contains(aPBf) || 
1776                            aMPBIn1.Contains(aPBf)) ? nF2 : nF1;
1777     const TopoDS_Face& aF = *(TopoDS_Face*)&myDS->Shape(nF);
1778     IntTools_Range aShrR(aPB->Pave1().Parameter(), aPB->Pave2().Parameter());
1779     const TopoDS_Edge& aE = *(TopoDS_Edge*)&myDS->Shape(aPB->Edge());
1780     //
1781     Standard_Boolean bCom = BOPTools_AlgoTools::IsBlockInOnFace(aShrR, aF, aE, myContext);
1782     if (bCom) {
1783       if (bCB) {
1784         aCB = aPB->CommonBlock();
1785         aCB->AddFace(nF);
1786       } else {
1787         aCB = new BOPDS_CommonBlock;
1788         aCB->AddPaveBlock(aPB);
1789         aCB->AddFace(nF1);
1790         aCB->AddFace(nF2);
1791         //
1792         aPB->SetCommonBlock(aCB);
1793       }
1794       aMPB.Add(aPB);
1795     }
1796     if (!bCB) {
1797       myDS->ChangePaveBlocks(nE).Append(aPB);
1798     }
1799   }
1800   //
1801   Standard_Integer i, aNbPB;
1802   Standard_Boolean bIn1, bIn2;
1803   //
1804   bIn1 = aMPBOn1.Contains(aPBf) || aMPBIn1.Contains(aPBf);
1805   bIn2 = aMPBOn2.Contains(aPBf) || aMPBIn2.Contains(aPBf);
1806   //
1807   aNbPB=aMPB.Extent();
1808   for (i=1; i<=aNbPB; ++i) {
1809     aPB = aMPB(i);
1810     if (!bIn1) {
1811       aMPBIn1.Add(aPB);
1812     }
1813     //
1814     if (!bIn2) {
1815       aMPBIn2.Add(aPB);
1816     }
1817   }
1818 }
1819
1820 //=======================================================================
1821 // function: PutClosingPaveOnCurve
1822 // purpose:
1823 //=======================================================================
1824   void BOPAlgo_PaveFiller::PutClosingPaveOnCurve(BOPDS_Curve& aNC)
1825 {
1826   Standard_Boolean bIsClosed, bHasBounds, bAdded;
1827   Standard_Integer nVC, j;
1828   Standard_Real aT[2], aTC, dT, aTx;
1829   gp_Pnt aP[2] ; 
1830   BOPDS_Pave aPVx;
1831   BOPDS_ListIteratorOfListOfPave aItLP;
1832   //
1833   const IntTools_Curve& aIC=aNC.Curve();
1834   const Handle(Geom_Curve)& aC3D=aIC.Curve();
1835   if(aC3D.IsNull()) {
1836     return;
1837   }
1838   //
1839   bIsClosed=IntTools_Tools::IsClosed(aC3D);
1840   if (!bIsClosed) {
1841     return;
1842   }
1843   //
1844   bHasBounds=aIC.HasBounds ();
1845   if (!bHasBounds){
1846     return;
1847   }
1848   // 
1849   bAdded=Standard_False;
1850   dT=Precision::PConfusion();
1851   aIC.Bounds (aT[0], aT[1], aP[0], aP[1]);
1852   //
1853   Handle(BOPDS_PaveBlock)& aPB=aNC.ChangePaveBlock1();
1854   BOPDS_ListOfPave& aLP=aPB->ChangeExtPaves();
1855   //
1856   aItLP.Initialize(aLP);
1857   for (; aItLP.More() && !bAdded; aItLP.Next()) {
1858     const BOPDS_Pave& aPC=aItLP.Value();
1859     nVC=aPC.Index();
1860     aTC=aPC.Parameter();
1861     //
1862     for (j=0; j<2; ++j) {
1863       if (fabs(aTC-aT[j]) < dT) {
1864         aTx=(!j) ? aT[1] : aT[0];
1865         aPVx.SetIndex(nVC);
1866         aPVx.SetParameter(aTx);
1867         aLP.Append(aPVx);
1868         //
1869         bAdded=Standard_True;
1870         break;
1871       }
1872     }
1873   }
1874 }
1875
1876 //=======================================================================
1877 //function : PreparePostTreatFF
1878 //purpose  : 
1879 //=======================================================================
1880   void BOPAlgo_PaveFiller::PreparePostTreatFF
1881     (const Standard_Integer aInt,
1882      const Handle(BOPDS_PaveBlock)& aPB,
1883      BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& aMSCPB,
1884      BOPCol_DataMapOfShapeInteger& aMVI,
1885      BOPDS_VectorOfCurve& aVC) 
1886 {
1887   Standard_Integer nV1, nV2;
1888   //
1889   Standard_Integer iC=aVC.Append()-1;
1890   BOPDS_ListOfPaveBlock& aLPBC = aVC(iC).ChangePaveBlocks();
1891   aLPBC.Append(aPB);
1892   //
1893   aPB->Indices(nV1, nV2);
1894   const TopoDS_Vertex& aV1=(*(TopoDS_Vertex *)(&myDS->Shape(nV1)));
1895   const TopoDS_Vertex& aV2=(*(TopoDS_Vertex *)(&myDS->Shape(nV2)));
1896   const TopoDS_Edge& aE = *(TopoDS_Edge*)&myDS->Shape(aPB->Edge());
1897   // Keep info for post treatment 
1898   BOPDS_CoupleOfPaveBlocks aCPB;
1899   aCPB.SetIndexInterf(aInt);
1900   aCPB.SetIndex(iC);
1901   aCPB.SetPaveBlock1(aPB);
1902   //
1903   aMSCPB.Add(aE, aCPB);
1904   aMVI.Bind(aV1, nV1);
1905   aMVI.Bind(aV2, nV2);
1906 }
1907
1908 //=======================================================================
1909 //function : ToleranceFF
1910 //purpose  : Computes the TolFF according to the tolerance value and 
1911 //           types of the faces.
1912 //=======================================================================
1913   void ToleranceFF(const TopoDS_Face& aF1,
1914                    const TopoDS_Face& aF2,
1915                    Standard_Real& aTolFF)
1916 {
1917   Standard_Real aTol1, aTol2;
1918   Standard_Boolean isAna1, isAna2;
1919   //
1920   aTol1 = BRep_Tool::Tolerance(aF1);
1921   aTol2 = BRep_Tool::Tolerance(aF2);
1922   aTolFF = Max(aTol1, aTol2);
1923   //
1924   BRepAdaptor_Surface BAS1(aF1);
1925   BRepAdaptor_Surface BAS2(aF2);
1926   //
1927   isAna1 = (BAS1.GetType() == GeomAbs_Plane ||
1928             BAS1.GetType() == GeomAbs_Cylinder ||
1929             BAS1.GetType() == GeomAbs_Cone ||
1930             BAS1.GetType() == GeomAbs_Sphere ||
1931             BAS1.GetType() == GeomAbs_Torus);
1932   //
1933   isAna2 = (BAS2.GetType() == GeomAbs_Plane ||
1934             BAS2.GetType() == GeomAbs_Cylinder ||
1935             BAS2.GetType() == GeomAbs_Cone ||
1936             BAS2.GetType() == GeomAbs_Sphere ||
1937             BAS2.GetType() == GeomAbs_Torus);
1938   //
1939   aTolFF = (isAna1 && isAna2) ? aTolFF : Max(aTolFF, 5.e-6);
1940 }
1941
1942
1943 // DEB f
1944   /*
1945   {
1946     BOPDS_DataMapIteratorOfDataMapOfShapeCoupleOfPaveBlocks aItx;
1947     TopoDS_Compound aCx;
1948     //
1949     BRep_Builder aBBx;
1950     aBBx.MakeCompound(aCx);
1951     //
1952     aItx.Initialize(theMSCPB);
1953     for (; aItx.More(); aItx.Next()) {
1954       const TopoDS_Shape& aSx=aItx.Key();
1955       aBBx.Add(aCx, aSx);
1956     }
1957     int a=0;
1958     BRepTools::Write(aCx, "cx");
1959   }
1960   */
1961   // DEB t