0023024: Update headers of OCCT files
[occt.git] / src / BOPTools / BOPTools_PaveFiller_3.cxx
1 // Created on: 2001-03-13
2 // Created by: Peter KURNEV
3 // Copyright (c) 2001-2012 OPEN CASCADE SAS
4 //
5 // The content of this file is subject to the Open CASCADE Technology Public
6 // License Version 6.5 (the "License"). You may not use the content of this file
7 // except in compliance with the License. Please obtain a copy of the License
8 // at http://www.opencascade.org and read it completely before using this file.
9 //
10 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
11 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
12 //
13 // The Original Code and all software distributed under the License is
14 // distributed on an "AS IS" basis, without warranty of any kind, and the
15 // Initial Developer hereby disclaims all such warranties, including without
16 // limitation, any warranties of merchantability, fitness for a particular
17 // purpose or non-infringement. Please see the License for the specific terms
18 // and conditions governing the rights and limitations under the License.
19
20
21
22 #include <BOPTools_PaveFiller.ixx>
23
24 #include <Geom_Curve.hxx>
25
26 #include <gp_Pnt.hxx>
27 #include <TColStd_SequenceOfInteger.hxx>
28 #include <TColStd_SequenceOfReal.hxx>
29
30 #include <TColStd_MapOfInteger.hxx>
31 #include <TColStd_ListOfInteger.hxx>
32 #include <TColStd_IndexedMapOfInteger.hxx>
33 #include <TColStd_ListIteratorOfListOfInteger.hxx>
34 #include <TColStd_MapIteratorOfMapOfInteger.hxx>
35
36 #include <TopoDS.hxx>
37 #include <TopoDS_Face.hxx>
38 #include <TopoDS_Edge.hxx>
39 #include <TopoDS_Vertex.hxx>
40
41 #include <BRep_Tool.hxx>
42 #include <BRep_Builder.hxx>
43
44 #include <BooleanOperations_ShapesDataStructure.hxx>
45 #include <BooleanOperations_OnceExplorer.hxx>
46 #include <BooleanOperations_AncestorsSeqAndSuccessorsSeq.hxx>
47
48 #include <IntTools_FaceFace.hxx>
49 #include <IntTools_SequenceOfCurves.hxx>
50 #include <IntTools_Curve.hxx>
51 #include <IntTools_Tools.hxx>
52 #include <IntTools_SequenceOfPntOn2Faces.hxx>
53 #include <IntTools_PntOn2Faces.hxx>
54 #include <IntTools_PntOnFace.hxx>
55
56 #include <BOPTools_IteratorOfCoupleOfShape.hxx>
57 #include <BOPTools_CArray1OfSSInterference.hxx>
58 #include <BOPTools_SSInterference.hxx>
59 #include <BOPTools_ListOfPaveBlock.hxx>
60 #include <BOPTools_PaveBlock.hxx>
61 #include <BOPTools_Pave.hxx>
62 #include <BOPTools_ListIteratorOfListOfPaveBlock.hxx>
63 #include <BOPTools_ListIteratorOfListOfPave.hxx>
64 #include <BOPTools_PaveBlockIterator.hxx>
65 #include <BOPTools_Tools.hxx>
66 #include <BOPTools_SequenceOfCurves.hxx>
67 #include <BOPTools_Curve.hxx>
68 #include <BOPTools_ListOfPave.hxx>
69 #include <BOPTools_PaveSet.hxx>
70 #include <BOPTools_CommonBlock.hxx>
71 #include <BOPTools_ListIteratorOfListOfCommonBlock.hxx>
72 #include <BOPTools_ListOfCommonBlock.hxx>
73
74 #include <BOPTools_InterferencePool.hxx>
75 #include <BOPTools_ListIteratorOfListOfInterference.hxx>
76 #include <BOPTools_InterferenceLine.hxx>
77 #include <BOPTools_ListOfInterference.hxx>
78 #include <BOPTools_Interference.hxx>
79 #include <BOPTools_CArray1OfInterferenceLine.hxx>
80
81 #include <Precision.hxx>
82 #include <BOPTColStd_IndexedDataMapOfIntegerIndexedMapOfInteger.hxx>
83
84 #include <TopExp_Explorer.hxx>
85 #include <Geom2d_Curve.hxx>
86 #include <Geom2dAPI_InterCurveCurve.hxx>
87 #include <IntRes2d_IntersectionPoint.hxx>
88 #include <BOPTools_ESInterference.hxx>
89 #include <BOPTools_VSInterference.hxx>
90 #include <BOPTools_VEInterference.hxx>
91 #include <BOPTools_VVInterference.hxx>
92 #include <BRepAdaptor_Surface.hxx>
93 #include <TopTools_ListOfShape.hxx>
94 #include <TopTools_ListIteratorOfListOfShape.hxx>
95
96 #include <BOPTools_EEInterference.hxx>
97 #include <IntTools_CommonPrt.hxx>
98 #include <BOPTools_ESInterference.hxx>
99 #include <BOPTools_ShapeShapeInterference.hxx>
100
101 #include <IntSurf_ListOfPntOn2S.hxx>
102
103 #include <GeomAPI_ProjectPointOnSurf.hxx>
104 #include <IntSurf_PntOn2S.hxx>
105 #include <TopTools_MapOfShape.hxx>
106
107
108 static
109   Standard_Boolean IsPaveBlock(const Standard_Integer nV1,
110                                const Standard_Integer nV2, 
111                                const BOPTools_ListOfPaveBlock& aLPBExisting);
112 static
113   Standard_Boolean IsFound(const TColStd_IndexedMapOfInteger& aMapWhat,
114                            const TColStd_IndexedMapOfInteger& aMapWith);
115 static
116   void FMapWith(const Standard_Integer nF,
117                 BOPTools_InterferencePool* myIntrPool,
118                 TColStd_IndexedMapOfInteger& aMapWith);
119 static
120   void FMapWhat(const Standard_Integer nF,
121                 BOPTools_InterferencePool* myIntrPool,
122                 TColStd_IndexedMapOfInteger& aMapWhat);
123
124 //wkar OCC334 f
125 static
126   void UnUsedMap(BOPTools_SequenceOfCurves& aSCvs,
127                  const BOPTools_PaveSet& aPSF,
128                  TColStd_IndexedMapOfInteger& aMapUnUsed);
129 static
130   Standard_Boolean VertexRangeTolerance(const Standard_Integer nV,
131                                         const Standard_Integer nF1,
132                                         const Standard_Integer nF2,
133                                         const BOPTools_InterferencePool& anIntrPool,
134                                         Standard_Real& aTolV);
135 static 
136   void FaceAndEdgeMap(const Standard_Integer nF,
137                       const BOPTools_InterferencePool& anIntrPool,
138                       TColStd_IndexedMapOfInteger& aMEF);
139 static
140   void ProcessAloneStickVertices(const Standard_Integer nF1,
141                                  const Standard_Integer nF2,
142                                  const BOPTools_PaveSet& aPSF,
143                                  BOPTools_SequenceOfCurves& aSCvs,
144                                  const BOPTools_InterferencePool& anIntrPool,
145                                  BOPTools_PaveFiller& aPF,
146                                  TColStd_SequenceOfInteger& aSeqVx,
147                                  TColStd_SequenceOfReal& aSeqTolVx);
148 static
149   void ProcessAloneStickVertices(const Standard_Integer nF1,
150                                  const Standard_Integer nF2,
151                                  const BOPTools_PaveSet& aPSF,
152                                  BOPTools_SequenceOfCurves& aSCvs,
153                                  BOPTools_PaveFiller& aPF,
154                                  TColStd_SequenceOfInteger& aSeqVx,
155                                  TColStd_SequenceOfReal& aSeqTolVx);
156 //wkar OCC334 t
157
158 static
159   Standard_Boolean IsPairFound(const Standard_Integer nF1,
160                                const Standard_Integer nF2,
161                                BOPTools_InterferencePool* myIntrPool,
162                                BOPTColStd_IndexedDataMapOfIntegerIndexedMapOfInteger& aMapWhat,
163                                BOPTColStd_IndexedDataMapOfIntegerIndexedMapOfInteger& aMapWith);
164
165 static Standard_Boolean CheckNewVertexAndUpdateData(const TopoDS_Vertex&              theVertex,
166                                                     const Standard_Real               theParamOnE,
167                                                     const TopoDS_Edge&                theEdge,
168                                                     const Standard_Real               theParamOnCurve,
169                                                     const Standard_Integer            theIndexF1,
170                                                     const Standard_Integer            theIndexF2,
171                                                     const Standard_Real               theTolerance,
172                                                     const BOPTools_PInterferencePool& theIntrPool,
173                                                     const BooleanOperations_PShapesDataStructure& theDS,
174                                                     const Handle(IntTools_Context)&   theContext,
175                                                     const BOPTools_PaveSet&           theEdgePaveSet,
176                                                     const Standard_Boolean            bAddNewVertex,
177                                                     const Standard_Boolean            bAddOldVertex,
178                                                     BOPTools_Curve&                   theBC,
179                                                     BOPTools_Pave&                    thePaveToPut,
180                                                     Standard_Boolean&                 bAddNewVertexOut,
181                                                     Standard_Boolean&                 bAddOldVertexOut);
182
183 static void AddInterfForAdjacentFace(const Standard_Integer            theEdgeIndex,
184                                      const Standard_Integer            theIndexF1,
185                                      const Standard_Integer            theIndexF2,
186                                      BOPTools_PInterferencePool        theIntrPool,
187                                      const BooleanOperations_PShapesDataStructure& theDS);
188
189 static Standard_Boolean RejectPaveBlock(const IntTools_Curve& theC,
190                                         const Standard_Real   theT1,
191                                         const Standard_Real   theT2,
192                                         const TopoDS_Vertex&  theV,
193                                         Standard_Real&        theRT);
194
195 static Standard_Boolean ModifFFTol(const TopoDS_Face& theF1,
196                                    const TopoDS_Face& theF2,
197                                    Standard_Real&     theTF);
198
199 static Standard_Integer RejectBuildingEdge(const IntTools_Curve& theC,
200                                            const TopoDS_Vertex&  theV1,
201                                            const TopoDS_Vertex&  theV2,
202                                            const Standard_Real   theT1,
203                                            const Standard_Real   theT2,
204                                            const TopTools_ListOfShape& theL,
205                                            Standard_Real&        theTF);
206
207 static
208   void CorrectTolR3D(BOPTools_PaveFiller& aPF,
209                      const BOPTools_SSInterference& aFF,
210                      const TColStd_MapOfInteger& aMVStick,
211                      Standard_Real& aTolR3D);
212
213 //=======================================================================
214 // function: PerformFF
215 // purpose: 
216 //=======================================================================
217   void BOPTools_PaveFiller::PerformFF() 
218 {
219   myIsDone=Standard_False;
220   Standard_Boolean bIsFound, bToSplit;
221   Standard_Integer n1, n2, anIndexIn=0, nF1, nF2, aNbFFs, aBlockLength;
222   BOPTColStd_IndexedDataMapOfIntegerIndexedMapOfInteger aMapWhat, aMapWith;
223   //
224   BOPTools_CArray1OfSSInterference& aFFs=myIntrPool->SSInterferences();
225   //
226   //  F/F Interferences  [BooleanOperations_SurfaceSurface]
227   myDSIt.Initialize(TopAbs_FACE, TopAbs_FACE);
228   //
229   // BlockLength correction
230   aNbFFs=ExpectedPoolLength();
231   aBlockLength=aFFs.BlockLength();
232   if (aNbFFs > aBlockLength) {
233     aFFs.SetBlockLength(aNbFFs);
234   }
235   // 
236   bToSplit=Standard_False;
237
238   for (; myDSIt.More(); myDSIt.Next()) {
239     Standard_Boolean justaddinterference = Standard_True;
240     myDSIt.Current(n1, n2, justaddinterference);
241
242     if(justaddinterference) {
243       if (!myIntrPool->IsComputed(n1, n2)) {
244
245         if(n1 < n2) {
246           nF1 = n1;
247           nF2 = n2;
248         }
249         else {
250           nF1 = n2;
251           nF2 = n1;
252         }
253         //
254         bIsFound=IsPairFound(nF1, nF2, myIntrPool, aMapWhat, aMapWith);
255         //
256         if (!bIsFound) {
257           myIntrPool->AddInterference (nF1, nF2, BooleanOperations_SurfaceSurface, anIndexIn); 
258         }
259         else {
260           IntTools_SequenceOfPntOn2Faces aPnts;
261           IntTools_SequenceOfCurves aCvs;
262
263           BOPTools_SSInterference anInterf (nF1, nF2, 1.e-07, 1.e-07, aCvs, aPnts);
264           anIndexIn=aFFs.Append(anInterf);
265           myIntrPool->AddInterference (nF1, nF2, BooleanOperations_SurfaceSurface, anIndexIn); 
266         }
267       }
268       continue;
269     }
270     //
271     if (myIntrPool->IsComputed(n1, n2)) {
272       continue;
273     }
274     //
275     nF1=n1; 
276     nF2=n2; 
277     if (nF1 > nF2) {
278       Standard_Integer iTmp;
279       iTmp=nF1;
280       nF1=nF2;
281       nF2=iTmp;
282     }
283     //
284     TopoDS_Face aF1=TopoDS::Face(myDS->GetShape(nF1));
285     TopoDS_Face aF2=TopoDS::Face(myDS->GetShape(nF2));
286     //
287     IntSurf_ListOfPntOn2S aListOfPnts;
288     GeomAPI_ProjectPointOnSurf& aProj1 = myContext->ProjPS(aF1);
289     GeomAPI_ProjectPointOnSurf& aProj2 = myContext->ProjPS(aF2);
290
291     BOPTools_CArray1OfESInterference& aEFs=myIntrPool->ESInterferences();
292     TColStd_MapOfInteger aMapEdgeIndex1, aMapEdgeIndex2;
293     for(Standard_Integer fIt = 0; fIt < 2; fIt++) {
294       Standard_Integer nF = (fIt == 0) ? nF1 : nF2;
295       for(Standard_Integer sIt1 = 1; sIt1 <= myDS->NumberOfSuccessors(nF); sIt1++) {
296         Standard_Integer nIndexS1 = myDS->GetSuccessor(nF, sIt1);
297         if(myDS->GetShapeType(nIndexS1) == TopAbs_EDGE) {
298           if(fIt == 0)
299             aMapEdgeIndex1.Add(nIndexS1);
300           else
301             aMapEdgeIndex2.Add(nIndexS1);
302         }
303         else {
304           for(Standard_Integer sIt2 = 1; sIt2 <= myDS->NumberOfSuccessors(nIndexS1); sIt2++) {
305             Standard_Integer nIndexS2 = myDS->GetSuccessor(nIndexS1, sIt2);
306             
307             if(myDS->GetShapeType(nIndexS2) == TopAbs_EDGE) {
308               if(fIt == 0)
309                 aMapEdgeIndex1.Add(nIndexS2);
310               else
311                 aMapEdgeIndex2.Add(nIndexS2);
312             }
313           }
314         }
315       }
316       
317       TColStd_MapIteratorOfMapOfInteger anIt;
318       if(fIt == 0)
319         anIt.Initialize(aMapEdgeIndex1);
320       else
321         anIt.Initialize(aMapEdgeIndex2);
322
323       Standard_Integer nFOpposite = (fIt == 0) ? nF2 : nF1;      
324
325       for(; anIt.More(); anIt.Next()) {
326         Standard_Integer nIndexE = anIt.Key();
327
328         for(Standard_Integer interIt = 1; interIt <= aEFs.Length(); interIt++) {
329           const BOPTools_ESInterference& aEF = aEFs(interIt);          
330
331           if((aEF.Index1() == nIndexE) && (nFOpposite == aEF.Index2())) {
332             IntTools_CommonPrt aCP = aEF.CommonPrt();
333
334             if(aCP.Type() == TopAbs_VERTEX) {
335               Standard_Real aPar = aCP.VertexParameter1();
336               // compute points and add to the list
337               Standard_Real f,l;
338               Handle(Geom_Curve) aCurve = BRep_Tool::Curve(TopoDS::Edge(myDS->GetShape(nIndexE)), f,l);
339               Handle(Geom2d_Curve) aPCurve;
340               if(fIt == 0) {
341                 aPCurve = BRep_Tool::CurveOnSurface(TopoDS::Edge(myDS->GetShape(nIndexE)),
342                                                     aF1, f, l);
343               }
344               else {
345                 aPCurve = BRep_Tool::CurveOnSurface(TopoDS::Edge(myDS->GetShape(nIndexE)),
346                                                     aF2, f, l);
347               }         
348                                                                        
349               gp_Pnt aPoint;
350               aCurve->D0(aPar, aPoint);
351               Standard_Real U1,V1,U2,V2;
352               IntSurf_PntOn2S aPnt;
353               if(!aPCurve.IsNull()) {
354                 gp_Pnt2d aP2d = aPCurve->Value(aPar);
355                 if(fIt == 0) {
356                   aProj2.Perform(aPoint);
357                   if(aProj2.IsDone()) {
358                     aProj2.LowerDistanceParameters(U2,V2);
359                     aPnt.SetValue(aP2d.X(),aP2d.Y(),U2,V2);
360                     aListOfPnts.Append(aPnt); 
361                   }
362                 }
363                 else {
364                   aProj1.Perform(aPoint);
365                   if(aProj1.IsDone()) {
366                     aProj1.LowerDistanceParameters(U1,V1);
367                     aPnt.SetValue(U1,V1,aP2d.X(),aP2d.Y());
368                     aListOfPnts.Append(aPnt); 
369                   }
370                 }
371               }              
372               else {
373                 aProj1.Perform(aPoint);
374                 aProj2.Perform(aPoint);
375                 if(aProj1.IsDone() && aProj2.IsDone()){
376                   aProj1.LowerDistanceParameters(U1,V1);
377                   aProj2.LowerDistanceParameters(U2,V2);
378                   aPnt.SetValue(U1,V1,U2,V2);
379                   aListOfPnts.Append(aPnt);                
380                 }
381               }
382             }
383           }
384         }
385       }
386     }
387     //
388     // FF
389     Standard_Boolean bToApproxC3d, bToApproxC2dOnS1, bToApproxC2dOnS2, bIsDone;
390     Standard_Real anApproxTol, aTolR3D, aTolR2D;
391     //
392     bToApproxC3d     = mySectionAttribute.Approximation();
393     bToApproxC2dOnS1 = mySectionAttribute.PCurveOnS1();
394     bToApproxC2dOnS2 = mySectionAttribute.PCurveOnS2();
395     //
396     anApproxTol=1.e-7;
397
398     IntTools_FaceFace aFF;
399     //
400     aFF.SetContext(myContext);
401     //
402     aFF.SetParameters (bToApproxC3d, 
403                        bToApproxC2dOnS1, 
404                        bToApproxC2dOnS2,
405                        anApproxTol);
406     //
407     if (!aListOfPnts.IsEmpty()) {
408       aFF.SetList(aListOfPnts);
409     }
410     //
411     aFF.Perform(aF1, aF2);
412     //
413     bIsDone=aFF.IsDone();
414     if (bIsDone) {
415       // Add Interference to the Pool
416       aTolR3D=aFF.TolReached3d();
417       aTolR2D=aFF.TolReached2d();
418       if (aTolR3D < 1.e-7){
419         aTolR3D=1.e-7;
420       } 
421       aFF.PrepareLines3D(bToSplit);
422       //
423       anIndexIn=0;
424       Standard_Integer aNbCurves, aNbPoints;
425
426       const IntTools_SequenceOfCurves& aCvs=aFF.Lines();
427       aNbCurves=aCvs.Length();
428       //
429       const IntTools_SequenceOfPntOn2Faces& aPnts=aFF.Points();
430       aNbPoints=aPnts.Length();
431       
432       if (!aNbCurves && !aNbPoints) {
433         //
434         bIsFound=IsPairFound(nF1, nF2, myIntrPool, aMapWhat, aMapWith);
435         //
436         if (!bIsFound) {
437           myIntrPool->AddInterference (nF1, nF2, BooleanOperations_SurfaceSurface, anIndexIn); 
438           continue;
439         }
440       }
441       //
442       BOPTools_SSInterference anInterf (nF1, nF2, aTolR3D, aTolR2D, aCvs, aPnts);
443       anIndexIn=aFFs.Append(anInterf);
444       
445       myIntrPool->AddInterference (nF1, nF2, BooleanOperations_SurfaceSurface, anIndexIn);
446     } //if (bIsDone)
447     //
448     else {
449       anIndexIn=0;
450       //
451       bIsFound=IsPairFound(nF1, nF2, myIntrPool, aMapWhat, aMapWith);
452       //
453       if (!bIsFound) {
454         myIntrPool->AddInterference (nF1, nF2, BooleanOperations_SurfaceSurface, anIndexIn); 
455       }
456       else {
457         IntTools_SequenceOfPntOn2Faces aPnts;
458         IntTools_SequenceOfCurves aCvs;
459         
460         BOPTools_SSInterference anInterf (nF1, nF2, 1.e-07, 1.e-07, aCvs, aPnts);
461         anIndexIn=aFFs.Append(anInterf);
462         myIntrPool->AddInterference (nF1, nF2, BooleanOperations_SurfaceSurface, anIndexIn);
463       }
464     }
465   }// for (; myDSIt.More(); myDSIt.Next()) 
466   myIsDone=Standard_True;
467 }
468 //=======================================================================
469 // function: MakeBlocks
470 // purpose: 
471 //=======================================================================
472   void BOPTools_PaveFiller::MakeBlocks()
473 {
474   Standard_Integer i, j, aNbCurves, aNbFFs, nF1, nF2, aBid=0, nV1, nV2;
475   Standard_Real aTolR3D, aT1, aT2;
476   Standard_Boolean bValid, bCoincide;
477
478   BOPTools_CArray1OfSSInterference& aFFs=myIntrPool->SSInterferences();
479   
480   aNbFFs=aFFs.Extent();
481
482   for (i=1; i<=aNbFFs; i++) {
483     BOPTools_SSInterference& aFFi=aFFs(i);
484     //  
485     nF1=aFFi.Index1();
486     nF2=aFFi.Index2();
487     //
488     // Curves' tolerance
489     aTolR3D=aFFi.TolR3D();
490     //
491     // Faces
492     const TopoDS_Face& aF1=TopoDS::Face(myDS->GetShape(nF1));
493     const TopoDS_Face& aF2=TopoDS::Face(myDS->GetShape(nF2));
494
495     TColStd_MapOfInteger aMap;
496     BOPTools_ListOfPaveBlock aLPB;
497     SplitsInFace (aBid, nF1, nF2, aLPB);
498     SplitsInFace (aBid, nF2, nF1, aLPB);
499     SplitsOnFace (aBid, nF1, nF2, aLPB);
500     
501     BOPTools_ListIteratorOfListOfPaveBlock anIt(aLPB);
502     for (; anIt.More(); anIt.Next()) {
503       const BOPTools_PaveBlock& aPB=anIt.Value();
504       aFFi.AppendBlock(aPB);
505       nV1=aPB.Pave1().Index();
506       nV2=aPB.Pave2().Index();
507       aMap.Add(nV1);
508       aMap.Add(nV2);
509     }
510     // Put existing paves on curves
511     //     BOPTools_PaveSet aPSF;
512     //     PrepareSetForFace (nF1, nF2, aPSF);
513
514     BOPTools_SequenceOfCurves& aSCvs = aFFi.Curves();
515     aNbCurves=aSCvs.Length();
516
517     // 
518     // Pave Blocks On Curves
519     // 
520     Standard_Boolean bIsPaveBlock;
521     Standard_Integer iCheckIntermediatePoint;
522     // 
523     for (j=1; j<=aNbCurves; j++) {
524       BOPTools_Curve& aBC=aSCvs(j);
525       const IntTools_Curve& aC= aBC.Curve();
526       
527       BOPTools_PaveSet& aPaveSet=aBC.Set();
528       BOPTools_PaveBlockIterator aPBIter(0, aPaveSet);
529       for (; aPBIter.More(); aPBIter.Next()) {
530         BOPTools_PaveBlock& aPBNew=aPBIter.Value();
531         aPBNew.SetCurve(aC);
532         aPBNew.SetFace1(nF1);
533         aPBNew.SetFace2(nF2);
534         //
535         nV1=aPBNew.Pave1().Index();
536         nV2=aPBNew.Pave2().Index();
537         
538         if (aMap.Contains(nV1) && aMap.Contains(nV2)) {
539           //
540           const BOPTools_ListOfPaveBlock& aLPBExisting=aFFi.PaveBlocks();
541           bIsPaveBlock=IsPaveBlock(nV1, nV2, aLPBExisting);
542           //
543           iCheckIntermediatePoint=1;
544           if (bIsPaveBlock) {
545             BOPTools_ListIteratorOfListOfPaveBlock anItLPB(aLPBExisting);
546             
547             for (; anItLPB.More(); anItLPB.Next()) {
548               const BOPTools_PaveBlock& aPBR=anItLPB.Value();
549               iCheckIntermediatePoint=
550                 CheckIntermediatePoint(aPBNew, aPBR, aTolR3D);
551               if (!iCheckIntermediatePoint) {
552                 break;
553               }
554             }
555             bIsPaveBlock=bIsPaveBlock && !iCheckIntermediatePoint;
556           }
557           //
558           if (bIsPaveBlock) {
559             continue;
560           }
561         }
562         //
563         else {
564           iCheckIntermediatePoint=0;
565         } 
566         //
567         aT1=aPBNew.Pave1().Param();
568         aT2=aPBNew.Pave2().Param();
569         // 
570         if((nV1 == nV2) && (Abs(aT2 - aT1) < Precision::PConfusion())) {
571             continue;
572         }
573         // 
574         // Checking of validity in 2D
575         //
576         Standard_Real aTolerance = (aTolR3D < 1.e-3) ? 1.e-3 : aTolR3D;
577         bValid=myContext->IsValidBlockForFaces(aT1, aT2, aC, aF1, aF2, aTolerance);
578         //
579         if (!bValid) {
580           continue;
581         }
582         //
583         // Checking the  paveblocks for coinsidence with aLPB
584         bCoincide=CheckCoincidence (aPBNew, aFFi);
585         //
586         bCoincide=bCoincide && !iCheckIntermediatePoint;
587         //
588         if (bCoincide) {
589           continue;
590         }
591         //
592         // reject pave block (FF) v1==v2 for too small sect. edge
593         TopoDS_Vertex aV1=TopoDS::Vertex(myDS->GetShape(nV1));
594         TopoDS_Vertex aV2=TopoDS::Vertex(myDS->GetShape(nV2));
595         Standard_Boolean rejectPaveBlock = Standard_False;
596         if(aV1.IsSame(aV2)) {
597           Standard_Real aRT = 1.e-7;
598           rejectPaveBlock = RejectPaveBlock(aC,aT1,aT2,aV1,aRT);
599           if(rejectPaveBlock) {
600             if(aRT > 1.e-7) {
601               BRep_Builder BB;
602               BB.UpdateVertex( aV1, 2*aRT );
603             }
604             continue;
605           }
606         }
607         //
608         aBC.AppendNewBlock(aPBNew);
609       }
610     } // end of for (j=1; j<=aNbCurves; j++)
611   }// end of for (i=1; i<=aNbFFs; i++)
612 }
613 //=======================================================================
614 // function: MakeAloneVertices
615 // purpose: 
616 //=======================================================================
617   void BOPTools_PaveFiller::MakeAloneVertices()
618 {
619   Standard_Integer i, j, k, aNbFFs, aNbCurves, nF1, nF2, nV, aNbAlone, aNbV;
620   Standard_Boolean bFlag=Standard_False;
621
622   BOPTools_ListIteratorOfListOfPave anIt;
623   TColStd_IndexedMapOfInteger aMap;
624   BOPTools_CArray1OfSSInterference& aFFs=myIntrPool->SSInterferences();
625   
626   aNbFFs=aFFs.Extent();
627   for (i=1; i<=aNbFFs; i++) {
628     BOPTools_SSInterference& aFFi=aFFs(i);
629
630     const IntTools_SequenceOfPntOn2Faces& aSeqAlonePnts=aFFi.AlonePnts();
631     aNbAlone=aSeqAlonePnts.Length();
632     
633     if (!aNbAlone) {
634       continue;
635     }
636
637     nF1=aFFi.Index1();
638     nF2=aFFi.Index2();
639     //
640     TopoDS_Face aF1=TopoDS::Face(myDS->Shape(nF1));
641     TopoDS_Face aF2=TopoDS::Face(myDS->Shape(nF2));
642     // 
643     // 1. fill aMap where all indices for (F/F) vertices are
644     aMap.Clear();
645     
646     BOPTools_PaveSet aPSF;
647     
648     PrepareSetForFace (nF1, nF2, aPSF);
649     const BOPTools_ListOfPave& aLPaves=aPSF.Set();
650     anIt.Initialize(aLPaves);
651     for (; anIt.More(); anIt.Next()) {
652       const BOPTools_Pave& aPave=anIt.Value();
653       nV=aPave.Index();
654       aMap.Add(nV);
655     }
656
657     BOPTools_SequenceOfCurves& aSCvs=aFFi.Curves();
658     aNbCurves=aSCvs.Length();
659     for (j=1; j<=aNbCurves; j++) {
660       BOPTools_Curve& aBC=aSCvs(j);
661       const BOPTools_PaveSet& aCPSF=aBC.Set();
662       const BOPTools_ListOfPave& aLPs=aCPSF.Set();
663       anIt.Initialize(aLPs);
664       for (; anIt.More(); anIt.Next()) {
665         const BOPTools_Pave& aPv=anIt.Value();
666         nV=aPv.Index();
667         aMap.Add(nV);
668       }
669     }
670     //
671     // 2. check alone points on closure with aMap's vertices
672     Standard_Integer iVV;
673     Standard_Real aTolVAlone, aTolF1, aTolF2;
674     TopoDS_Vertex aVAlone;
675     BRep_Builder aBB;
676     
677     aTolF1=BRep_Tool::Tolerance(aF1);
678     aTolF2=BRep_Tool::Tolerance(aF2);
679     aTolVAlone=aTolF1+aTolF2;
680
681     aNbV=aMap.Extent();
682     for (j=1; j<=aNbAlone; ++j) {
683       const IntTools_PntOn2Faces& aP2F=aSeqAlonePnts(j);
684       const IntTools_PntOnFace& aPF1=aP2F.P1();
685       const gp_Pnt& aPAlone=aPF1.Pnt();
686       aBB.MakeVertex(aVAlone, aPAlone, aTolVAlone);
687       //
688       bFlag=Standard_True;
689       //
690       for (k=1; k<=aNbV; ++k) {
691         nV=aMap(k);
692         const TopoDS_Vertex& aV=TopoDS::Vertex(myDS->Shape(nV));
693         
694         iVV= IntTools_Tools::ComputeVV (aVAlone, aV);
695         if (!iVV) {
696           // It means that aVAlone and aV coinsided so 
697           // we do not need to insert aVAlone into the DS
698           bFlag=Standard_False;
699           break;
700         }
701         
702       }
703       if (bFlag) {
704         Standard_Boolean bVF;
705         Standard_Integer aNewShape;
706         //
707         bVF=myContext->IsValidPointForFaces (aPAlone, aF1, aF2, 1.e-3);
708         //
709         if (bVF) {
710           BooleanOperations_AncestorsSeqAndSuccessorsSeq anASSeq;
711           myDS->InsertShapeAndAncestorsSuccessors(aVAlone, anASSeq);
712           aNewShape=myDS->NumberOfInsertedShapes();
713           myDS->SetState (aNewShape, BooleanOperations_ON);
714           //
715           TColStd_ListOfInteger& anAloneVertices=aFFi.AloneVertices();
716           anAloneVertices.Append(aNewShape);
717         }
718       }
719     }
720     
721   }
722 }
723 //=======================================================================
724 // function: CheckCoincidence
725 // purpose: 
726 //=======================================================================
727   Standard_Boolean BOPTools_PaveFiller::CheckCoincidence(const BOPTools_PaveBlock& aPB,
728                                                          const BOPTools_SSInterference& aFFi)
729                                                          
730 {
731   Standard_Real aTolC, aTE, aT11, aT12;
732   Standard_Integer nV11, nV12, nV21, nV22, iVV, iVE, nE2, iCount=0, iCountExt=1;
733   Standard_Integer iV;
734
735   aTolC=aFFi.TolR3D();
736   // V11
737   const BOPTools_Pave& aPave11=aPB.Pave1();
738   nV11=aPave11.Index();
739   const TopoDS_Vertex& aV11=TopoDS::Vertex(myDS->GetShape(nV11));
740   aT11=aPave11.Param();
741   // V12
742   const BOPTools_Pave& aPave12=aPB.Pave2();
743   nV12=aPave12.Index();
744   const TopoDS_Vertex& aV12=TopoDS::Vertex(myDS->GetShape(nV12));
745   aT12=aPave12.Param();
746   //
747   const BOPTools_ListOfPaveBlock& aLPB=aFFi.PaveBlocks();
748   BOPTools_ListIteratorOfListOfPaveBlock anIt(aLPB);
749   for (; anIt.More(); anIt.Next()) {
750     
751     iCount=0;
752     
753     const BOPTools_PaveBlock& aPBR=anIt.Value();
754     // V21
755     const BOPTools_Pave& aPave21=aPBR.Pave1();
756     nV21=aPave21.Index();
757     const TopoDS_Vertex& aV21=TopoDS::Vertex(myDS->GetShape(nV21));
758     // V22
759     const BOPTools_Pave& aPave22=aPBR.Pave2();
760     nV22=aPave22.Index();
761     const TopoDS_Vertex& aV22=TopoDS::Vertex(myDS->GetShape(nV22));
762     // E2
763     nE2=aPBR.Edge();
764     const TopoDS_Edge& aE2=TopoDS::Edge(myDS->GetShape(nE2));
765     //
766     // VV
767     iV=0;
768     iVV=IntTools_Tools::ComputeVV (aV11, aV21);
769     if (!iVV) {
770       iCount++;
771       iV++;
772       if (iCount>iCountExt) {
773         break;
774       }
775     }
776     
777     iVV=IntTools_Tools::ComputeVV (aV11, aV22);
778     if (!iVV) {
779       iCount++;
780       iV++;
781       if (iCount>iCountExt) {
782         break;
783       }
784     }
785
786     // VE
787     if (!iV) {
788       iVE=myContext->ComputeVE (aV11, aE2, aTE);
789       if (!iVE) {
790         iCount++;
791         if (iCount>iCountExt) {
792           break;
793         }
794       }
795     }
796     //
797     // VV
798     iV=0;
799     iVV=IntTools_Tools::ComputeVV (aV12, aV21);
800     if (!iVV) {
801       iCount++;
802       iV++;
803       if (iCount>iCountExt) {
804         break;
805       }
806     }
807
808     iVV=IntTools_Tools::ComputeVV (aV12, aV22);
809     if (!iVV) {
810       iCount++;
811       iV++;
812       if (iCount>iCountExt) {
813         break;
814       }
815     }
816     // VE
817     if (!iV) {
818       //
819       iVE=myContext->ComputeVE (aV12, aE2, aTE);
820       //
821       if (!iVE) {
822         iCount++;
823         if (iCount>iCountExt) {
824           break;
825         }
826       }
827     }
828     
829   } // next aPBR
830   return (iCount>iCountExt);
831 }
832 //=======================================================================
833 // function: CheckIntermediatePoint
834 // purpose: 
835 //=======================================================================
836   Standard_Integer BOPTools_PaveFiller::CheckIntermediatePoint(const BOPTools_PaveBlock& aPB,
837                                                                const BOPTools_PaveBlock& aPBR,
838                                                                const Standard_Real aTolC)
839                                                          
840 {
841   Standard_Real aT11, aT12, aTM, aTmp;
842   Standard_Integer iVM, nE2;
843
844   gp_Pnt aPM;
845   BRep_Builder aBB;
846   TopoDS_Vertex aVM;
847   // 
848   // Vertex
849   const BOPTools_Pave& aPave11=aPB.Pave1();
850   aT11=aPave11.Param();
851   // 
852   const BOPTools_Pave& aPave12=aPB.Pave2();
853   aT12=aPave12.Param();
854   //
855   aTM=IntTools_Tools::IntermediatePoint (aT11, aT12);
856   //
857   const IntTools_Curve& aIC=aPB.Curve();
858   aIC.D0(aTM, aPM);
859   //
860   aBB.MakeVertex (aVM, aPM, aTolC);
861   //
862   //Edge
863   nE2=aPBR.Edge();
864   const TopoDS_Edge& aE2=TopoDS::Edge(myDS->GetShape(nE2));
865   // VE
866   iVM=myContext->ComputeVE(aVM, aE2, aTmp); 
867   //
868   return iVM;
869 }
870 //=======================================================================
871 // function: PutBoundPaveOnCurve
872 // purpose: 
873 //=======================================================================
874   void BOPTools_PaveFiller::PutBoundPaveOnCurve(BOPTools_Curve& aBC,
875                                                 BOPTools_SSInterference& aFFi)
876
877   Standard_Boolean bHasBounds, bVF;
878   
879
880   const IntTools_Curve& aIC=aBC.Curve();
881   bHasBounds=aIC.HasBounds ();
882   
883   if (!bHasBounds){
884     return;
885   }
886
887   Standard_Integer nF1, nF2;
888   Standard_Real aT1, aT2, aTolR3D;
889   gp_Pnt aP1, aP2;
890   //
891   // Bounds
892   aIC.Bounds (aT1, aT2, aP1, aP2);
893   //
894   // Faces
895   nF1=aFFi.Index1();
896   nF2=aFFi.Index2();
897   //
898   aTolR3D=aFFi.TolR3D();
899   //
900   TopoDS_Face aF1=TopoDS::Face(myDS->GetShape(nF1));
901   TopoDS_Face aF2=TopoDS::Face(myDS->GetShape(nF2));
902   //
903   bVF=myContext->IsValidPointForFaces (aP1, aF1, aF2, aTolR3D);
904   //
905   if (bVF) {
906     PutBoundPaveOnCurve (aP1, aT1, aBC, aFFi);
907   }
908   //
909   bVF=myContext->IsValidPointForFaces (aP2, aF1, aF2, aTolR3D);
910   //
911   if (bVF) {
912     PutBoundPaveOnCurve (aP2, aT2, aBC, aFFi);
913   }
914 }
915 //=======================================================================
916 // function: PutBoundPaveOnCurve
917 // purpose: 
918 //=======================================================================
919   void BOPTools_PaveFiller::PutBoundPaveOnCurve(const gp_Pnt& aP,
920                                                 const Standard_Real aT,
921                                                 BOPTools_Curve& aBC,
922                                                 BOPTools_SSInterference& aFFi)
923
924   Standard_Boolean bFound1, bFound2;
925   Standard_Integer nV;
926   Standard_Real aTolV=aFFi.TolR3D();
927
928   BOPTools_Pave aPave1, aPave2, aPave;
929   BOPTools_PaveSet& aCPS=aBC.Set();
930   BOPTools_PaveSet& aFFiPS=aFFi.NewPaveSet();
931   const IntTools_Curve& aIC=aBC.Curve();
932
933   bFound1=FindPave(aP, aTolV, aCPS  , aPave1);
934   bFound2=FindPave(aP, aTolV, aFFiPS, aPave2);
935   
936   if (!bFound1 && !bFound2) {
937     TopoDS_Vertex aNewVertex;
938     BOPTools_Tools::MakeNewVertex(aP, aTolV, aNewVertex);
939     //
940     BooleanOperations_AncestorsSeqAndSuccessorsSeq anASSeq;
941     myDS->InsertShapeAndAncestorsSuccessors(aNewVertex, anASSeq);
942     nV=myDS->NumberOfInsertedShapes();
943     aPave.SetIndex(nV);
944     aPave.SetParam(aT);
945
946     aCPS.Append(aPave);
947     aFFiPS.Append(aPave);
948     //
949     // Append Techno Vertex to the Curve
950     TColStd_ListOfInteger& aTVs=aBC.TechnoVertices();
951     aTVs.Append(nV);
952   }
953   
954   if (bFound1 && !bFound2) {
955     nV=aPave1.Index();
956     aPave.SetIndex(nV);
957     aPave.SetParam(aT);
958     aFFiPS.Append(aPave);
959     //
960     const TopoDS_Vertex& aV=TopoDS::Vertex(myDS->Shape(nV));
961     BOPTools_Tools::UpdateVertex (aIC, aT, aV);
962   }
963   
964   if (!bFound1 && bFound2) {
965     nV=aPave2.Index();
966     aPave.SetIndex(nV);
967     aPave.SetParam(aT);
968     aCPS.Append(aPave);
969     //
970     const TopoDS_Vertex& aV=TopoDS::Vertex(myDS->Shape(nV));
971     BOPTools_Tools::UpdateVertex (aIC, aT, aV);
972   }
973 }
974
975 //=======================================================================
976 // function: PutBoundPaveOnCurveSpec
977 // purpose: 
978 //=======================================================================
979   void BOPTools_PaveFiller::PutBoundPaveOnCurveSpec(BOPTools_Curve& aBC,
980                                                     BOPTools_SSInterference& aFFi)
981
982   Standard_Boolean bHasBounds, bVF;
983   
984
985   const IntTools_Curve& aIC=aBC.Curve();
986   bHasBounds=aIC.HasBounds ();
987   
988   if (!bHasBounds){
989     return;
990   }
991
992   Standard_Integer nF1, nF2;
993   Standard_Real aT1, aT2, aTolR3D;
994   gp_Pnt aP1, aP2;
995   //
996   // Bounds
997   aIC.Bounds (aT1, aT2, aP1, aP2);
998   //
999   // Faces
1000   nF1=aFFi.Index1();
1001   nF2=aFFi.Index2();
1002   //
1003   aTolR3D=aFFi.TolR3D();
1004   //
1005   TopoDS_Face aF1=TopoDS::Face(myDS->GetShape(nF1));
1006   TopoDS_Face aF2=TopoDS::Face(myDS->GetShape(nF2));
1007   //
1008   bVF=myContext->IsValidPointForFaces (aP1, aF1, aF2, aTolR3D);
1009   //
1010   if (bVF) {
1011     PutBoundPaveOnCurveSpec (aP1, aT1, aBC, aFFi);
1012   }
1013   //
1014   bVF=myContext->IsValidPointForFaces (aP2, aF1, aF2, aTolR3D);
1015   //
1016   if (bVF) {
1017     PutBoundPaveOnCurveSpec (aP2, aT2, aBC, aFFi);
1018   }
1019 }
1020 //=======================================================================
1021 // function: PutBoundPaveOnCurveSpec
1022 // purpose: 
1023 //=======================================================================
1024   void BOPTools_PaveFiller::PutBoundPaveOnCurveSpec(const gp_Pnt& aP,
1025                                                     const Standard_Real aT,
1026                                                     BOPTools_Curve& aBC,
1027                                                     BOPTools_SSInterference& aFFi)
1028
1029   Standard_Boolean bFound1, bFound2;
1030   Standard_Integer nV;
1031   Standard_Real aTolV=aFFi.TolR3D();
1032
1033   BOPTools_Pave aPave1, aPave2, aPave;
1034   BOPTools_PaveSet& aCPS=aBC.Set();
1035   BOPTools_PaveSet& aFFiPS=aFFi.NewPaveSet();
1036   const IntTools_Curve& aIC=aBC.Curve();
1037
1038   bFound1=FindPave(aP, aTolV, aCPS  , aPave1);
1039   bFound2=FindPave(aP, aTolV, aFFiPS, aPave2);
1040   
1041   if (!bFound1 && !bFound2) {
1042     TopoDS_Vertex aNewVertex;
1043     BOPTools_Tools::MakeNewVertex(aP, aTolV, aNewVertex);
1044     //
1045     BooleanOperations_AncestorsSeqAndSuccessorsSeq anASSeq;
1046     myDS->InsertShapeAndAncestorsSuccessors(aNewVertex, anASSeq);
1047     nV=myDS->NumberOfInsertedShapes();
1048     aPave.SetIndex(nV);
1049     aPave.SetParam(aT);
1050
1051     aCPS.Append(aPave);
1052     aFFiPS.Append(aPave);
1053     //
1054     // Append Techno Vertex to the Curve
1055     TColStd_ListOfInteger& aTVs=aBC.TechnoVertices();
1056     aTVs.Append(nV);
1057     //
1058     //To check, if face boundary must be split by new vertex
1059     TopTools_MapOfShape aMap;
1060     Standard_Real aPar;
1061     Standard_Integer anErrStat;
1062     Standard_Integer aWhat, aWith, anIndexIn;
1063     BOPTools_CArray1OfVEInterference& aVEs=myIntrPool->VEInterferences();
1064     // Faces
1065     Standard_Integer nF1=aFFi.Index1();
1066     const TopoDS_Shape aF1 = myDS->GetShape(nF1);
1067     //
1068     Standard_Integer nF2=aFFi.Index2();
1069     const TopoDS_Shape aF2 = myDS->GetShape(nF2);
1070     //
1071     //
1072     Standard_Integer aRank = myDS->Rank(nF1);
1073     TopExp_Explorer anExp(aF1, TopAbs_EDGE);
1074     for(; anExp.More(); anExp.Next()) {
1075
1076       const TopoDS_Shape& anE = anExp.Current();
1077       if (BRep_Tool::Degenerated(TopoDS::Edge(anE))){
1078         continue;
1079       }
1080
1081       if(!aMap.Add(anE)) continue;
1082
1083       anErrStat = 
1084         myContext->ComputeVE(aNewVertex, TopoDS::Edge(anE), aPar);
1085       if(anErrStat) continue;
1086       //
1087       Standard_Real aT1, aT2;
1088       gp_Pnt aP1, aP2;
1089       aIC.Bounds(aT1, aT2, aP1, aP2);
1090       //Check if any other point on curve belongs edge
1091       aT1 = 0.5*(aT1+aT2);
1092       aIC.D0(aT1, aP1);
1093       TopoDS_Vertex aNewVertex1;
1094       BOPTools_Tools::MakeNewVertex(aP1, aTolV, aNewVertex1);
1095       anErrStat = 
1096         myContext->ComputeVE(aNewVertex1, TopoDS::Edge(anE), aT1);
1097       if(!anErrStat) continue; //curve and edge seem to be coincide
1098       
1099       aWhat = nV;
1100       aWith = myDS->ShapeIndex(anE, aRank);
1101       BOPTools_VEInterference anInterf (aWhat, aWith, aPar);
1102       anIndexIn=aVEs.Append(anInterf);
1103       //
1104       // Add Pave to the Edge's myPavePool
1105       BOPTools_Pave aPave3(aWhat, aPar, BooleanOperations_VertexEdge);
1106       aPave3.SetInterference(anIndexIn);
1107       BOPTools_PaveSet& aPaveSet= myPavePool(myDS->RefEdge(aWith));
1108       aPaveSet.Append(aPave3);
1109
1110       //
1111       // State for the Vertex in DS;
1112       myDS->SetState (aWhat, BooleanOperations_ON);
1113       // Insert Vertex in Interference Object
1114       BOPTools_VEInterference& aVE=aVEs(anIndexIn);
1115       aVE.SetNewShape(aWhat);
1116
1117       PreparePaveBlocks(aWith);
1118       RecomputeCommonBlocks(aWith);
1119     }
1120     //
1121     aRank = myDS->Rank(nF2);
1122     anExp.Init(aF2, TopAbs_EDGE);
1123     for(; anExp.More(); anExp.Next()) {
1124       const TopoDS_Shape& anE = anExp.Current();
1125       if (BRep_Tool::Degenerated(TopoDS::Edge(anE))){
1126         continue;
1127       }
1128
1129       if(!aMap.Add(anE)) continue;
1130
1131       anErrStat = 
1132         myContext->ComputeVE(aNewVertex, TopoDS::Edge(anE), aPar);
1133       if(anErrStat) continue;
1134       //
1135       Standard_Real aT1, aT2;
1136       gp_Pnt aP1, aP2;
1137       aIC.Bounds(aT1, aT2, aP1, aP2);
1138       //Check if any other point on curve belongs edge
1139       aT1 = 0.5*(aT1+aT2);
1140       aIC.D0(aT1, aP1);
1141       TopoDS_Vertex aNewVertex1;
1142       BOPTools_Tools::MakeNewVertex(aP1, aTolV, aNewVertex1);
1143       anErrStat = 
1144         myContext->ComputeVE(aNewVertex1, TopoDS::Edge(anE), aT1);
1145       if(!anErrStat) continue; //curve and edge seem to be coincide
1146       
1147       aWhat = nV;
1148       aWith = myDS->ShapeIndex(anE, aRank);
1149       BOPTools_VEInterference anInterf (aWhat, aWith, aPar);
1150       anIndexIn=aVEs.Append(anInterf);
1151       //
1152       // Add Pave to the Edge's myPavePool
1153       BOPTools_Pave aPave3(aWhat, aPar, BooleanOperations_VertexEdge);
1154       aPave3.SetInterference(anIndexIn);
1155       BOPTools_PaveSet& aPaveSet= myPavePool(myDS->RefEdge(aWith));
1156       aPaveSet.Append(aPave3);
1157
1158       //
1159       // State for the Vertex in DS;
1160       myDS->SetState (aWhat, BooleanOperations_ON);
1161       // Insert Vertex in Interference Object
1162       BOPTools_VEInterference& aVE=aVEs(anIndexIn);
1163       aVE.SetNewShape(aWhat);
1164
1165       PreparePaveBlocks(aWith);
1166       RecomputeCommonBlocks(aWith);
1167     }
1168     //
1169   }
1170   
1171   if (bFound1 && !bFound2) {
1172     nV=aPave1.Index();
1173     aPave.SetIndex(nV);
1174     aPave.SetParam(aT);
1175     aFFiPS.Append(aPave);
1176     //
1177     const TopoDS_Vertex& aV=TopoDS::Vertex(myDS->Shape(nV));
1178     BOPTools_Tools::UpdateVertex (aIC, aT, aV);
1179   }
1180   
1181   if (!bFound1 && bFound2) {
1182     nV=aPave2.Index();
1183     aPave.SetIndex(nV);
1184     aPave.SetParam(aT);
1185     aCPS.Append(aPave);
1186     //
1187     const TopoDS_Vertex& aV=TopoDS::Vertex(myDS->Shape(nV));
1188     BOPTools_Tools::UpdateVertex (aIC, aT, aV);
1189   }
1190 }
1191 //=======================================================================
1192 // function: FindPave
1193 // purpose: 
1194 //=======================================================================
1195   Standard_Boolean BOPTools_PaveFiller::FindPave(const gp_Pnt& aP,
1196                                                  const Standard_Real aTolPV, 
1197                                                  const BOPTools_PaveSet& aPS,
1198                                                  BOPTools_Pave& aPave)
1199 {
1200   Standard_Integer nV;
1201   Standard_Boolean bIsVertex=Standard_False;
1202  
1203   const BOPTools_ListOfPave& aLP=aPS.Set();
1204   BOPTools_ListIteratorOfListOfPave anIt(aLP);
1205   for (; anIt.More(); anIt.Next()) {
1206     const BOPTools_Pave& aPC=anIt.Value();
1207     nV=aPC.Index();
1208     const TopoDS_Vertex& aV=TopoDS::Vertex(myDS->GetShape(nV));
1209     bIsVertex=IntTools_Tools::IsVertex (aP, aTolPV, aV);
1210     if (bIsVertex) {
1211       aPave=aPC;
1212       return bIsVertex;
1213     }
1214   }
1215   return bIsVertex;
1216 }
1217 //=======================================================================
1218 // function: MakeSectionEdges
1219 // purpose: 
1220 //=======================================================================
1221   void BOPTools_PaveFiller::MakeSectionEdges()
1222 {
1223   Standard_Integer i, j, aNbCurves, aNbFFs, nF1, nF2, nV1, nV2, aNbPaveBlocks,
1224                    aNewShapeIndex ;
1225   Standard_Real    t1, t2;
1226   TopoDS_Edge aESect;
1227   TopoDS_Vertex aV1, aV2;
1228   BRep_Builder BB;
1229
1230   Standard_Integer pbi = 0;
1231
1232
1233   BOPTools_CArray1OfSSInterference& aFFs=myIntrPool->SSInterferences();
1234   
1235   aNbFFs=aFFs.Extent();
1236   for (i=1; i<=aNbFFs; i++) {
1237     BOPTools_SSInterference& aFFi=aFFs(i);
1238     nF1=aFFi.Index1();
1239     nF2=aFFi.Index2();
1240     //
1241     Standard_Real aTF = 1.e-7;
1242     TopoDS_Face aF1=TopoDS::Face(myDS->GetShape(nF1));
1243     TopoDS_Face aF2=TopoDS::Face(myDS->GetShape(nF2));
1244     Standard_Boolean isModT = ModifFFTol(aF1,aF2,aTF);
1245     Standard_Real aTolFF = (isModT) ? Max(aTF,aFFi.TolR3D()) : aFFi.TolR3D();
1246     BOPTools_ListOfPaveBlock aFFPBL;
1247     TopTools_ListOfShape aFFSEL;
1248     //
1249     BOPTools_SequenceOfCurves& aSCvs=aFFi.Curves();
1250     aNbCurves=aSCvs.Length();
1251     for (j=1; j<=aNbCurves; j++) {
1252       BOPTools_Curve& aBC=aSCvs(j);
1253       const IntTools_Curve& aIC=aBC.Curve();
1254       //
1255       const BOPTools_ListOfPaveBlock& aSectEdges=aBC.NewPaveBlocks();
1256       aNbPaveBlocks=aSectEdges.Extent();
1257       BOPTools_ListIteratorOfListOfPaveBlock aPBIt(aSectEdges);
1258       pbi = 0;
1259       for (; aPBIt.More(); aPBIt.Next()) {
1260         pbi++;
1261         BOPTools_PaveBlock& aPB=aPBIt.Value();
1262         //
1263         // Pave1
1264         const BOPTools_Pave& aPave1=aPB.Pave1(); 
1265         nV1=aPave1.Index();
1266         t1=aPave1.Param();
1267         aV1=TopoDS::Vertex(myDS->GetShape(nV1));
1268         aV1.Orientation(TopAbs_FORWARD);
1269         //
1270         // Pave2
1271         const BOPTools_Pave& aPave2=aPB.Pave2();
1272         nV2=aPave2.Index();
1273         t2=aPave2.Param();
1274         aV2=TopoDS::Vertex(myDS->GetShape(nV2));
1275         aV2.Orientation(TopAbs_REVERSED);
1276         //
1277         // MakeSplitEdge
1278         //
1279         // reject building parallel sect. edge on the same pave block,
1280         //          if distance between created and this edges is too small
1281         if(IsPaveBlock(nV1,nV2,aFFPBL)) {
1282           Standard_Real diffTol = 1.e-7;
1283           Standard_Integer eI = RejectBuildingEdge(aIC,aV1,aV2,t1,t2,aFFSEL,diffTol);
1284           if(eI != 0) {
1285             Standard_Integer eIndex = 0;
1286             TopTools_ListIteratorOfListOfShape aSEIt(aFFSEL);
1287             for(; aSEIt.More(); aSEIt.Next()) {
1288               eIndex++;
1289               if(eIndex == eI) {
1290                 const TopoDS_Edge & aE = TopoDS::Edge(aSEIt.Value());
1291                 TopoDS_Edge& anEdge = (TopoDS_Edge &) aE;
1292                 BOPTools_ListOfPaveBlock& aListPB = (BOPTools_ListOfPaveBlock&) aSectEdges;
1293                 aListPB.Remove(aPBIt);
1294                 BB.UpdateEdge( anEdge, 2*(aTolFF+diffTol) );
1295                 BB.UpdateVertex( aV1, 2*(aTolFF+diffTol) );
1296                 BB.UpdateVertex( aV2, 2*(aTolFF+diffTol) );
1297                 break;
1298               }
1299             }
1300             if(aPBIt.More())
1301               continue;
1302             else
1303               break;
1304           }
1305         }
1306        
1307         if(fabs(t1-t2) <= 1.e-10) continue;
1308         BOPTools_Tools::MakeSectEdge (aIC, aV1, t1, aV2, t2, aESect);
1309         //
1310         BB.UpdateEdge( aESect, aTolFF );
1311         BB.UpdateVertex( aV1, aTolFF );
1312         BB.UpdateVertex( aV2, aTolFF );
1313         ///////////////////////////////////
1314         // Add Sect Part to the DS
1315         BooleanOperations_AncestorsSeqAndSuccessorsSeq anASSeq;
1316         
1317         anASSeq.SetNewSuccessor(nV1);
1318         anASSeq.SetNewOrientation(aV1.Orientation());
1319         
1320         anASSeq.SetNewSuccessor(nV2);
1321         anASSeq.SetNewOrientation(aV2.Orientation());
1322         //
1323         myDS->InsertShapeAndAncestorsSuccessors(aESect, anASSeq);
1324         aNewShapeIndex=myDS->NumberOfInsertedShapes();
1325         //
1326         aPB.SetEdge(aNewShapeIndex);
1327         //
1328         aFFSEL.Append(aESect);
1329         aFFPBL.Append(aPB);
1330       }
1331     }
1332   }
1333   
1334 }
1335 //=======================================================================
1336 // function: PutPaveOnCurve
1337 // purpose: 
1338 //=======================================================================
1339   void BOPTools_PaveFiller::PutPaveOnCurve(const BOPTools_PaveSet& aPaveSet,
1340                                            const Standard_Real aTolR3D,
1341                                            BOPTools_Curve& aBC)
1342
1343   const BOPTools_ListOfPave& aLP=aPaveSet.Set();
1344   BOPTools_ListIteratorOfListOfPave anIt(aLP);
1345   for (; anIt.More(); anIt.Next()) {
1346     const BOPTools_Pave& aPave=anIt.Value();
1347     PutPaveOnCurve (aPave, aTolR3D, aBC);
1348   }
1349 }
1350 //=======================================================================
1351 // function: PutPaveOnCurve
1352 // purpose: 
1353 //=======================================================================
1354   void BOPTools_PaveFiller::PutPaveOnCurve (const BOPTools_Pave& aPave,
1355                                             const Standard_Real aTolR3D,
1356                                             BOPTools_Curve& aBC)
1357 {
1358   Standard_Integer nV;
1359   Standard_Boolean bIsVertexOnLine;
1360   Standard_Real aT, aTolVExt, aTolTresh;
1361   BRep_Builder aBB;
1362   //
1363   aTolTresh=0.01;
1364   nV=aPave.Index();
1365   const TopoDS_Vertex& aV=TopoDS::Vertex(myDS->Shape(nV));
1366   const IntTools_Curve& aC=aBC.Curve();
1367   Handle (Geom_Curve) aC3D= aC.Curve();
1368   //
1369   aTolVExt=BRep_Tool::Tolerance(aV);
1370   ExtendedTolerance(nV, aTolVExt);
1371   bIsVertexOnLine=myContext->IsVertexOnLine(aV, aTolVExt, aC, aTolR3D, aT);
1372   //
1373   if (bIsVertexOnLine) {
1374     BOPTools_Pave aPaveNew(nV, aT, BooleanOperations_SurfaceSurface);
1375     BOPTools_PaveSet& aPaveSet=aBC.Set();
1376     aPaveSet.Append(aPaveNew);
1377     //<-B
1378     BOPTools_Tools::UpdateVertex (aC, aT, aV);
1379     if(aTolR3D<aTolTresh) {
1380     aBB.UpdateVertex(aV, aTolR3D);
1381     }
1382   }
1383 }
1384 //
1385 //=======================================================================
1386 // function: ExtendedTolerance
1387 // purpose: 
1388 //=======================================================================
1389   Standard_Boolean BOPTools_PaveFiller::ExtendedTolerance(const Standard_Integer nV,
1390                                                           Standard_Real& aTolVExt)
1391 {
1392   Standard_Boolean bFound, bIsNewShape;
1393   Standard_Integer k, i, aNbLines, aNewShape;
1394   Standard_Real aT11, aT12, aD1, aD2, aD;
1395   TopoDS_Vertex aV;
1396   gp_Pnt aPV, aP11, aP12;
1397   //
1398   bFound=Standard_False;
1399   //
1400   bIsNewShape=myDS->IsNewShape(nV);
1401   if (!bIsNewShape) {
1402     return bFound;
1403   }
1404   //
1405   aV=TopoDS::Vertex(myDS->Shape(nV));
1406   aPV=BRep_Tool::Pnt(aV);
1407   //
1408   const BOPTools_InterferencePool& anInterferencePool=*myIntrPool;
1409   const BOPTools_CArray1OfEEInterference&  aEEInterfs=anInterferencePool.EEInterfs();
1410   const BOPTools_CArray1OfESInterference&  aESInterfs=anInterferencePool.ESInterfs();
1411   //
1412   for (k=0; k<2; ++k) {
1413     aNbLines=(!k) ? aEEInterfs.Extent() : aESInterfs.Extent();
1414     for (i=1; i<=aNbLines; ++i) {
1415       BOPTools_ShapeShapeInterference *pI=(!k) ? 
1416         (BOPTools_ShapeShapeInterference *)&aEEInterfs(i):
1417           (BOPTools_ShapeShapeInterference *)&aESInterfs(i);
1418       //
1419       aNewShape=pI->NewShape();
1420       if (aNewShape==nV) {
1421         const IntTools_CommonPrt& aCPart=(!k) ? 
1422           aEEInterfs(i).CommonPrt() : 
1423             aESInterfs(i).CommonPrt();
1424         //
1425         const TopoDS_Edge& aE1=aCPart.Edge1();
1426         aCPart.Range1(aT11, aT12);
1427         BOPTools_Tools::PointOnEdge(aE1, aT11, aP11);
1428         BOPTools_Tools::PointOnEdge(aE1, aT12, aP12);
1429         aD1=aPV.Distance(aP11);
1430         aD2=aPV.Distance(aP12);
1431         aD=(aD1>aD2)? aD1 : aD2;
1432         if (aD>aTolVExt) {
1433           aTolVExt=aD;
1434         }
1435         bFound=!bFound;
1436         return bFound;
1437       }
1438     }
1439   }
1440   //
1441   return bFound;
1442 }
1443 //
1444 //=======================================================================
1445 // function: PutPavesOnCurves
1446 // purpose: 
1447 //=======================================================================
1448   void BOPTools_PaveFiller::PutPavesOnCurves ()
1449 {
1450   Standard_Integer i, j, aNbCurves, aNbFFs, nF1, nF2, nV;
1451   Standard_Real aTolR3D = 0.;
1452
1453   BOPTools_CArray1OfSSInterference& aFFs=myIntrPool->SSInterferences();
1454   
1455   aNbFFs=aFFs.Extent();
1456
1457   for (i=1; i<=aNbFFs; i++) {
1458     BOPTools_SSInterference& aFFi=aFFs(i);
1459     // 
1460     // Curves' tolerance
1461     aTolR3D=aFFi.TolR3D();
1462     //
1463     // Faces
1464     nF1=aFFi.Index1();
1465     nF2=aFFi.Index2();
1466
1467     //
1468     // Put existing paves on curves
1469     BOPTools_PaveSet aPSF;
1470     PrepareSetForFace (nF1, nF2, aPSF);
1471     //
1472     //f
1473     {
1474       Standard_Integer nVX;
1475       BOPTools_ListIteratorOfListOfPave aItLP;
1476       TColStd_MapOfInteger aMVStick;
1477       //
1478       const BOPTools_ListOfPave& aLPX=aPSF.Set();
1479       aItLP.Initialize(aLPX);
1480       for (; aItLP.More(); aItLP.Next()) {
1481         const BOPTools_Pave& aPX=aItLP.Value();
1482         nVX=aPX.Index();
1483         aMVStick.Add(nVX);
1484       }
1485       //
1486       CorrectTolR3D(*this, aFFi, aMVStick, aTolR3D);
1487     }
1488     //t
1489     //
1490     BOPTools_SequenceOfCurves& aSCvs=aFFi.Curves();
1491     aNbCurves=aSCvs.Length();
1492     for (j=1; j<=aNbCurves; j++) {
1493       BOPTools_Curve& aBC=aSCvs(j);
1494       // DEBUG
1495       const IntTools_Curve& aC=aBC.Curve();
1496       Handle (Geom_Curve) aC3D= aC.Curve();
1497       //
1498       PutPaveOnCurve (aPSF, aTolR3D, aBC);
1499     }
1500     //f
1501     {
1502       Standard_Integer aNbVtx, jx;
1503       Standard_Real aTolVRange;
1504       TColStd_SequenceOfInteger aSeqVx;
1505       TColStd_SequenceOfReal    aSeqTolVx;
1506       //
1507       ProcessAloneStickVertices(nF1, 
1508                                 nF2, 
1509                                 aPSF, 
1510                                 aSCvs, 
1511                                 *this,
1512                                 aSeqVx, 
1513                                 aSeqTolVx);
1514       // 
1515       aNbVtx=aSeqVx.Length();
1516       for (jx=1; jx<=aNbVtx; ++jx) {
1517         BOPTools_PaveSet aPSFx;
1518         BOPTools_Pave aPVx;
1519
1520         nV=aSeqVx(jx);
1521         aTolVRange=aSeqTolVx(jx);
1522         
1523         aPVx.SetIndex(nV);
1524         aPSFx.Append(aPVx);
1525
1526         for (j=1; j<=aNbCurves; j++) {
1527           BOPTools_Curve& aBC=aSCvs(j);
1528           // DEBUG
1529           const IntTools_Curve& aC=aBC.Curve();
1530           Handle (Geom_Curve) aC3D= aC.Curve();
1531           //
1532           PutPaveOnCurve (aPSFx, aTolVRange, aBC);
1533         }
1534       }
1535     }
1536     //t
1537     //
1538     // Put bounding paves on curves
1539     //Check very specific case of cone-cone intersection (OCC13211)
1540
1541     Standard_Boolean bIsSpecific = Standard_False;
1542     if(aNbCurves >= 4) {
1543       const TopoDS_Shape aF1 = myDS->GetShape(nF1);
1544       BRepAdaptor_Surface aS1(TopoDS::Face(aF1), Standard_False);
1545       GeomAbs_SurfaceType aSType = aS1.GetType();
1546       if(aSType == GeomAbs_Cone) {
1547         const TopoDS_Shape aF2 = myDS->GetShape(nF2);
1548         BRepAdaptor_Surface aS2(TopoDS::Face(aF2), Standard_False);
1549         aSType = aS2.GetType();
1550         if(aSType == GeomAbs_Cone) {
1551           bIsSpecific = Standard_True;
1552         }
1553       }
1554     }
1555     //
1556     if(bIsSpecific) {
1557       for (j=1; j<=aNbCurves; j++) {
1558         BOPTools_Curve& aBC=aSCvs(j);
1559         PutBoundPaveOnCurveSpec (aBC, aFFi);
1560       }
1561     }
1562     else {
1563       for (j=1; j<=aNbCurves; j++) {
1564         BOPTools_Curve& aBC=aSCvs(j);
1565         PutBoundPaveOnCurve (aBC, aFFi);
1566       }
1567     }
1568     //
1569     // Put closing pave if needded
1570     for (j=1; j<=aNbCurves; ++j) {
1571       BOPTools_Curve& aBC=aSCvs(j);
1572       PutClosingPaveOnCurve (aBC, aFFi);
1573     }
1574     //
1575     // xxx
1576     for (j=1; j<=aNbCurves; j++) {
1577       BOPTools_Curve& aBC=aSCvs(j);
1578       BOPTools_ListOfPave anOldList;
1579       anOldList = aBC.Set().Set();
1580
1581       if (aBC.NewPaveBlocks().IsEmpty()) {
1582         continue;
1583       }
1584       //
1585       
1586       BOPTools_CArray1OfESInterference& aESs = myIntrPool->ESInterferences();
1587       Standard_Integer k, fit;
1588       //
1589       // Among all aESs find those that are between nE1 from nF1(nE2 from nF2) and nF2(nF1)  
1590       for(k = 1; k <= aESs.Length(); k++) {
1591         BOPTools_ESInterference& aES = aESs(k);
1592
1593         if(aES.Index1() == nF1 || aES.Index2() == nF2) {
1594           Standard_Integer nE = (aES.Index1() == nF1) ? aES.Index2() : aES.Index1();
1595
1596           // check if it belongs to F1 or F2.begin
1597           Standard_Boolean edgefound = Standard_False;
1598
1599           for(fit = 0; !edgefound && (fit < 2); fit++) {
1600             Standard_Integer nF = (fit == 0) ? nF1 : nF2;
1601             Standard_Integer sit1 = 0, sit2 = 0;
1602
1603             for(sit1 = 1; !edgefound && (sit1 <= myDS->NumberOfSuccessors(nF)); sit1++) {
1604               Standard_Integer asuccessor = myDS->GetSuccessor(nF, sit1);
1605
1606               for(sit2 = 1; sit2 <= myDS->NumberOfSuccessors(asuccessor); sit2++) {
1607                 if(nE == myDS->GetSuccessor(asuccessor, sit2)) {
1608                   edgefound = Standard_True;
1609                   break;
1610                 }
1611               }
1612             }
1613           }
1614           // check if it belongs to F1 or F2.end
1615
1616           if(edgefound) {
1617             RestrictCurveIn2d (nE, nF1, nF2, aTolR3D, aBC);// ->
1618           }
1619         }
1620       }// for(k = 1; k <= aESs.Length(); k++) 
1621
1622       for(fit = 1; fit <= 2; fit++) {
1623         Standard_Integer nF = (fit == 1) ? nF1 : nF2;
1624         Standard_Integer nFOpposite = (fit == 1) ? nF2 : nF1;
1625         TopExp_Explorer anExp(myDS->Shape(nF), TopAbs_EDGE);
1626
1627         for(; anExp.More(); anExp.Next()) {
1628           Standard_Integer nE = myDS->ShapeIndex(anExp.Current(), fit);
1629
1630           if(nE) {
1631             const BOPTools_ListOfInterference& aList =
1632               myIntrPool->InterferenceTable().Value(nE).GetOnType(BooleanOperations_EdgeSurface);
1633             BOPTools_ListIteratorOfListOfInterference anIt2(aList);
1634             Standard_Boolean bProcessed = Standard_False;
1635
1636             for(; anIt2.More(); anIt2.Next()) {
1637               if(anIt2.Value().With() == nFOpposite) {
1638                 if(!bProcessed) {
1639                   RestrictCurveIn2d (nE, nF1, nF2, aTolR3D, aBC);
1640                   bProcessed = Standard_True;
1641                   break;
1642                 }
1643               }
1644             }
1645
1646             if(!myCommonBlockPool(myDS->RefEdge(nE)).IsEmpty() &&
1647                !bProcessed) {
1648               RestrictCurveIn2d (nE, nF1, nF2, aTolR3D, aBC);
1649             }
1650           }
1651         }
1652       }
1653       // end for(fit = 1...
1654
1655       // put new paves on other curves.begin
1656       BOPTools_ListOfPave aListOfNewPave;
1657       BOPTools_ListIteratorOfListOfPave anIt1, anIt2;
1658
1659       for(anIt1.Initialize(aBC.Set().Set()); anIt1.More(); anIt1.Next()) {
1660         Standard_Boolean bfound = Standard_False;
1661         for(anIt2.Initialize(anOldList); anIt2.More(); anIt2.Next()) {
1662           if(anIt1.Value().IsEqual(anIt2.Value())) {
1663             bfound = Standard_True;
1664             break;
1665           }
1666         }
1667
1668         if(!bfound) {
1669           aListOfNewPave.Append(anIt1.Value());
1670         }
1671       }
1672
1673       Standard_Integer m = 0, n = 0;
1674       for (m=1; m<=aNbFFs; m++) {
1675         BOPTools_SSInterference& aFFm = aFFs(m);
1676         // 
1677         // Curves' tolerance
1678         Standard_Real aTolR3D2 = aFFm.TolR3D();
1679
1680         BOPTools_SequenceOfCurves& aSCvs2 = aFFm.Curves();
1681         Standard_Integer aNbCurves2 = aSCvs2.Length();
1682
1683         for(n = 1; n <= aNbCurves2; n++) {
1684           if((n == j) && (m == i))
1685             continue;
1686           BOPTools_Curve& aBC2 = aSCvs2(n);
1687
1688           for(anIt1.Initialize(aListOfNewPave); anIt1.More(); anIt1.Next()) {
1689             Standard_Boolean bfound = Standard_False;
1690             for(anIt2.Initialize(aBC2.Set().Set()); anIt2.More(); anIt2.Next()) {
1691               if(anIt1.Value().Index() == anIt2.Value().Index()) {
1692                 bfound = Standard_True;
1693                 break;
1694               }       
1695             }
1696
1697             if(!bfound) {
1698               PutPaveOnCurve (anIt1.Value(), aTolR3D2, aBC2);
1699             }
1700           }
1701         }
1702       }
1703       // put new paves on other curves.end
1704     } // xxx for (j=1; j<=aNbCurves; j++)
1705
1706     //wkar OCC334 f
1707     {
1708       Standard_Integer aNbVtx, jx;
1709       Standard_Real aTolVRange;
1710       TColStd_SequenceOfInteger aSeqVx;
1711       TColStd_SequenceOfReal    aSeqTolVx;
1712       //
1713       ProcessAloneStickVertices(nF1, 
1714                                 nF2, 
1715                                 aPSF, 
1716                                 aSCvs, 
1717                                 *myIntrPool, 
1718                                 *this,
1719                                 aSeqVx, 
1720                                 aSeqTolVx);
1721       //
1722       aNbVtx=aSeqVx.Length();
1723       for (jx=1; jx<=aNbVtx; ++jx) {
1724         BOPTools_PaveSet aPSFx;
1725         BOPTools_Pave aPVx;
1726
1727         nV=aSeqVx(jx);
1728         aTolVRange=aSeqTolVx(jx);
1729         
1730         aPVx.SetIndex(nV);
1731         aPSFx.Append(aPVx);
1732
1733         for (j=1; j<=aNbCurves; j++) {
1734           BOPTools_Curve& aBC=aSCvs(j);
1735           // DEBUG
1736           const IntTools_Curve& aC=aBC.Curve();
1737           Handle (Geom_Curve) aC3D= aC.Curve();
1738           //
1739           PutPaveOnCurve (aPSFx, aTolVRange, aBC);
1740         }
1741       }
1742     }
1743     //wkar OCC334 t
1744   }
1745 }
1746 //=======================================================================
1747 // function: PrepareSetForFace
1748 // purpose: 
1749 //=======================================================================
1750   void BOPTools_PaveFiller::PrepareSetForFace(const Standard_Integer nF1,
1751                                               const Standard_Integer nF2,
1752                                               BOPTools_PaveSet& aPaveSet)
1753
1754   Standard_Integer i, aNbV, nV;
1755   TColStd_IndexedMapOfInteger aMV;
1756   //
1757   StickVertices(nF1, nF2, aMV);
1758   //
1759   aNbV=aMV.Extent();
1760   for (i=1; i<=aNbV; ++i) {
1761     nV=aMV(i);
1762     BOPTools_Pave aPV;
1763     aPV.SetIndex(nV);
1764     aPaveSet.Append(aPV);
1765   }
1766 }
1767 //=======================================================================
1768 // function: IsPaveBlock
1769 // purpose: 
1770 //=======================================================================
1771 Standard_Boolean IsPaveBlock(const Standard_Integer nV1,
1772                              const Standard_Integer nV2, 
1773                              const BOPTools_ListOfPaveBlock& aLPBExisting)
1774 {
1775   Standard_Boolean bFlag=Standard_True;
1776   Standard_Integer nVE1, nVE2;
1777
1778   BOPTools_ListIteratorOfListOfPaveBlock anIt(aLPBExisting);
1779   for (; anIt.More(); anIt.Next()) {
1780     const BOPTools_PaveBlock& aPBR=anIt.Value();
1781     // 
1782     nVE1=aPBR.Pave1().Index();
1783     // 
1784     nVE2=aPBR.Pave2().Index();
1785     //
1786     if ((nVE1==nV1 && nVE2==nV2) || (nVE2==nV1 && nVE1==nV2)) {
1787       return bFlag;
1788     }
1789   }
1790    return !bFlag;
1791 }
1792
1793 //=======================================================================
1794 // function: FMapWhat
1795 // purpose: 
1796 //=======================================================================
1797   void FMapWhat(const Standard_Integer nF,
1798                     BOPTools_InterferencePool* myIntrPool,
1799                     TColStd_IndexedMapOfInteger& aMapWhat)
1800                     
1801 {
1802   Standard_Integer nE, nV;
1803  
1804   
1805
1806   BooleanOperations_ShapesDataStructure* myDS=myIntrPool->DS();
1807   BooleanOperations_OnceExplorer aExp(*myDS);
1808   //
1809   //  What
1810   aMapWhat.Add(nF);
1811   aExp.Init(nF, TopAbs_VERTEX);
1812   for (; aExp.More(); aExp.Next()) {
1813     nV=aExp.Current();
1814     aMapWhat.Add(nV);
1815   }
1816   //
1817   aExp.Init(nF, TopAbs_EDGE);
1818   for (; aExp.More(); aExp.Next()) {
1819     nE=aExp.Current();
1820     aMapWhat.Add(nE);
1821   }
1822 }
1823
1824 //=======================================================================
1825 // function: FMapWith
1826 // purpose: 
1827 //=======================================================================
1828   void FMapWith(const Standard_Integer nF,
1829                 BOPTools_InterferencePool* myIntrPool,
1830                 TColStd_IndexedMapOfInteger& aMapWith)
1831 {
1832   TColStd_IndexedMapOfInteger aMapWhat;
1833   
1834   FMapWhat(nF, myIntrPool, aMapWhat);
1835   //
1836   // With
1837   Standard_Integer i, aNb, anIndex, aWhat, aWith;
1838   BOPTools_ListIteratorOfListOfInterference anIt;
1839   
1840   const BOPTools_CArray1OfInterferenceLine& anArrIL= myIntrPool->InterferenceTable();
1841
1842   aNb=aMapWhat.Extent();
1843   for (i=1; i<=aNb; i++) {
1844     aWhat=aMapWhat(i);
1845     
1846     const BOPTools_InterferenceLine& aWithLine=anArrIL(aWhat);
1847   
1848     const BOPTools_ListOfInterference& aLI=aWithLine.List();
1849     anIt.Initialize(aLI);
1850     for (; anIt.More(); anIt.Next()) {
1851       const BOPTools_Interference& anIntf=anIt.Value();
1852       anIndex=anIntf.Index();
1853       if (anIndex) {
1854         aWith=anIntf.With();
1855         aMapWith.Add(aWith);
1856       }
1857     }
1858   }
1859 }
1860
1861 //=======================================================================
1862 // function: IsFound
1863 // purpose: 
1864 //=======================================================================
1865 Standard_Boolean IsFound(const TColStd_IndexedMapOfInteger& aMapWhat,
1866                          const TColStd_IndexedMapOfInteger& aMapWith)
1867 {
1868   Standard_Boolean bFlag=Standard_False;
1869   Standard_Integer i, aNb, aWhat;
1870
1871   aNb=aMapWhat.Extent();
1872   for (i=1; i<=aNb; i++) {
1873     aWhat=aMapWhat(i);
1874     if (aMapWith.Contains(aWhat)) {
1875       return !bFlag;
1876     }
1877   }
1878   return bFlag;
1879 }
1880
1881
1882 //wkar OCC334 f
1883 #include <BOPTools_CArray1OfESInterference.hxx>
1884 #include <BOPTools_CArray1OfEEInterference.hxx>
1885 #include <BOPTools_ESInterference.hxx>
1886 #include <BOPTools_EEInterference.hxx>
1887 #include <IntTools_CommonPrt.hxx>
1888 #include <gp_Pnt.hxx>
1889 #include <Geom_Curve.hxx>
1890 #include <GeomAbs_SurfaceType.hxx>
1891 #include <Geom_Surface.hxx>
1892 #include <GeomAdaptor_Surface.hxx>
1893 #include <GeomAPI_ProjectPointOnCurve.hxx>
1894 #include <BOPTools_Tools3D.hxx>
1895
1896 //=======================================================================
1897 // function: ProcessAloneStickVertices
1898 // purpose: 
1899 //=======================================================================
1900 void ProcessAloneStickVertices(const Standard_Integer nF1,
1901                                const Standard_Integer nF2,
1902                                const BOPTools_PaveSet& aPSF,
1903                                BOPTools_SequenceOfCurves& aSCvs,
1904                                const BOPTools_InterferencePool& anIntrPool, 
1905                                BOPTools_PaveFiller& aPF,
1906                                TColStd_SequenceOfInteger& aSeqVx,
1907                                TColStd_SequenceOfReal& aSeqTolVx)
1908 {
1909   Standard_Boolean bFound, bIsClosed;
1910   Standard_Integer aNbVtx, jx, nV;
1911   Standard_Real aTolVRange;
1912   TColStd_IndexedMapOfInteger aMapUnUsed;
1913   GeomAbs_SurfaceType aType1, aType2;
1914   //
1915   BooleanOperations_PShapesDataStructure pDS=anIntrPool.DS();
1916   //
1917   const TopoDS_Face& aF1= TopoDS::Face(pDS->Shape(nF1));
1918   const TopoDS_Face& aF2= TopoDS::Face(pDS->Shape(nF2));
1919   Handle(Geom_Surface) aS1=BRep_Tool::Surface(aF1);
1920   Handle(Geom_Surface) aS2=BRep_Tool::Surface(aF2);
1921   GeomAdaptor_Surface aGAS1(aS1);
1922   GeomAdaptor_Surface aGAS2(aS2);
1923   
1924   aType1=aGAS1.GetType();
1925   aType2=aGAS2.GetType();
1926
1927   if((aType1==GeomAbs_Cylinder && aType2==GeomAbs_Cylinder) 
1928      ||
1929      (aType1==GeomAbs_Plane && aType2==GeomAbs_Plane)) {
1930     //
1931     UnUsedMap(aSCvs, aPSF, aMapUnUsed);
1932     // 
1933     aNbVtx=aMapUnUsed.Extent();
1934     for (jx=1; jx<=aNbVtx; ++jx) {
1935       nV=aMapUnUsed(jx);
1936       if (pDS->IsNewShape(nV)) {
1937         bFound=VertexRangeTolerance(nV, nF1, nF2, anIntrPool, aTolVRange);
1938         if (bFound) {
1939           aSeqVx.Append(nV);
1940           aSeqTolVx.Append(aTolVRange);
1941         }
1942       }
1943     }
1944   }
1945   //
1946   //wkar  pkv/904/F7
1947   if((aType1==GeomAbs_Torus && aType2==GeomAbs_Plane) ||
1948      (aType1==GeomAbs_Plane && aType2==GeomAbs_Torus)) {
1949     Standard_Integer aNbSCvs, aNbPoints;
1950     Standard_Real aDist, aTolV;
1951     gp_Pnt aPV;
1952     //
1953     UnUsedMap(aSCvs, aPSF, aMapUnUsed);
1954     aNbVtx=aMapUnUsed.Extent();
1955     if (aNbVtx) {
1956       const Handle(IntTools_Context)& aCtx=aPF.Context();
1957       //
1958       aNbSCvs=aSCvs.Length();
1959       if (aNbSCvs==1) {
1960         BOPTools_Curve& aBC=aSCvs(1);
1961         const IntTools_Curve& aIC=aBC.Curve();
1962         Handle (Geom_Curve) aC3D= aIC.Curve();
1963         //
1964         bIsClosed=IntTools_Tools::IsClosed(aC3D);
1965         if (bIsClosed) {
1966           return;
1967         }
1968         GeomAPI_ProjectPointOnCurve& aProjPT=aCtx->ProjPT(aC3D);
1969         //
1970         for (jx=1; jx<=aNbVtx; ++jx) {
1971           nV=aMapUnUsed(jx);
1972           if (pDS->IsNewShape(nV)) {
1973             const TopoDS_Vertex& aV=*((TopoDS_Vertex*)&pDS->Shape(nV));
1974             aTolV=BRep_Tool::Tolerance(aV);
1975             aPV=BRep_Tool::Pnt(aV);
1976             //
1977             aProjPT.Perform(aPV);
1978             aNbPoints=aProjPT.NbPoints();
1979             if (aNbPoints) {
1980               aDist=aProjPT.LowerDistance();
1981               aDist=(aDist>aTolV)?  aDist : aTolV;
1982               aSeqVx.Append(nV);
1983               aSeqTolVx.Append(aDist);
1984             }
1985           }
1986         }
1987       }
1988     }
1989   }
1990 }
1991 //=======================================================================
1992 // function: ProcessAloneStickVertices
1993 // purpose: 
1994 //=======================================================================
1995 void ProcessAloneStickVertices(const Standard_Integer nF1,
1996                                const Standard_Integer nF2,
1997                                const BOPTools_PaveSet& aPSF,
1998                                BOPTools_SequenceOfCurves& aSCvs,
1999                                BOPTools_PaveFiller& aPF,
2000                                TColStd_SequenceOfInteger& aSeqVx,
2001                                TColStd_SequenceOfReal& aSeqTolVx)
2002 {
2003   GeomAbs_SurfaceType aType1, aType2;
2004   //
2005   BooleanOperations_PShapesDataStructure pDS=aPF.DS();
2006   //
2007   const TopoDS_Face& aF1= TopoDS::Face(pDS->Shape(nF1));
2008   const TopoDS_Face& aF2= TopoDS::Face(pDS->Shape(nF2));
2009   Handle(Geom_Surface) aS1=BRep_Tool::Surface(aF1);
2010   Handle(Geom_Surface) aS2=BRep_Tool::Surface(aF2);
2011   GeomAdaptor_Surface aGAS1(aS1);
2012   GeomAdaptor_Surface aGAS2(aS2);
2013   //
2014   aType1=aGAS1.GetType();
2015   aType2=aGAS2.GetType();
2016   //
2017   if(aType1==GeomAbs_Torus  || aType2==GeomAbs_Torus) {
2018     Standard_Integer aNbSCvs, jVU, aNbVU, nVU, k, m, n;
2019     Standard_Real aTC[2], aD, aD2, aDT2, aU, aV, aScPr, aDScPr;
2020     TColStd_IndexedMapOfInteger aMVU;
2021     GeomAbs_CurveType aTypeC;
2022     gp_Pnt aPC[2], aPVU;
2023     gp_Dir aDN[2];
2024     gp_Pnt2d aP2D;
2025     
2026     Handle(Geom2d_Curve) aC2D[2];
2027     //
2028     aDT2=2e-7;     // the rich criteria
2029     aDScPr=5.e-9;  // the creasing criteria
2030     //
2031     UnUsedMap(aSCvs, aPSF, aMVU);
2032     //
2033     aNbVU=aMVU.Extent();
2034     for (jVU=1; jVU<=aNbVU; ++jVU) {
2035       nVU=aMVU(jVU);
2036       const TopoDS_Vertex& aVU=*((TopoDS_Vertex*)&pDS->Shape(nVU));
2037       aPVU=BRep_Tool::Pnt(aVU);
2038       //
2039       aNbSCvs=aSCvs.Length();
2040       for (k=1; k<=aNbSCvs; ++k) {
2041         BOPTools_Curve& aBC=aSCvs(k);
2042         const IntTools_Curve& aIC=aBC.Curve();
2043         //Handle(Geom_Curve) aC3D=aIC.Curve(); //DEB
2044         aTypeC=aIC.Type();
2045         if (!(aTypeC==GeomAbs_BezierCurve || GeomAbs_BSplineCurve)) {
2046           continue;
2047         }
2048         //
2049         aIC.Bounds(aTC[0], aTC[1], aPC[0], aPC[1]);
2050         aC2D[0]=aIC.FirstCurve2d();
2051         aC2D[1]=aIC.SecondCurve2d();
2052         if (aC2D[0].IsNull() || aC2D[1].IsNull()) {
2053            continue;
2054         }
2055         //
2056         for (m=0; m<2; ++m) {
2057           aD2=aPC[m].SquareDistance(aPVU);
2058           if (aD2>aDT2) {// no rich
2059             continue; 
2060           }
2061           //
2062           for (n=0; n<2; ++n) {
2063             Handle(Geom_Surface)& aS=(!n)? aS1 : aS2;
2064             aC2D[n]->D0(aTC[m], aP2D);
2065             aP2D.Coord(aU, aV);
2066             BOPTools_Tools3D::GetNormalToSurface(aS, aU, aV, aDN[n]);
2067           }
2068           // 
2069           aScPr=aDN[0]*aDN[1];
2070           if (aScPr<0.) {
2071             aScPr=-aScPr;
2072           }
2073           aScPr=1.-aScPr;
2074           //
2075           if (aScPr>aDScPr) {
2076             continue;
2077           }
2078           //
2079           // The intersection curve aIC is vanishing curve (the crease)
2080           aD=sqrt(aD2);
2081           //
2082           aSeqVx.Append(nVU);
2083           aSeqTolVx.Append(aD);
2084         }
2085       }//for (k=1; k<=aNbSCvs; ++k) {
2086     }//for (jVU=1; jVU=aNbVU; ++jVU) {
2087   }//if(aType1==GeomAbs_Torus  || aType2==GeomAbs_Torus) {
2088 }
2089 //=======================================================================
2090 // function: UnUsedMap
2091 // purpose: 
2092 //=======================================================================
2093 void UnUsedMap(BOPTools_SequenceOfCurves& aSCvs,
2094                const BOPTools_PaveSet& aPSF,
2095                TColStd_IndexedMapOfInteger& aMapUnUsed)
2096 {
2097   //
2098   // What stick/non-stick vertices we used 
2099   TColStd_IndexedMapOfInteger aMapUsed, aMapMustBeUsed;
2100   Standard_Integer j, aNbCurves, aNbVtx, nV1;//, nV2;
2101   BOPTools_ListIteratorOfListOfPave anLPIt;
2102
2103   aNbCurves=aSCvs.Length();
2104   for (j=1; j<=aNbCurves; ++j) {
2105     BOPTools_Curve& aBC=aSCvs(j);
2106     //const IntTools_Curve& aC= aBC.Curve();// Wng in Gcc 3.0
2107         
2108     const BOPTools_PaveSet& aPaveSet=aBC.Set();
2109     const BOPTools_ListOfPave& aLPAlreadyUsed=aPaveSet.Set();
2110     anLPIt.Initialize(aLPAlreadyUsed);
2111     for (; anLPIt.More(); anLPIt.Next()) {
2112       const BOPTools_Pave& aPave=anLPIt.Value();
2113       nV1=aPave.Index();
2114       aMapUsed.Add(nV1);
2115     }
2116   }
2117   // 
2118   // 2. Stick vertices that must be used
2119   const BOPTools_ListOfPave& aLPMustUsed=aPSF.Set();
2120   anLPIt.Initialize(aLPMustUsed);
2121   for (; anLPIt.More(); anLPIt.Next()) {
2122     const BOPTools_Pave& aPave=anLPIt.Value();
2123     nV1=aPave.Index();
2124     aMapMustBeUsed.Add(nV1);
2125   }
2126   //
2127   // 3.Unused Stick vertices .
2128   aNbVtx=aMapMustBeUsed.Extent();
2129   for (j=1; j<=aNbVtx; ++j) {
2130     nV1=aMapMustBeUsed(j);
2131     if (!aMapUsed.Contains(nV1)) {
2132       aMapUnUsed.Add(nV1);
2133     }
2134   }
2135   // 
2136 }
2137 //=======================================================================
2138 // function: VertexRangeTolerance
2139 // purpose: 
2140 //=======================================================================
2141 Standard_Boolean VertexRangeTolerance(const Standard_Integer nV,
2142                                       const Standard_Integer nF1,
2143                                       const Standard_Integer nF2,
2144                                       const BOPTools_InterferencePool& anIntrPool,
2145                                       Standard_Real& aTolV)
2146 {
2147   Standard_Boolean bFound=Standard_False;
2148   Standard_Integer i, aNbEFs, iWhat, iWith, iNewShape ;
2149   TColStd_IndexedMapOfInteger aMEF;
2150   //
2151   BooleanOperations_PShapesDataStructure pDS=anIntrPool.DS();
2152   //
2153   const TopoDS_Vertex& aV=TopoDS::Vertex(pDS->Shape(nV));
2154   //
2155   FaceAndEdgeMap(nF1, anIntrPool, aMEF);
2156   FaceAndEdgeMap(nF2, anIntrPool, aMEF);
2157   //
2158   // EF Interferences
2159   const BOPTools_CArray1OfESInterference& aEFs=anIntrPool.ESInterfs();
2160   
2161   aNbEFs=aEFs.Extent();
2162   for (i=1; i<=aNbEFs; ++i) {
2163     const BOPTools_ESInterference& aEF=aEFs(i);
2164     iNewShape=aEF.NewShape();
2165     if (iNewShape==nV) {
2166       aEF.Indices(iWhat, iWith);
2167       if (aMEF.Contains(iWhat) && aMEF.Contains(iWith)) {
2168         //...
2169         Standard_Real aTolVWas, aD1, aD2, aDMax;
2170         gp_Pnt aP3DV, aP3DV1, aP3DV2;
2171         //
2172         const IntTools_CommonPrt& aCommonPrt=aEF.CommonPrt();
2173         //const TopoDS_Edge& aE1= aCommonPrt.Edge1();// Wng in Gcc 3.0
2174         
2175         aP3DV=BRep_Tool::Pnt(aV);
2176         aTolVWas=BRep_Tool::Tolerance(aV);
2177         
2178         aCommonPrt.BoundingPoints(aP3DV1, aP3DV2);
2179         aD1=aP3DV.Distance(aP3DV1);
2180         aD2=aP3DV.Distance(aP3DV2);
2181         
2182         aDMax=Max(aD1, aD2);
2183
2184         aTolV=aTolVWas;
2185         if (aDMax>aTolVWas) {
2186           aTolV=aDMax;
2187         }
2188         return !bFound;
2189       }
2190     }
2191   }
2192   //
2193   // EE Interferences
2194   /*
2195   const BOPTools_CArray1OfEEInterference& aEEs=anIntrPool.EEInterfs();
2196   aNbEEs=aEEs.Extent();
2197   for (i=1; i<=aNbEEs; ++i) {
2198     const BOPTools_EEInterference& aEE=aEEs(i);
2199     iNewShape=aEE.NewShape();
2200     if (iNewShape==nV) {
2201       aEE.Indices(iWhat, iWith);
2202       if (aMEF.Contains(iWhat) && aMEF.Contains(iWith)) {
2203         //...
2204         aTolV=0.;
2205         return !bFound;
2206       }
2207     }
2208   }
2209   */
2210   //
2211   return bFound;
2212 }
2213
2214 //=======================================================================
2215 // function: FaceAndEdgeMap
2216 // purpose: 
2217 //=======================================================================
2218 void FaceAndEdgeMap(const Standard_Integer nF,
2219                     const BOPTools_InterferencePool& anIntrPool,
2220                     TColStd_IndexedMapOfInteger& aMEF)
2221 {
2222   Standard_Integer nEF;
2223   aMEF.Add(nF);
2224   BooleanOperations_PShapesDataStructure myDS=anIntrPool.DS();
2225   BooleanOperations_OnceExplorer aExp(*myDS);
2226   aExp.Init(nF, TopAbs_EDGE);
2227   for (; aExp.More(); aExp.Next()) {
2228     nEF=aExp.Current();
2229     aMEF.Add(nEF);
2230   }
2231 }
2232 //wkar OCC334 t
2233
2234 //=======================================================================
2235 // function: IsPairFound
2236 // purpose: 
2237 //=======================================================================
2238 Standard_Boolean IsPairFound(const Standard_Integer nF1,
2239                              const Standard_Integer nF2,
2240                              BOPTools_InterferencePool* myIntrPool,
2241                              BOPTColStd_IndexedDataMapOfIntegerIndexedMapOfInteger& aMapWhat,
2242                              BOPTColStd_IndexedDataMapOfIntegerIndexedMapOfInteger& aMapWith)
2243 {
2244   Standard_Boolean bIsFound;
2245   //
2246   if (!aMapWhat.Contains(nF1)) {
2247     TColStd_IndexedMapOfInteger aMWhat;
2248     FMapWhat(nF1, myIntrPool, aMWhat);
2249     aMapWhat.Add(nF1, aMWhat);
2250   }
2251   //
2252   if (!aMapWith.Contains(nF2)) {
2253     TColStd_IndexedMapOfInteger aMWith;
2254     FMapWith(nF2, myIntrPool, aMWith);
2255     aMapWith.Add(nF2, aMWith);
2256   }
2257   //
2258   const TColStd_IndexedMapOfInteger& aMWht=aMapWhat.FindFromKey(nF1);
2259   const TColStd_IndexedMapOfInteger& aMWit=aMapWith.FindFromKey(nF2);
2260   //
2261   bIsFound=IsFound(aMWht, aMWit);
2262   //
2263   return bIsFound;
2264 }
2265
2266 //=======================================================================
2267 // function: RestrictCurveIn2d
2268 // purpose:  Intersects 2d curve of edge nE and 2d curve of theBC.
2269 //           Splits theBC by new vertex, also splits nE by new vertex.
2270 //           If nE has same domain with another edge, the same domain 
2271 //           edge is splitted too.
2272 //=======================================================================
2273   void BOPTools_PaveFiller::RestrictCurveIn2d(const Standard_Integer nE,
2274                                               const Standard_Integer nF1,
2275                                               const Standard_Integer nF2,
2276                                               const Standard_Real    theTolerance,
2277                                               BOPTools_Curve&        theBC) 
2278 {
2279   myPavePoolNew.Resize (myNbEdges);
2280   TopoDS_Shape atmpShape;
2281  
2282   BOPTools_CArray1OfESInterference& aESs = myIntrPool->ESInterferences();
2283
2284   BOPTools_PaveSet& aPS = myPavePool(myDS->RefEdge(nE));
2285   Standard_Boolean bSearchInter = Standard_True;
2286
2287   // 6841
2288   Standard_Integer pvVrtIndex = 0;
2289   //
2290
2291   BOPTools_ListIteratorOfListOfPave anIt1(aPS.Set());
2292   BOPTools_ListIteratorOfListOfPave anIt2;
2293
2294   for(; bSearchInter && anIt1.More(); anIt1.Next()) {
2295
2296     for(anIt2.Initialize(theBC.Set().Set()); anIt2.More(); anIt2.Next()) {
2297
2298       if(anIt1.Value().Index() == anIt2.Value().Index()) { // too hard condition for the algorithm
2299         // 6841
2300         pvVrtIndex = anIt1.Value().Index();
2301         //
2302         bSearchInter = Standard_False;
2303         break;
2304       }
2305     }
2306   }
2307   // -- 6841: test 2d intersection any way, but update vertex only
2308   if((!bSearchInter && pvVrtIndex != 0)) {
2309     Standard_Boolean OnFirst = (myDS->Rank(nE) == 1);
2310     TopoDS_Edge aE = TopoDS::Edge(myDS->Shape(nE));
2311     TopoDS_Face aF  = (OnFirst) ? TopoDS::Face(myDS->Shape(nF1)) : TopoDS::Face(myDS->Shape(nF2));
2312     Standard_Real pf2 = 0., pl2 = 0.;
2313     Handle(Geom_Curve)   aC2D3 = BRep_Tool::Curve(aE, pf2, pl2);
2314     Handle(Geom2d_Curve) aC2D2 = BRep_Tool::CurveOnSurface(aE, aF, pf2, pl2);
2315     Handle(Geom2d_Curve) aC1D2 = (OnFirst) ? theBC.Curve().FirstCurve2d() : theBC.Curve().SecondCurve2d();
2316     Handle(Geom_Curve)   aC1D3 = theBC.Curve().Curve();
2317     if((!aC2D3.IsNull() && !aC2D2.IsNull()) && (!aC1D2.IsNull() && !aC1D3.IsNull())) {
2318       Standard_Real pf1 = aC1D2->FirstParameter();
2319       Standard_Real pl1 = aC1D2->LastParameter();
2320       Geom2dAPI_InterCurveCurve aInt(aC1D2, aC2D2, Precision::PConfusion());
2321       if(aInt.NbPoints() > 0) {
2322         Standard_Integer jj = 1;
2323         for(; jj <= aInt.NbPoints(); jj++) {
2324           Standard_Real t1 = aInt.Intersector().Point(jj).ParamOnFirst();
2325           Standard_Real t2 = aInt.Intersector().Point(jj).ParamOnSecond();
2326           if((t1 >= pf1) && (t1 <= pl1) && (t2 >= pf2) && (t2 <= pl2)) {
2327 //             gp_Pnt2d aP2d = aInt.Point(jj);
2328             gp_Pnt   aP3d = aC2D3->Value(t2);
2329             gp_Pnt   aP3d2 = aC1D3->Value(t1);
2330             TopoDS_Vertex & aVrt = (TopoDS_Vertex &) myDS->Shape(pvVrtIndex);
2331             gp_Pnt aVP = BRep_Tool::Pnt(aVrt);
2332             Standard_Real aVTol  = BRep_Tool::Tolerance(aVrt);
2333             Standard_Real aD1 = aP3d.Distance(aVP);
2334             Standard_Real aD2 = aP3d2.Distance(aVP);
2335             Standard_Real aFD1 = fabs(aVTol-aD1);
2336             Standard_Real aFD2 = fabs(aVTol-aD2);
2337             if(aD1 > aVTol || aD2 > aVTol) {
2338               if(Max(aFD1,aFD2) <= 1.e-2) {
2339                 Standard_Real nTol = aVTol + 2. * Max(aFD1,aFD2) + 1.e-7;
2340                 BRep_Builder bb;
2341                 bb.UpdateVertex(aVrt, nTol);
2342               }
2343             }
2344           }
2345         }
2346       }
2347     }
2348   }
2349   //-- 6841
2350
2351   if(bSearchInter) {
2352     // search intersection in 2d. begin
2353     BOPTools_ListOfPave aPavesOnCurve, aPavesOnEdge;
2354     Standard_Boolean bIsOnFirst = (myDS->Rank(nE) == 1);
2355
2356     Handle(Geom2d_Curve) aC1 = (bIsOnFirst) ? theBC.Curve().FirstCurve2d() : theBC.Curve().SecondCurve2d();
2357
2358     if(aC1.IsNull())
2359       return;
2360     Standard_Real f1 = aC1->FirstParameter();
2361     Standard_Real l1 = aC1->LastParameter();
2362     
2363     // f1 and l1 may not correspond 
2364     // to boundary parameters of 3d curve
2365     if(theBC.Curve().HasBounds()) {
2366       gp_Pnt tmpp1, tmpp2;
2367       theBC.Curve().Bounds(f1, l1, tmpp1, tmpp2);
2368     }
2369
2370     atmpShape           = myDS->Shape(nE);
2371     TopoDS_Edge  anEdge = TopoDS::Edge(atmpShape);
2372     TopoDS_Shape aFace  = (bIsOnFirst) ? myDS->Shape(nF1) : myDS->Shape(nF2);
2373     Standard_Real f2=0., l2=0.;
2374     Handle(Geom2d_Curve) aC2 = BRep_Tool::CurveOnSurface(anEdge, TopoDS::Face(aFace), f2, l2);
2375     Handle(Geom_Curve) aCurve = BRep_Tool::Curve(anEdge, f2, l2);
2376
2377     if(aC2.IsNull() || aCurve.IsNull())
2378       return;
2379
2380     Geom2dAPI_InterCurveCurve anIntersector(aC1, aC2, Precision::PConfusion());
2381
2382     if(anIntersector.NbPoints() > 0) {
2383       Standard_Integer j = 0;
2384
2385       for(j = 1; j <= anIntersector.NbPoints(); j++) {
2386         Standard_Real t1 = anIntersector.Intersector().Point(j).ParamOnFirst();
2387         Standard_Real t2 = anIntersector.Intersector().Point(j).ParamOnSecond();
2388
2389         if((t1 >= f1) && (t1 <= l1) &&
2390            (t2 >= f2) && (t2 <= l2)) {
2391           gp_Pnt2d aP2dOnFace = anIntersector.Point(j);
2392           atmpShape  = (!bIsOnFirst) ? myDS->Shape(nF1) : myDS->Shape(nF2);
2393           TopoDS_Face anOtherFace = TopoDS::Face(atmpShape);
2394           gp_Pnt aP3d = aCurve->Value(t2);
2395
2396           if(myContext->IsPointInOnFace(TopoDS::Face(aFace), aP2dOnFace) &&
2397              myContext->IsValidPointForFace(aP3d, anOtherFace, BRep_Tool::Tolerance(anEdge))) {
2398             BOPTools_Pave aPave1;
2399             aPave1.SetParam(t1);
2400             aPave1.SetIndex(-1);
2401             aPavesOnCurve.Append(aPave1);
2402             BOPTools_Pave aPave2;
2403             aPave2.SetParam(t2);
2404             aPave2.SetIndex(-1);
2405             aPavesOnEdge.Append(aPave2);
2406           }
2407         }
2408       }
2409     } // (anIntersector.NbPoints())
2410     // search intersection in 2d. end
2411
2412
2413     BOPTools_ListIteratorOfListOfPave aPaveIt1(aPavesOnCurve);
2414     BOPTools_ListIteratorOfListOfPave aPaveIt2(aPavesOnEdge);
2415
2416     // test common blocks. begin
2417     Standard_Boolean bFaceCBFound = Standard_False;
2418     Standard_Boolean bEdgeCBFound = Standard_False;
2419     const BOPTools_ListOfCommonBlock& aLCBTest = myCommonBlockPool(myDS->RefEdge(nE));
2420     BOPTools_ListIteratorOfListOfCommonBlock aCBListIt(aLCBTest);
2421     Standard_Boolean bHasCBOnFace = Standard_False;
2422     Standard_Boolean bHasCBOnEdge = Standard_False;
2423
2424     for(; aCBListIt.More(); aCBListIt.Next()) {
2425       if((aCBListIt.Value().Face() == nF1) ||
2426          (aCBListIt.Value().Face() == nF2)) {
2427         bHasCBOnFace = Standard_True;
2428       }
2429
2430       if(aCBListIt.Value().Face() == 0) {
2431         bHasCBOnEdge = Standard_True;
2432       }
2433     }
2434     
2435     if(!bHasCBOnFace || !bHasCBOnEdge) {
2436       BOPTools_PaveSet aTestPaveSet;
2437       aTestPaveSet.ChangeSet() = aPS.Set();
2438
2439       for(; aPaveIt2.More(); aPaveIt2.Next()) {
2440         aTestPaveSet.Append(aPaveIt2.Value());
2441       }
2442       BOPTools_PaveBlockIterator aPBIter(0, aTestPaveSet);
2443
2444       for (; aPBIter.More(); aPBIter.Next()) {
2445         const BOPTools_PaveBlock& aPB = aPBIter.Value();
2446         Standard_Real aT1=aPB.Pave1().Param();
2447         Standard_Real aT2=aPB.Pave2().Param();
2448         gp_Pnt aPMid = aCurve->Value((aT1 + aT2) * 0.5);
2449         Standard_Integer nFOpposite = (bIsOnFirst) ? nF2 : nF1;
2450         TopoDS_Shape aOppFace = myDS->Shape(nFOpposite);
2451
2452         if(!bHasCBOnFace && !bFaceCBFound &&
2453            myContext->IsValidPointForFace(aPMid, TopoDS::Face(aOppFace), 
2454                                          BRep_Tool::Tolerance(anEdge) +
2455                                          BRep_Tool::Tolerance(TopoDS::Face(aOppFace)))) {
2456           bFaceCBFound = Standard_True;
2457         }
2458
2459         if(!bHasCBOnEdge && !bEdgeCBFound) {
2460           TopoDS_Vertex aVMid;
2461           BRep_Builder aBB;
2462           aBB.MakeVertex(aVMid, aPMid, BRep_Tool::Tolerance(anEdge));
2463           TopExp_Explorer anExpE(aOppFace, TopAbs_EDGE);
2464
2465           for(; anExpE.More(); anExpE.Next()) {
2466             TopoDS_Shape aTmpEdge = anExpE.Current();
2467             Standard_Real aParameter = 0.;
2468
2469             if(myContext->ComputeVE(aVMid, TopoDS::Edge(aTmpEdge), aParameter) == 0) {
2470               bEdgeCBFound = Standard_True;
2471               break;
2472             }
2473           }
2474         }
2475       }
2476       aPaveIt2.Initialize(aPavesOnEdge);
2477     }
2478     // test common blocks. end
2479
2480     Standard_Boolean bChecknAddPaves = Standard_True;
2481
2482     if(bEdgeCBFound) {
2483       bChecknAddPaves = Standard_False;
2484     }
2485     else {
2486       if(!bHasCBOnEdge) {
2487         bChecknAddPaves = !bFaceCBFound;
2488       }
2489     }
2490
2491     if(bChecknAddPaves) {
2492       // add paves chaking if new pave is equal to existent. begin
2493       for(; aPaveIt1.More() && aPaveIt2.More(); aPaveIt1.Next(), aPaveIt2.Next()) {
2494         BOPTools_Pave& aPaveOnCurve = aPaveIt1.Value();
2495         BOPTools_Pave& aPaveOnEdge  = aPaveIt2.Value();
2496
2497         gp_Pnt aP1 = theBC.Curve().Curve()->Value(aPaveOnCurve.Param());
2498         gp_Pnt aP2 = aCurve->Value(aPaveOnEdge.Param());
2499
2500         Standard_Boolean bAddNewVertex = Standard_True;
2501         Standard_Boolean bAddOldVertex = Standard_False;
2502         Standard_Integer oldvertexindex = 0;
2503
2504         for(anIt2.Initialize(theBC.Set().Set()); anIt2.More(); anIt2.Next()) {
2505           atmpShape = myDS->Shape(anIt2.Value().Index());
2506           TopoDS_Vertex aVertex = TopoDS::Vertex(atmpShape);
2507           gp_Pnt aPoint = BRep_Tool::Pnt(aVertex);
2508           Standard_Real aTolerance = theTolerance + BRep_Tool::Tolerance(aVertex);
2509           if((aPoint.Distance(aP1) < aTolerance) ||
2510              (aPoint.Distance(aP2) < aTolerance)) {
2511             bAddNewVertex = Standard_False;
2512             bAddOldVertex = Standard_True;
2513             oldvertexindex = anIt2.Value().Index(); 
2514             break;
2515           }
2516         }
2517
2518         // treat equality with other vertices.begin
2519         if(bAddNewVertex || bAddOldVertex) {
2520           TopoDS_Vertex aNewVertex;
2521           BOPTools_Tools::MakeNewVertex(anEdge, aPaveOnEdge.Param(), 
2522                                         TopoDS::Face(aFace),  aNewVertex);
2523           
2524           BOPTools_Pave aPaveToPut;
2525           Standard_Boolean bAddNewVertextmp = bAddNewVertex, bAddOldVertextmp = bAddOldVertex;
2526
2527           if(!CheckNewVertexAndUpdateData(aNewVertex, aPaveOnEdge.Param(), anEdge, aPaveOnCurve.Param(), 
2528                                           nF1, nF2, theTolerance, myIntrPool, myDS, myContext, aPS, 
2529                                           bAddNewVertextmp, bAddOldVertextmp, theBC, aPaveToPut, 
2530                                           bAddNewVertex, bAddOldVertex)) {
2531             bAddNewVertex = Standard_False;
2532             bAddOldVertex = Standard_False;
2533           }
2534           else {
2535             if((aPaveToPut.Index() != 0) && (aPaveToPut.Param() != 0.) &&
2536                aPaveToPut.Interference() != 0) {
2537               PutPaveOnCurve(aPaveToPut, theTolerance, theBC);
2538             }
2539           }
2540           // end for(anIt1.Initialize...
2541         }
2542         // treat equality with other vertices.end
2543         
2544         if(bAddNewVertex || (bAddOldVertex && oldvertexindex)) {
2545           TopoDS_Vertex aNewVertex;
2546
2547           Standard_Integer aNewShapeIndex = 0;
2548           
2549           // reject creation new vertex if there is a created one at a too small distance
2550           BOPTools_Tools::MakeNewVertex(anEdge,aPaveOnEdge.Param(),TopoDS::Face(aFace),aNewVertex);
2551           Standard_Real nvTol = BRep_Tool::Tolerance(aNewVertex);
2552           Standard_Integer chShNb = myDS->NumberOfInsertedShapes(), chShInd = 0;
2553           Standard_Boolean completeSearching = Standard_False;
2554           for(chShInd = 1; chShInd <= chShNb; chShInd++) {
2555             if(myDS->GetShapeType(chShInd) != TopAbs_VERTEX)
2556               continue;
2557             TopoDS_Vertex chV = TopoDS::Vertex(myDS->Shape(chShInd));
2558             Standard_Real distVV = BRep_Tool::Pnt(chV).Distance(BRep_Tool::Pnt(aNewVertex));
2559             if(distVV <= 1.e-5) {
2560               for(anIt1.Initialize(aPS.Set()); anIt1.More(); anIt1.Next()) {
2561                 if(anIt1.Value().Index() == chShInd) {
2562                   Standard_Real dParam = fabs(aPaveOnEdge.Param()-anIt1.Value().Param());
2563                   if(dParam <= 1.e-7) {
2564                     bAddNewVertex = Standard_False;
2565                     bAddOldVertex = Standard_True;
2566                     oldvertexindex = anIt1.Value().Index();
2567                     nvTol += BRep_Tool::Tolerance(chV) + distVV;
2568                     completeSearching = Standard_True;
2569                     break;
2570                   }
2571                 }
2572               }
2573             }
2574             if(completeSearching)
2575               break;
2576           }
2577           // -&&
2578
2579
2580           if(!bAddOldVertex) {
2581             BOPTools_Tools::MakeNewVertex(anEdge, aPaveOnEdge.Param(), 
2582                                           TopoDS::Face(aFace),  aNewVertex);
2583             BooleanOperations_AncestorsSeqAndSuccessorsSeq anASSeq; 
2584             myDS->InsertShapeAndAncestorsSuccessors(aNewVertex, anASSeq);
2585             aNewShapeIndex = myDS->NumberOfInsertedShapes();
2586           }
2587           else {
2588             aNewShapeIndex = oldvertexindex;
2589             aNewVertex = TopoDS::Vertex(myDS->Shape(aNewShapeIndex));
2590             BRep_Builder aBB;
2591             //
2592             aBB.UpdateVertex(aNewVertex, aPaveOnEdge.Param(), anEdge, nvTol);
2593           }
2594
2595           BOPTools_ListIteratorOfListOfPave anItAll;
2596           Standard_Boolean samePFound = Standard_False;
2597           for(anItAll.Initialize(aPS.Set()); anItAll.More(); anItAll.Next()) {
2598             if(anItAll.Value().Index() == aNewShapeIndex) {
2599               BOPTools_Pave& aPV = anItAll.Value();
2600               aPV.SetParam(aPaveOnEdge.Param());
2601               samePFound = Standard_True; 
2602               break;
2603             }
2604           }
2605           if(samePFound)
2606             continue;
2607
2608
2609           myDS->SetState (aNewShapeIndex, BooleanOperations_ON);
2610
2611           IntTools_CommonPrt aCPart;
2612           aCPart.SetEdge1(anEdge);
2613           aCPart.SetType(TopAbs_VERTEX);
2614           aCPart.SetRange1(IntTools_Range(aPaveOnEdge.Param(), aPaveOnEdge.Param()));
2615           aCPart.SetVertexParameter1(aPaveOnEdge.Param());
2616
2617           Standard_Integer nFOpposite = (bIsOnFirst) ? nF2 : nF1;
2618           BOPTools_ESInterference anInterf (nE, nFOpposite, aCPart);
2619           Standard_Integer anIndexIn = aESs.Append(anInterf);
2620           myIntrPool->AddInterference (nE, nFOpposite, BooleanOperations_EdgeSurface, anIndexIn);
2621
2622           BOPTools_ESInterference& aESInterf = aESs(anIndexIn);
2623           aESInterf.SetNewShape(aNewShapeIndex);
2624
2625           // put pave on edge. begin 
2626           aPaveOnEdge.SetInterference(anIndexIn);
2627           aPaveOnEdge.SetType (BooleanOperations_EdgeSurface);
2628           aPaveOnEdge.SetIndex(aNewShapeIndex);
2629
2630           BOPTools_PaveSet& aPaveSet1 = myPavePoolNew(myDS->RefEdge(nE));
2631           aPaveSet1.Append(aPaveOnEdge);
2632           // put pave on edge. end
2633
2634           // put pave on curve. begin 
2635           aPaveOnCurve.SetIndex(aNewShapeIndex);
2636           aPaveOnCurve.SetType(BooleanOperations_SurfaceSurface);
2637           BOPTools_PaveSet& aPaveSet = theBC.Set();
2638           aPaveSet.Append(aPaveOnCurve);
2639
2640           BOPTools_Tools::UpdateVertex (theBC.Curve(), aPaveOnCurve.Param(), aNewVertex);
2641
2642           // put pave on curve. end
2643
2644           BOPTools_ListOfCommonBlock& aLCB1 = myCommonBlockPool(myDS->RefEdge(nE));
2645
2646           BOPTools_ListIteratorOfListOfCommonBlock  anIt(aLCB1);
2647
2648           for(; anIt.More(); anIt.Next()) {
2649             BOPTools_CommonBlock& aCB = anIt.Value();
2650
2651             if(aCB.Face()) {
2652               continue;
2653             }
2654
2655             Standard_Integer anOppIndex = aCB.PaveBlock2().OriginalEdge();
2656             IntTools_Range aRange = aCB.PaveBlock2().Range();
2657
2658             if(anOppIndex == nE) {
2659               anOppIndex = aCB.PaveBlock1().OriginalEdge();
2660               aRange = aCB.PaveBlock1().Range();
2661             }
2662             TopoDS_Edge anOppEdge = TopoDS::Edge(myDS->Shape(anOppIndex));
2663             Standard_Real aOppParameter = 0.;
2664
2665             if(myContext->ComputeVE(aNewVertex, anOppEdge, aOppParameter) == 0) {
2666             
2667               if((aOppParameter > aRange.First()) && (aOppParameter < aRange.Last())) {
2668                 // put pave on same domain edge. begin
2669                 BRep_Builder aBB;
2670                 aBB.UpdateVertex(aNewVertex, aOppParameter, anOppEdge, BRep_Tool::Tolerance(aNewVertex));
2671                 BOPTools_Pave aPaveOpp;
2672                 aPaveOpp.SetParam(aOppParameter);
2673                 aPaveOpp.SetIndex(aNewShapeIndex);
2674                 BOPTools_PaveSet& aPaveSetOpp = myPavePoolNew(myDS->RefEdge(anOppIndex));
2675                 aPaveSetOpp.Append(aPaveOpp);
2676                 // put pave on same domain edge. end
2677               }
2678             }
2679           }
2680
2681           // add SS interference for adjacent face.begin
2682           if(aLCB1.IsEmpty()) {
2683             AddInterfForAdjacentFace(nE, nF1, nF2, myIntrPool, myDS);
2684           }
2685           // add SS interference for adjacent face.end
2686
2687           RefinePavePool();
2688           myPavePoolNew.Resize(myNbEdges);
2689           //
2690
2691           RecomputeCommonBlocks(nE);
2692
2693         }
2694       } // end for(; aPaveIt1.More() && aPaveIt2.More()...
2695       // add paves chaking if new pave is equal to existent. end
2696     }
2697   } //(bSearchInter)
2698   myPavePoolNew.Destroy();
2699 }
2700 //=======================================================================
2701 //function : RecomputeCommonBlocks
2702 //purpose  : 
2703 //=======================================================================
2704   void BOPTools_PaveFiller::RecomputeCommonBlocks(const Standard_Integer nE) 
2705 {
2706   TopoDS_Shape atmpShape = myDS->Shape(nE);
2707   TopoDS_Edge  anEdge   = TopoDS::Edge(atmpShape);
2708   BOPTools_ListOfCommonBlock& aLCB1 = myCommonBlockPool(myDS->RefEdge(nE));
2709
2710   BOPTools_ListOfCommonBlock anOldLCB;
2711   anOldLCB = aLCB1;
2712   aLCB1.Clear();
2713   BOPTools_ListOfCommonBlock aNewLCB1;
2714   Standard_Boolean bReverse = Standard_False;
2715   BOPTools_ListIteratorOfListOfCommonBlock  anIt(anOldLCB);
2716
2717   for(; anIt.More(); anIt.Next()) {
2718     BOPTools_CommonBlock& anOldCB = anIt.Value();
2719
2720     Standard_Integer anIndex = anOldCB.PaveBlock1().OriginalEdge();
2721     Standard_Integer anIndexOpp = anOldCB.PaveBlock2().OriginalEdge();
2722     IntTools_Range aCBRange = anOldCB.PaveBlock1().Range();
2723
2724     if(anIndex != nE) {
2725       aCBRange = anOldCB.PaveBlock2().Range();
2726       anIndex = anOldCB.PaveBlock2().OriginalEdge();
2727       anIndexOpp = anOldCB.PaveBlock1().OriginalEdge();
2728       bReverse = Standard_True;
2729     }
2730
2731     BOPTools_ListOfPaveBlock& aSplitEdges1 = mySplitShapesPool(myDS->RefEdge(nE));
2732     BOPTools_ListIteratorOfListOfPaveBlock aLPBIt1(aSplitEdges1);
2733     Standard_Boolean found = Standard_False;
2734     BOPTools_ListOfCommonBlock aNewListOfCommonBlock;
2735
2736     for(; aLPBIt1.More(); aLPBIt1.Next()) {
2737       BOPTools_PaveBlock& aPBCurrent1 = aLPBIt1.Value();
2738       IntTools_Range aCurRange1 = aPBCurrent1.Range();
2739
2740       if((aCurRange1.First() > aCBRange.First() && aCurRange1.First() < aCBRange.Last()) ||
2741          (aCurRange1.Last() > aCBRange.First() && aCurRange1.Last() < aCBRange.Last())) {
2742         BOPTools_CommonBlock aNewCB;
2743
2744         if(!bReverse)
2745           aNewCB.SetPaveBlock1(aPBCurrent1);
2746         else
2747           aNewCB.SetPaveBlock2(aPBCurrent1);
2748
2749         Standard_Boolean foundpaveblock2 = Standard_False;
2750
2751         if(anOldCB.Face()) {
2752           foundpaveblock2 = Standard_True;
2753           aNewCB.SetFace(anOldCB.Face());
2754         }
2755         else {
2756           if(anIndexOpp <= 0)
2757             continue;
2758           BOPTools_ListIteratorOfListOfPaveBlock aLPBIt2(mySplitShapesPool(myDS->RefEdge(anIndexOpp)));
2759
2760           for(; aLPBIt2.More(); aLPBIt2.Next()) {
2761             BOPTools_PaveBlock& aPBCurrent2 = aLPBIt2.Value();
2762             IntTools_Range aCurRange2 = aPBCurrent2.Range();
2763
2764             if(((aPBCurrent1.Pave1().Index() == aPBCurrent2.Pave1().Index()) && 
2765                 (aPBCurrent1.Pave2().Index() == aPBCurrent2.Pave2().Index())) ||
2766                ((aPBCurrent1.Pave1().Index() == aPBCurrent2.Pave2().Index()) && 
2767                 (aPBCurrent1.Pave2().Index() == aPBCurrent2.Pave1().Index()))) {
2768               Standard_Real f = 0., l = 0.;
2769               Handle(Geom_Curve) aCurve = BRep_Tool::Curve(anEdge, f, l);
2770               Standard_Real aMidPar = (aCurRange1.First() + aCurRange1.Last()) * 0.5;
2771               gp_Pnt aMidPnt = aCurve->Value(aMidPar);
2772               Standard_Real aProjPar = 0.;
2773               TopoDS_Vertex aTestpVertex;
2774               TopoDS_Edge aOppEdge = TopoDS::Edge(myDS->Shape(anIndexOpp));
2775               BRep_Builder aBB;
2776               aBB.MakeVertex(aTestpVertex, aMidPnt, BRep_Tool::Tolerance(anEdge));
2777
2778               if(myContext->ComputeVE(aTestpVertex, aOppEdge, aProjPar) == 0) {
2779                 if(aProjPar > aCurRange2.First() && aProjPar < aCurRange2.Last()) {
2780                   if(!bReverse)
2781                     aNewCB.SetPaveBlock2(aPBCurrent2);
2782                   else
2783                     aNewCB.SetPaveBlock1(aPBCurrent2);
2784                   foundpaveblock2 = Standard_True;
2785                   break;
2786                 }
2787               }
2788             }
2789           }
2790         }
2791
2792         if(foundpaveblock2) {
2793           found = Standard_True;
2794           aNewListOfCommonBlock.Append(aNewCB);
2795         }
2796       }
2797     }
2798     // end for(; aLPBIt1.More()...
2799
2800     if(!found) {
2801       aNewLCB1.Append(anOldCB);
2802     }
2803     else {
2804       BOPTools_ListOfCommonBlock tmplst;
2805       tmplst = aNewListOfCommonBlock;
2806       aNewLCB1.Append(tmplst);
2807
2808       if((anOldCB.Face() == 0) && (anIndexOpp > 0)) {
2809         tmplst = aNewListOfCommonBlock;
2810         BOPTools_ListOfCommonBlock& aLCB2 = myCommonBlockPool(myDS->RefEdge(anIndexOpp));
2811
2812         BOPTools_ListIteratorOfListOfCommonBlock anItLCB2(aLCB2);
2813
2814         for(; anItLCB2.More(); anItLCB2.Next()) {
2815           BOPTools_CommonBlock& anOldCB2 = anItLCB2.Value();
2816
2817           if(anOldCB2.Face())
2818             continue;
2819
2820           if(anOldCB.PaveBlock1().IsEqual(anOldCB2.PaveBlock1()) &&
2821              anOldCB.PaveBlock2().IsEqual(anOldCB2.PaveBlock2())) {
2822             aLCB2.Remove(anItLCB2);
2823             aLCB2.Append(tmplst);
2824             break;
2825           }
2826         }
2827       }
2828     }
2829   }
2830   // end for(; anIt.More()...
2831   aLCB1 = aNewLCB1;
2832 }
2833 //=======================================================================
2834 //function : CheckNewVertexAndUpdateData
2835 //purpose  : 
2836 //=======================================================================
2837 Standard_Boolean CheckNewVertexAndUpdateData(const TopoDS_Vertex&              theVertex,
2838                                              const Standard_Real               theParamOnE,
2839                                              const TopoDS_Edge&                theEdge,
2840                                              const Standard_Real               theParamOnCurve,
2841                                              const Standard_Integer            theIndexF1,
2842                                              const Standard_Integer            theIndexF2,
2843                                              const Standard_Real               theTolerance,
2844                                              const BOPTools_PInterferencePool& theIntrPool,
2845                                              const BooleanOperations_PShapesDataStructure& theDS,
2846                                              const Handle(IntTools_Context)&   theContext,
2847                                              const BOPTools_PaveSet&           theEdgePaveSet,
2848                                              const Standard_Boolean            bAddNewVertex,
2849                                              const Standard_Boolean            bAddOldVertex,
2850                                              BOPTools_Curve&                   theBC,
2851                                              BOPTools_Pave&                    thePaveToPut,
2852                                              Standard_Boolean&                 bAddNewVertexOut,
2853                                              Standard_Boolean&                 bAddOldVertexOut) {
2854
2855   thePaveToPut.SetParam(0.);
2856   thePaveToPut.SetIndex(0);
2857   thePaveToPut.SetInterference(0);
2858
2859   bAddNewVertexOut = bAddNewVertex;
2860   bAddOldVertexOut = bAddOldVertex;
2861   TopoDS_Shape atmpShape;
2862   gp_Pnt aP1 = theBC.Curve().Curve()->Value(theParamOnCurve);
2863   Standard_Real f = 0., l = 0.;
2864   Handle(Geom_Curve) aCurve = BRep_Tool::Curve(theEdge, f, l);
2865
2866   if(aCurve.IsNull())
2867     return Standard_False;
2868   gp_Pnt aP2 = aCurve->Value(theParamOnE);
2869
2870   BOPTools_ListIteratorOfListOfPave anIt1, anIt2;
2871
2872   for(anIt1.Initialize(theEdgePaveSet.Set()); anIt1.More(); anIt1.Next()) {
2873     atmpShape = theDS->Shape(anIt1.Value().Index());
2874     TopoDS_Vertex aVertex = TopoDS::Vertex(atmpShape);
2875     gp_Pnt aPoint = BRep_Tool::Pnt(aVertex);
2876     Standard_Real aTolerance = theTolerance + BRep_Tool::Tolerance(aVertex);
2877     aTolerance *= 4.;
2878
2879     if((aPoint.Distance(aP1) < aTolerance) ||
2880        (aPoint.Distance(aP2) < aTolerance)) {
2881       IntTools_Range aRange(anIt1.Value().Param(), theParamOnE);
2882       TopoDS_Vertex aV1 = aVertex;
2883       TopoDS_Vertex aV2 = theVertex;
2884
2885       if(anIt1.Value().Param() > theParamOnE) {
2886         aRange.SetFirst(theParamOnE);
2887         aRange.SetLast(anIt1.Value().Param());
2888         aV1 = theVertex;
2889         aV2 = aVertex;
2890       }
2891       gp_Pnt ptest1 = aCurve->Value(aRange.First());
2892       gp_Pnt ptest2 = aCurve->Value(aRange.Last());
2893       Standard_Boolean bUpdateVertex = Standard_True;
2894
2895       if(ptest1.Distance(ptest2) > (BRep_Tool::Tolerance(aVertex) + BRep_Tool::Tolerance(theEdge))) {
2896         IntTools_ShrunkRange aSR (theEdge, aV1, aV2, aRange, theContext);
2897         bUpdateVertex = !aSR.IsDone() || (aSR.ErrorStatus() != 0);
2898       }
2899
2900       if(bUpdateVertex) {
2901         bAddNewVertexOut = Standard_False;
2902               
2903         if(bAddOldVertexOut) {
2904           bAddOldVertexOut = Standard_False;
2905           break;
2906         }
2907         BOPTools_Tools::UpdateVertex (theBC.Curve(), theParamOnCurve, aVertex);
2908
2909         Standard_Boolean bPutPave = Standard_True;
2910
2911         for(anIt2.Initialize(theBC.Set().Set()); anIt2.More(); anIt2.Next()) {
2912           if(anIt1.Value().Index() == anIt2.Value().Index()) {
2913             bPutPave = Standard_False;
2914             break;
2915           }
2916         }
2917
2918         Standard_Integer nbbefore = theBC.Set().Set().Extent();
2919
2920         if(bPutPave) {
2921           thePaveToPut = anIt1.Value();
2922         }
2923
2924         if(anIt1.Value().Index() > theDS->NumberOfSourceShapes())
2925           break;
2926
2927         Standard_Integer nbafter = theBC.Set().Set().Extent();
2928
2929         if(nbbefore < nbafter) {
2930           // update interferences.begin
2931           Standard_Integer nF = theIndexF1;
2932
2933           if(theDS->Rank(anIt1.Value().Index()) != theDS->Rank(theIndexF1)) {
2934             nF = theIndexF2;
2935           }
2936           atmpShape = theDS->Shape(nF);
2937           TopoDS_Face   aF = TopoDS::Face  (atmpShape);
2938           BOPTools_CArray1OfVSInterference& aVSs = theIntrPool->VSInterferences();
2939           Standard_Integer vsit = 0;
2940           Standard_Boolean interffound = Standard_False;
2941
2942           for(vsit = 1; vsit <= aVSs.Length(); vsit++) {
2943             if((aVSs.Value(vsit).Index1() == anIt1.Value().Index()) &&
2944                (aVSs.Value(vsit).Index2() == nF)) {
2945               interffound = Standard_True;
2946               break;
2947             }
2948           }
2949
2950           if(!interffound) {
2951             BOPTools_CArray1OfVEInterference& aVEs = theIntrPool->VEInterferences();
2952
2953             for(vsit = 1; vsit <= aVEs.Length(); vsit++) {
2954               if((aVEs.Value(vsit).Index1() == anIt1.Value().Index())) {
2955                 interffound = Standard_True;
2956                 break;
2957               }
2958             }
2959           }
2960
2961           if(!interffound) {
2962             BOPTools_CArray1OfVVInterference& aVVs = theIntrPool->VVInterferences();
2963
2964             for(vsit = 1; vsit <= aVVs.Length(); vsit++) {
2965               if((aVVs.Value(vsit).Index1() == anIt1.Value().Index())) {
2966                 interffound = Standard_True;
2967                 break;
2968               }
2969             }
2970           }
2971
2972           if(!interffound) {
2973             Standard_Real aU = 0., aV = 0.;
2974             Standard_Integer aFlag = theContext->ComputeVS (aVertex, aF, aU, aV);
2975             Standard_Integer anIndexIn = 0;
2976
2977             if (!aFlag) {
2978               //
2979               // Add Interference to the Pool
2980               BOPTools_VSInterference anInterf (anIt1.Value().Index(), nF, aU, aV);
2981               anIndexIn=aVSs.Append(anInterf);
2982               //
2983               // SetState for Vertex in DS;
2984               theDS->SetState (anIt1.Value().Index(), BooleanOperations_ON);
2985               // Insert Vertex in Interference Object
2986               BOPTools_VSInterference& aVS = aVSs(anIndexIn);
2987               aVS.SetNewShape(anIt1.Value().Index());
2988
2989               interffound = Standard_False;
2990               const BOPTools_ListOfInterference& aList1 =
2991                 theIntrPool->InterferenceTable().Value(anIt1.Value().Index()).GetOnType(BooleanOperations_EdgeSurface);
2992               BOPTools_ListOfInterference& amodifList1 = *((BOPTools_ListOfInterference*)&aList1); // not very good approach
2993               BOPTools_ListIteratorOfListOfInterference anInterfIt(amodifList1);
2994
2995               for(; anInterfIt.More(); anInterfIt.Next()) {
2996                 if(anInterfIt.Value().With() == nF) {
2997                   anInterfIt.Value().SetIndex(anIndexIn);
2998                   interffound = Standard_True;
2999                 }
3000               }
3001               const BOPTools_ListOfInterference& aList2 =
3002                 theIntrPool->InterferenceTable().Value(nF).GetOnType(BooleanOperations_EdgeSurface);
3003               BOPTools_ListOfInterference& amodifList2 = *((BOPTools_ListOfInterference*)&aList2); // not very good approach
3004               anInterfIt.Initialize(amodifList2);
3005
3006               for(; anInterfIt.More(); anInterfIt.Next()) {
3007                 if(anInterfIt.Value().With() == anIt1.Value().Index()) {
3008                   anInterfIt.Value().SetIndex(anIndexIn);
3009                   interffound = Standard_True;
3010                 }
3011               }
3012                       
3013               if(!interffound)
3014                 theIntrPool->AddInterference(anIt1.Value().Index(), nF, BooleanOperations_VertexSurface, anIndexIn);
3015             }
3016           }
3017           // update interferences.end
3018         }
3019         break;
3020       }
3021     }
3022   }
3023   // end for(anIt1.Initialize...
3024   return Standard_True;
3025 }
3026 //=======================================================================
3027 //function : AddInterfForAdjacentFace
3028 //purpose  : 
3029 //=======================================================================
3030 void AddInterfForAdjacentFace(const Standard_Integer            theEdgeIndex,
3031                               const Standard_Integer            theIndexF1,
3032                               const Standard_Integer            theIndexF2,
3033                               BOPTools_PInterferencePool        theIntrPool,
3034                               const BooleanOperations_PShapesDataStructure& theDS) {
3035   Standard_Boolean bIsOnFirst = (theDS->Rank(theEdgeIndex) == 1);
3036
3037   IntTools_SequenceOfPntOn2Faces aPnts;
3038   IntTools_SequenceOfCurves aCvs;
3039   Standard_Integer index1 = (bIsOnFirst) ? theIndexF1 : theIndexF2;
3040   Standard_Integer index2 = (bIsOnFirst) ? theIndexF2 : theIndexF1;
3041   Standard_Integer nbw = theDS->NumberOfAncestors(theEdgeIndex);
3042   Standard_Integer ancwit = 0, ancfit = 0;
3043   Standard_Boolean badjacentfound = Standard_False;
3044
3045   for(ancwit = 1; (!badjacentfound) && (ancwit <= nbw); ancwit++) {
3046     Standard_Integer ancestor1 = theDS->GetAncestor(theEdgeIndex, ancwit);
3047
3048     if(ancestor1 == index1)
3049       continue;
3050
3051     if(theDS->GetShapeType(ancestor1) == TopAbs_WIRE) {
3052       Standard_Integer nbf = theDS->NumberOfAncestors(ancestor1);
3053
3054       for(ancfit = 1; ancfit <= nbf; ancfit++) {
3055         Standard_Integer ancestor2 = theDS->GetAncestor(ancestor1, ancfit);
3056
3057         if(ancestor2 != index1) {
3058           index1 = ancestor2;
3059           badjacentfound = Standard_True;
3060           break;
3061         }
3062       }
3063     }
3064   }
3065
3066   if(index1 > index2) {
3067     Standard_Integer tmp = index1;
3068     index1 = index2;
3069     index2 = tmp;
3070   }
3071   Standard_Boolean bAddInterference = Standard_True;
3072   Standard_Integer ffit = 0;
3073   BOPTools_CArray1OfSSInterference& aFFs = theIntrPool->SSInterferences();
3074
3075   for(ffit = 1; ffit <= aFFs.Extent(); ffit++) {
3076     BOPTools_SSInterference& aFFi3 = aFFs(ffit);
3077
3078     if((index1 == aFFi3.Index1()) && (index2 == aFFi3.Index2())) {
3079       bAddInterference = Standard_False;
3080     }
3081   }
3082
3083   if(bAddInterference) {
3084     BOPTools_SSInterference anInterfSS (index1, index2, 1.e-07, 1.e-07, aCvs, aPnts);
3085     Standard_Integer anIndexInSS = aFFs.Append(anInterfSS);
3086     theIntrPool->AddInterference (index1, index2, BooleanOperations_SurfaceSurface, anIndexInSS); 
3087   }
3088 }
3089
3090 //=======================================================================
3091 //function : RejectPaveBlock
3092 //purpose  : 
3093 //=======================================================================
3094 Standard_Boolean RejectPaveBlock(const IntTools_Curve& theC,
3095                                  const Standard_Real   theT1,
3096                                  const Standard_Real   theT2,
3097                                  const TopoDS_Vertex&  theV,
3098                                  Standard_Real&        theRT)
3099 {
3100   Standard_Boolean bIsPeriodic, bClosed, isp, c3d;
3101   Standard_Real aPeriod, dt, pf, pl, dp, aTol;
3102   Handle(Geom_Curve) aC;
3103   //
3104   theRT = BRep_Tool::Tolerance(theV);
3105   aC = theC.Curve();
3106   //
3107   pf = aC->FirstParameter();
3108   pl = aC->LastParameter();
3109   dp = fabs(pl-pf);
3110   aTol=1.e-9;
3111   bIsPeriodic=aC->IsPeriodic();
3112   bClosed=IntTools_Tools::IsClosed(aC);
3113   //
3114   isp=Standard_False;
3115   if (bIsPeriodic) {
3116     aPeriod=aC->Period();
3117     isp=(fabs(aPeriod-dp) <= aTol);
3118     dt = fabs(theT2-theT1);
3119     isp = (isp ||  fabs(aPeriod-dt) <= aTol);
3120   }
3121   c3d=(bClosed || isp);
3122   //
3123   /*
3124   Standard_Boolean isp = (aC->IsPeriodic() && fabs(aC->Period()-dp) <= 1.e-9);
3125   Standard_Real dt = fabs(theT2-theT1);
3126   isp = (isp || (aC->IsPeriodic() && fabs(aC->Period()-dt) <= 1.e-9));
3127   Standard_Boolean c3d = (aC->IsClosed() || isp);
3128   */
3129   if(c3d) {
3130     return !c3d;
3131   }
3132   //
3133   Standard_Real p1, p2, tp, d3d2, aRT2;;
3134   //
3135   p1 = Max(pf,theT1);
3136   p2 = Min(pl,theT2);
3137   if(p2 != p1) {
3138     if(p2 < p1) {
3139       tp = p1; 
3140       p1 = p2; 
3141       p2 = tp;
3142     }
3143     gp_Pnt pntf, pntl;
3144     aC->D0(p1,pntf);
3145     aC->D0(p2,pntl);
3146     //
3147     aRT2=theRT*theRT;
3148     d3d2 = pntf.SquareDistance(pntl);
3149     if(d3d2 > aRT2) {
3150       theRT=sqrt(d3d2);
3151     }
3152   }
3153   return Standard_True;
3154 }
3155
3156 //=======================================================================
3157 //function : ModifFFTol
3158 //purpose  : 
3159 //=======================================================================
3160 Standard_Boolean ModifFFTol(const TopoDS_Face& theF1,
3161                             const TopoDS_Face& theF2,
3162                             Standard_Real&     theTF)
3163 {
3164   Standard_Real t1 = BRep_Tool::Tolerance(theF1), t2 = BRep_Tool::Tolerance(theF2);
3165   theTF = 2* (t1 + t2);
3166   BRepAdaptor_Surface BAS1(theF1);
3167   BRepAdaptor_Surface BAS2(theF2);
3168   
3169   Standard_Boolean isAna1 = (BAS1.GetType() == GeomAbs_Plane ||
3170                              BAS1.GetType() == GeomAbs_Cylinder ||
3171                              BAS1.GetType() == GeomAbs_Cone ||
3172                              BAS1.GetType() == GeomAbs_Sphere);
3173   Standard_Boolean isAna2 = (BAS2.GetType() == GeomAbs_Plane ||
3174                              BAS2.GetType() == GeomAbs_Cylinder ||
3175                              BAS2.GetType() == GeomAbs_Cone ||
3176                              BAS2.GetType() == GeomAbs_Sphere);
3177
3178   isAna1=isAna1||(BAS1.GetType() == GeomAbs_Torus);
3179   isAna2=isAna2||(BAS2.GetType() == GeomAbs_Torus);
3180
3181   if(isAna1 && isAna2)
3182     return Standard_False;
3183
3184   theTF = Max(theTF, 5.e-6);
3185   return Standard_True;
3186 }
3187
3188
3189 //=======================================================================
3190 //function : RejectBuildingEdge
3191 //purpose  : 
3192 //=======================================================================
3193 Standard_Integer RejectBuildingEdge(const IntTools_Curve& theC,
3194                                     const TopoDS_Vertex&  theV1,
3195                                     const TopoDS_Vertex&  theV2,
3196                                     const Standard_Real   theT1,
3197                                     const Standard_Real   theT2,
3198                                     const TopTools_ListOfShape& theL,
3199                                     Standard_Real&        theTF)
3200 {
3201   theTF = 1.e-7;
3202   if(theL.Extent() == 0)
3203     return 0;
3204
3205   Handle(Geom_Curve) aTCurve;
3206   Standard_Real aTT;
3207   
3208   Standard_Integer eIndex = 0;
3209   Standard_Boolean edgeFound = Standard_False;
3210   Handle(Geom_Curve) aCurve = theC.Curve();
3211   TopTools_ListIteratorOfListOfShape anIt(theL);
3212   for(; anIt.More(); anIt.Next()) {
3213     eIndex++;
3214     const TopoDS_Edge & aE = TopoDS::Edge(anIt.Value());
3215     if(aE.IsNull()) continue;
3216     TopExp_Explorer ee(aE,TopAbs_VERTEX);
3217     Standard_Boolean v1Found = Standard_False;
3218     Standard_Boolean v2Found = Standard_False;
3219     Standard_Real v1P = 0., v2P = 0;
3220     for(; ee.More(); ee.Next()) {
3221       const TopoDS_Vertex aV = TopoDS::Vertex(ee.Current());
3222       if(aV.IsNull()) continue;
3223       if(aV.IsEqual(theV1)) {
3224         v1Found = Standard_True;
3225         v1P = BRep_Tool::Parameter(aV,aE);
3226       }
3227       if(aV.IsEqual(theV2)) {
3228         v2Found = Standard_True;
3229         v2P = BRep_Tool::Parameter(aV,aE);
3230       }
3231     }
3232     Standard_Boolean sameParam = Standard_False;
3233     if(v1Found && v2Found) {
3234       if(fabs(theT1-v1P) <= 1.e-8 && fabs(theT2-v2P) <= 1.e-8)
3235         sameParam = Standard_True;
3236     }
3237     if(sameParam) {
3238       Standard_Real f,l;
3239       aTCurve = BRep_Tool::Curve(aE,f,l);
3240       aTT = BRep_Tool::Tolerance(aE);
3241       edgeFound = Standard_True;
3242     }
3243     if(edgeFound)
3244       break;
3245   }
3246
3247   if(!edgeFound)
3248     return 0;
3249
3250   gp_Pnt p1 = aTCurve->Value(theT1);
3251   gp_Pnt p2 = aCurve->Value(theT1);
3252   Standard_Real dpf = p1.Distance(p2);
3253   p1 = aTCurve->Value(theT2);
3254   p2 = aCurve->Value(theT2);
3255   Standard_Real dpl = p1.Distance(p2);
3256   Standard_Real dplf = fabs(dpl-dpf);
3257   Standard_Real dpp = Max(dpl,dpf);
3258
3259   if(dplf > 1.e-7)
3260     return 0;
3261
3262   Standard_Real maxD = Max(dpl,dpf);
3263   Standard_Boolean inTol = Standard_True;
3264   Standard_Real dp = fabs(theT2-theT1)/23.;
3265   Standard_Integer di = 0;
3266   for(di = 1; di <= 21; di++) {
3267     Standard_Real cp = theT1 + dp*((Standard_Real)di);
3268     p1 = aTCurve->Value(cp);
3269     p2 = aCurve->Value(cp);
3270     Standard_Real d12 = p1.Distance(p2);
3271     maxD = Max(maxD,d12);
3272     if(fabs(d12-dpp) > 1.e-7) {
3273       inTol = Standard_False;
3274       break;
3275     }
3276   }
3277
3278   if(!inTol)
3279     return 0;
3280
3281   theTF = maxD;
3282   return eIndex;
3283 }
3284 //=======================================================================
3285 //function : CorrectTolR3D
3286 //purpose  : 
3287 //=======================================================================
3288 void CorrectTolR3D(BOPTools_PaveFiller& aPF,
3289                    const BOPTools_SSInterference& aFF,
3290                    const TColStd_MapOfInteger& aMVStick,
3291                    Standard_Real& aTolR3D)
3292 {
3293   Standard_Boolean bHasBounds;
3294   Standard_Integer i, nF[2], nV, aNbCurves;
3295   Standard_Real aT1, aT2, aU, aV, aT, aA, aTolV, aTolVmax;
3296   Standard_Real aTolR, aTolTresh, aAmin, aAmax;
3297   TColStd_MapIteratorOfMapOfInteger aIt;
3298   gp_Pnt aP, aP1, aP2;
3299   gp_Dir aDN[2];
3300   gp_Vec aVT;
3301   Handle(Geom_Surface) aS[2];
3302   Handle(Geom_Curve) aC3D;
3303   GeomAdaptor_Surface aGAS;
3304   GeomAbs_SurfaceType aType;
3305   TopoDS_Face aF[2];
3306   //
3307   BooleanOperations_PShapesDataStructure myDS=aPF.DS();
3308   const Handle(IntTools_Context)& myContext=aPF.Context();
3309   //
3310   aTolTresh=0.0005;
3311   aAmin=0.012;// 0.7-7 deg
3312   aAmax=0.12;
3313   //
3314   if (!aMVStick.Extent()) {
3315     return;
3316   }
3317   //
3318   BOPTools_SSInterference& aFFi=*((BOPTools_SSInterference*)&aFF);
3319   BOPTools_SequenceOfCurves& aSCvs=aFFi.Curves();
3320   aNbCurves=aSCvs.Length();
3321   if (aNbCurves!=1){
3322     return;
3323   }
3324   //
3325   aFFi.Indices(nF[0], nF[1]);
3326   for (i=0; i<2; ++i) {
3327     aF[i]=*((TopoDS_Face*)(&myDS->Shape(nF[i])));
3328     aS[i]=BRep_Tool::Surface(aF[i]);
3329     aGAS.Load(aS[i]);
3330     aType=aGAS.GetType();
3331     if (aType!=GeomAbs_BSplineSurface) {
3332       return;
3333     }
3334   }
3335   //
3336   BOPTools_Curve& aBC=aSCvs(1);
3337   const IntTools_Curve& aIC=aBC.Curve();
3338   bHasBounds=aIC.HasBounds();
3339   if (!bHasBounds){
3340     return;
3341   }
3342   //
3343   aIC.Bounds (aT1, aT2, aP1, aP2);
3344   aT=IntTools_Tools::IntermediatePoint(aT1, aT2);
3345   aC3D=aIC.Curve();
3346   aC3D->D0(aT, aP);
3347   //
3348   for (i=0; i<2; ++i) {
3349     GeomAPI_ProjectPointOnSurf& aPPS=myContext->ProjPS(aF[i]);
3350     aPPS.Perform(aP);
3351     aPPS.LowerDistanceParameters(aU, aV);
3352     BOPTools_Tools3D::GetNormalToSurface(aS[i], aU, aV, aDN[i]);
3353   }
3354   //
3355   aA=aDN[0].Angle(aDN[1]);
3356   aA=fabs(aA);
3357   if (aA>0.5*M_PI) {
3358     aA=M_PI-aA;
3359   }
3360   //
3361   if (aA<aAmin || aA>aAmax) {
3362     return;
3363   }
3364   //
3365   aTolVmax=-1.;
3366   aIt.Initialize(aMVStick);
3367   for (; aIt.More(); aIt.Next()) {
3368     nV=aIt.Key();
3369     const TopoDS_Vertex& aV=*((TopoDS_Vertex*)(&myDS->Shape(nV)));
3370     aTolV=BRep_Tool::Tolerance(aV);
3371     if (aTolV>aTolVmax) {
3372       aTolVmax=aTolV;
3373     }
3374   }
3375   //
3376   aTolR=aTolVmax/aA;
3377   if (aTolR<aTolTresh) {
3378     aTolR3D=aTolR;
3379   }
3380 }
3381 //=======================================================================
3382 // function: PutClosingPaveOnCurve
3383 // purpose:
3384 //=======================================================================
3385 void BOPTools_PaveFiller::PutClosingPaveOnCurve(BOPTools_Curve& aBC,
3386                                                 BOPTools_SSInterference& aFFi)
3387 {
3388   Standard_Boolean bIsClosed, bHasBounds, bAdded;
3389   Standard_Integer nVC, j;
3390   Standard_Real aT[2], aTolR3D, aTC, dT, aTx;
3391   gp_Pnt aP[2] ; 
3392   BOPTools_Pave aPVx;
3393   BOPTools_ListIteratorOfListOfPave aItLP;
3394   //
3395   const IntTools_Curve& aIC=aBC.Curve();
3396   const Handle (Geom_Curve)& aC3D=aIC.Curve();
3397   if(aC3D.IsNull()) {
3398     return;
3399   }
3400   //
3401   bIsClosed=IntTools_Tools::IsClosed(aC3D);