18b163103df5c61a642ac86ef6543fe88526227f
[occt.git] / src / BOPAlgo / BOPAlgo_PaveFiller_7.cxx
1 // Created by: Peter KURNEV
2 // Copyright (c) 2010-2014 OPEN CASCADE SAS
3 // Copyright (c) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
4 // Copyright (c) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, CEDRAT,
5 //                         EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 //
7 // This file is part of Open CASCADE Technology software library.
8 //
9 // This library is free software; you can redistribute it and/or modify it under
10 // the terms of the GNU Lesser General Public License version 2.1 as published
11 // by the Free Software Foundation, with special exception defined in the file
12 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
13 // distribution for complete text of the license and disclaimer of any warranty.
14 //
15 // Alternatively, this file may be used under the terms of Open CASCADE
16 // commercial license or contractual agreement.
17
18 #include <BOPAlgo_PaveFiller.ixx>
19
20 #include <NCollection_IncAllocator.hxx>
21
22 #include <Geom_RectangularTrimmedSurface.hxx>
23 #include <Geom_Plane.hxx>
24 #include <Geom_Surface.hxx>
25 #include <Geom_RectangularTrimmedSurface.hxx>
26
27 #include <TopoDS_Vertex.hxx>
28 #include <TopoDS_Edge.hxx>
29 #include <TopoDS_Face.hxx>
30
31 #include <BRepBndLib.hxx>
32
33 #include <BRep_Tool.hxx>
34 #include <BRep_Builder.hxx>
35
36 #include <TopExp.hxx>
37 #include <TopExp_Explorer.hxx>
38
39 #include <Geom_Curve.hxx>
40 #include <Geom_Surface.hxx>
41 #include <Geom2d_Curve.hxx>
42
43 #include <BOPCol_NCVector.hxx>
44 #include <BOPCol_Parallel.hxx>
45 #include <BOPCol_MapOfShape.hxx>
46
47 #include <BOPDS_VectorOfListOfPaveBlock.hxx>
48 #include <BOPDS_ListOfPaveBlock.hxx>
49 #include <BOPDS_PaveBlock.hxx>
50 #include <BOPDS_CommonBlock.hxx>
51 #include <BOPDS_Pave.hxx>
52 #include <BOPDS_ShapeInfo.hxx>
53 #include <BOPDS_MapOfPaveBlock.hxx>
54 #include <BOPDS_VectorOfInterfFF.hxx>
55 #include <BOPDS_Interf.hxx>
56 #include <BOPDS_VectorOfCurve.hxx>
57 #include <BOPDS_VectorOfFaceInfo.hxx>
58 #include <BOPDS_FaceInfo.hxx>
59 #include <BOPDS_MapOfPaveBlock.hxx>
60 #include <BOPDS_Curve.hxx>
61 #include <BOPDS_Iterator.hxx>
62
63 #include <BOPTools_AlgoTools.hxx>
64 #include <BOPTools_AlgoTools2D.hxx>
65
66 static
67   Standard_Boolean IsBasedOnPlane(const TopoDS_Face& aF);
68
69
70 static void UpdateVertices(const TopoDS_Edge& aE, 
71                            const TopoDS_Face& aF);
72
73 //=======================================================================
74 //class    : BOPAlgo_SplitEdge
75 //purpose  : 
76 //=======================================================================
77 class BOPAlgo_SplitEdge : public BOPAlgo_Algo  {
78  
79  public:
80   DEFINE_STANDARD_ALLOC
81
82   BOPAlgo_SplitEdge() :
83     BOPAlgo_Algo() {
84     myT1=0.;
85     myT2=0.;
86   }
87   //
88   virtual ~BOPAlgo_SplitEdge() {
89   }
90   //
91   void SetData(const TopoDS_Edge& aE,
92                const TopoDS_Vertex& aV1,
93                const Standard_Real aT1,
94                const TopoDS_Vertex& aV2,
95                const Standard_Real aT2) {
96     myE=aE;
97     myV1=aV1;
98     myT1=aT1;
99     myV2=aV2;
100     myT2=aT2;
101     myESp=aE;
102   }
103   //
104   void SetPaveBlock(const Handle(BOPDS_PaveBlock)& aPB) {
105     myPB=aPB;
106   }
107   //
108   Handle(BOPDS_PaveBlock)& PaveBlock() {
109     return myPB;
110   }
111   //
112   void SetCommonBlock(const Handle(BOPDS_CommonBlock)& aCB) {
113     myCB=aCB;
114   }
115   //
116   Handle(BOPDS_CommonBlock)& CommonBlock() {
117     return myCB;
118   }
119   //
120   const TopoDS_Edge& SplitEdge() const {
121     return myESp;
122   }
123   //
124   const Bnd_Box Box() {
125     return myBox;
126   }
127   //
128   virtual void Perform () {
129     BOPAlgo_Algo::UserBreak();
130     BOPTools_AlgoTools::MakeSplitEdge(myE, 
131                                       myV1, myT1, 
132                                       myV2, myT2, 
133                                       myESp);
134     BRepBndLib::Add(myESp, myBox);  
135   }
136   //
137  protected:
138   // ->
139   TopoDS_Edge myE;
140   TopoDS_Vertex myV1;
141   Standard_Real myT1;
142   TopoDS_Vertex myV2;
143   Standard_Real myT2;
144   // <->
145   Handle(BOPDS_PaveBlock) myPB;
146   Handle(BOPDS_CommonBlock) myCB;
147   // <-
148   TopoDS_Edge myESp;
149   Bnd_Box myBox;
150 };
151 //
152 //=======================================================================
153 typedef BOPCol_NCVector
154   <BOPAlgo_SplitEdge> BOPAlgo_VectorOfSplitEdge; 
155 //
156 typedef BOPCol_Functor 
157   <BOPAlgo_SplitEdge,
158   BOPAlgo_VectorOfSplitEdge> BOPAlgo_SplitEdgeFunctor;
159 //
160 typedef BOPCol_Cnt 
161   <BOPAlgo_SplitEdgeFunctor,
162   BOPAlgo_VectorOfSplitEdge> BOPAlgo_SplitEdgeCnt;
163 //
164 //=======================================================================
165 //class    : BOPAlgo_MPC
166 //purpose  : 
167 //=======================================================================
168 class BOPAlgo_MPC : public BOPAlgo_Algo  {
169  
170  public:
171   DEFINE_STANDARD_ALLOC
172
173   BOPAlgo_MPC() : 
174     BOPAlgo_Algo(),
175     myFlag(Standard_False) {
176   };
177   //
178   virtual ~BOPAlgo_MPC(){
179   };
180   //
181   void SetEdge(const TopoDS_Edge& aE) {
182     myE=aE;
183   }
184   //
185   const TopoDS_Edge& Edge() const {
186     return myE;
187   }
188   //
189   void SetFace(const TopoDS_Face& aF) {
190     myF=aF;
191   }
192   //
193   const TopoDS_Face& Face() const {
194     return myF;
195   }
196   //
197   void SetFlag(const Standard_Boolean bFlag) {
198     myFlag=bFlag;
199   }
200   //
201   Standard_Boolean Flag() const {
202     return myFlag;
203   }
204   //
205   virtual void Perform() {
206     BOPAlgo_Algo::UserBreak();
207     BOPTools_AlgoTools2D::BuildPCurveForEdgeOnFace(myE, myF);
208     if (myFlag) {
209       UpdateVertices(myE, myF);
210     }
211   }
212   //
213  protected:
214   Standard_Boolean myFlag;
215   TopoDS_Edge myE;
216   TopoDS_Face myF;
217 };
218 //
219 //=======================================================================
220 typedef BOPCol_NCVector
221   <BOPAlgo_MPC> BOPAlgo_VectorOfMPC; 
222 //
223 typedef BOPCol_Functor 
224   <BOPAlgo_MPC,
225   BOPAlgo_VectorOfMPC> BOPAlgo_MPCFunctor;
226 //
227 typedef BOPCol_Cnt 
228   <BOPAlgo_MPCFunctor,
229   BOPAlgo_VectorOfMPC> BOPAlgo_MPCCnt;
230 //
231 //=======================================================================
232 //class    : BOPAlgo_BPC
233 //purpose  : 
234 //=======================================================================
235 class BOPAlgo_BPC {
236  public:
237   BOPAlgo_BPC(){
238   };
239   //
240   ~BOPAlgo_BPC(){
241   };
242   //
243   void SetFace(const TopoDS_Face& aF) {
244     myF=aF;
245   }
246   //
247   void SetEdge(const TopoDS_Edge& aE) {
248     myE=aE;
249   }
250   //
251   void Perform() {
252     BOPTools_AlgoTools2D::BuildPCurveForEdgeOnPlane (myE, myF);
253   };
254   //
255  protected:
256   TopoDS_Edge myE;
257   TopoDS_Face myF;
258 };
259 //=======================================================================
260 typedef BOPCol_NCVector
261   <BOPAlgo_BPC> BOPAlgo_VectorOfBPC; 
262 //
263 typedef BOPCol_Functor 
264   <BOPAlgo_BPC,
265   BOPAlgo_VectorOfBPC> BOPAlgo_BPCFunctor;
266 //
267 typedef BOPCol_Cnt 
268   <BOPAlgo_BPCFunctor,
269   BOPAlgo_VectorOfBPC> BOPAlgo_BPCCnt;
270 //
271 //
272 //=======================================================================
273 // function: MakeSplitEdges
274 // purpose: 
275 //=======================================================================
276 void BOPAlgo_PaveFiller::MakeSplitEdges()
277 {
278   Standard_Integer aNbPBP;
279   //
280   myErrorStatus=0;
281   //
282   BOPDS_VectorOfListOfPaveBlock& aPBP=myDS->ChangePaveBlocksPool();
283   aNbPBP=aPBP.Extent();
284   if(!aNbPBP) {
285     return;
286   }
287   //
288   Standard_Boolean bCB, bV1, bV2;
289   Standard_Integer i, nE, nV1, nV2, nSp, aNbPB, aNbVBSE, k;
290   Standard_Real aT1, aT2;
291   BOPDS_ListIteratorOfListOfPaveBlock aItPB, aItPBCB;
292   Handle(BOPDS_PaveBlock) aPB;
293   BOPDS_MapOfPaveBlock aMPB(100);
294   TopoDS_Vertex aV1, aV2;
295   TopoDS_Edge aE;
296   BOPAlgo_VectorOfSplitEdge aVBSE;
297   
298   //
299   for (i=0; i<aNbPBP; ++i) {
300     BOPDS_ListOfPaveBlock& aLPB=aPBP(i);
301     //
302     aNbPB=aLPB.Extent();
303     if (aNbPB==1) {
304       aPB=aLPB.First();
305       aPB->Indices(nV1, nV2);
306       bV1=myDS->IsNewShape(nV1);
307       bV2=myDS->IsNewShape(nV2);
308       //
309       if (!(bV1 || bV2)) {
310         nE=aPB->OriginalEdge();
311         aPB->SetEdge(nE);
312         continue;
313       }
314     }
315     //
316     aItPB.Initialize(aLPB);
317     for (; aItPB.More(); aItPB.Next()) {
318       aPB=aItPB.Value();
319       const Handle(BOPDS_CommonBlock)& aCB=myDS->CommonBlock(aPB);
320       bCB=!aCB.IsNull();
321       if (bCB) {
322         myDS->SortPaveBlocks(aCB);
323         aPB=aCB->PaveBlock1();
324       }
325       //
326       if (aMPB.Add(aPB)) {
327         nE=aPB->OriginalEdge();
328         aPB->Indices(nV1, nV2);
329         aPB->Range(aT1, aT2);
330         //
331         aE=(*(TopoDS_Edge *)(&myDS->Shape(nE))); 
332         aE.Orientation(TopAbs_FORWARD);
333         //
334         aV1=(*(TopoDS_Vertex *)(&myDS->Shape(nV1)));
335         aV1.Orientation(TopAbs_FORWARD); 
336         //
337         aV2=(*(TopoDS_Vertex *)(&myDS->Shape(nV2)));
338         aV2.Orientation(TopAbs_REVERSED); 
339         //
340         BOPAlgo_SplitEdge& aBSE=aVBSE.Append1();
341         //
342         aBSE.SetData(aE, aV1, aT1, aV2, aT2);
343         aBSE.SetPaveBlock(aPB);
344         if (bCB) {
345           aBSE.SetCommonBlock(aCB);
346         }
347         aBSE.SetProgressIndicator(myProgressIndicator);
348       }
349     } // for (; aItPB.More(); aItPB.Next()) {
350   }  // for (i=0; i<aNbPBP; ++i) {      
351   //
352   aNbVBSE=aVBSE.Extent();
353   //======================================================
354   BOPAlgo_SplitEdgeCnt::Perform(myRunParallel, aVBSE);
355   //======================================================
356   //
357   BOPDS_ShapeInfo aSI;
358   //
359   aSI.SetShapeType(TopAbs_EDGE);
360   //
361   for (k=0; k < aNbVBSE; ++k) {
362     BOPAlgo_SplitEdge& aBSE=aVBSE(k);
363     //
364     const TopoDS_Edge& aSp=aBSE.SplitEdge();
365     const Bnd_Box& aBox=aBSE.Box();
366     //
367     Handle(BOPDS_PaveBlock) aPBk=aBSE.PaveBlock();
368     Handle(BOPDS_CommonBlock)& aCBk=aBSE.CommonBlock();
369     //
370     aSI.SetShape(aSp);
371     aSI.ChangeBox()=aBox;
372     //
373     nSp=myDS->Append(aSI);
374     //
375     if (!aCBk.IsNull()) {
376       aCBk->SetEdge(nSp);
377     }
378     else {
379       aPBk->SetEdge(nSp);
380     }
381   }
382 }
383 //=======================================================================
384 // function: SplitEdge
385 // purpose: 
386 //=======================================================================
387 Standard_Integer BOPAlgo_PaveFiller::SplitEdge(const Standard_Integer nE, 
388                                                const Standard_Integer nV1,
389                                                const Standard_Real aT1, 
390                                                const Standard_Integer nV2, 
391                                                const Standard_Real aT2)
392 {
393   Standard_Integer nSp;
394   TopoDS_Vertex aV1, aV2;
395   TopoDS_Edge aE, aSp;
396   BOPDS_ShapeInfo aSI;
397   //
398   aSI.SetShapeType(TopAbs_EDGE);
399   //
400   aE=(*(TopoDS_Edge *)(&myDS->Shape(nE))); 
401   aE.Orientation(TopAbs_FORWARD);
402   //
403   aV1=(*(TopoDS_Vertex *)(&myDS->Shape(nV1)));
404   aV1.Orientation(TopAbs_FORWARD); 
405   //
406   aV2=(*(TopoDS_Vertex *)(&myDS->Shape(nV2)));
407   aV2.Orientation(TopAbs_REVERSED); 
408   //
409   BOPTools_AlgoTools::MakeSplitEdge(aE, aV1, aT1, aV2, aT2, aSp);  
410   //
411   aSI.SetShape(aSp);
412   //
413   Bnd_Box& aBox=aSI.ChangeBox();
414   BRepBndLib::Add(aSp, aBox);
415   //
416   nSp=myDS->Append(aSI);
417   return nSp;
418 }
419 //=======================================================================
420 // function: MakePCurves
421 // purpose: 
422 //=======================================================================
423 void BOPAlgo_PaveFiller::MakePCurves()
424 {
425   
426   Standard_Integer i, nF1, nF2, aNbC, k, nE, aNbFF, aNbFI;
427   BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
428   BOPDS_MapIteratorOfMapOfPaveBlock aItMPB;
429   TopoDS_Face aF1F, aF2F;
430   BOPAlgo_VectorOfMPC aVMPC;
431   //
432   myErrorStatus=0;
433   //
434   // 1. Process Common Blocks 
435   const BOPDS_VectorOfFaceInfo& aFIP=myDS->FaceInfoPool();
436   //
437   aNbFI=aFIP.Extent();
438   for (i=0; i<aNbFI; ++i) {
439     const BOPDS_FaceInfo& aFI=aFIP(i);
440     nF1=aFI.Index();
441     //
442     aF1F=(*(TopoDS_Face *)(&myDS->Shape(nF1)));
443     aF1F.Orientation(TopAbs_FORWARD);
444     // In
445     const BOPDS_IndexedMapOfPaveBlock& aMPBIn=aFI.PaveBlocksIn();
446     aItMPB.Initialize(aMPBIn);
447     for(; aItMPB.More(); aItMPB.Next()) {
448       const Handle(BOPDS_PaveBlock)& aPB=aItMPB.Value();
449       nE=aPB->Edge();
450       const TopoDS_Edge& aE=(*(TopoDS_Edge *)(&myDS->Shape(nE)));
451       //
452       BOPAlgo_MPC& aMPC=aVMPC.Append1();
453       aMPC.SetEdge(aE);
454       aMPC.SetFace(aF1F);
455       aMPC.SetProgressIndicator(myProgressIndicator);
456     }
457     //
458     // On
459     const BOPDS_IndexedMapOfPaveBlock& aMPBOn=aFI.PaveBlocksOn();
460     aItMPB.Initialize(aMPBOn);
461     for(; aItMPB.More(); aItMPB.Next()) {
462       const Handle(BOPDS_PaveBlock)& aPB=aItMPB.Value();
463       if (myDS->IsCommonBlockOnEdge(aPB)) {
464         nE=aPB->Edge();
465         const TopoDS_Edge& aE=(*(TopoDS_Edge *)(&myDS->Shape(nE)));
466         //
467         BOPAlgo_MPC& aMPC=aVMPC.Append1();
468         aMPC.SetEdge(aE);
469         aMPC.SetFace(aF1F);
470         aMPC.SetProgressIndicator(myProgressIndicator);
471       }
472     }
473   }// for (i=0; i<aNbFI; ++i) {
474   //
475   // 2. Process section edges
476   Standard_Boolean bPCurveOnS[2];
477   Standard_Integer m;
478   TopoDS_Face aFf[2];
479   //
480   bPCurveOnS[0]=mySectionAttribute.PCurveOnS1();
481   bPCurveOnS[1]=mySectionAttribute.PCurveOnS2();
482   //
483   if (bPCurveOnS[0] || bPCurveOnS[1]) {
484     BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
485     aNbFF=aFFs.Extent();
486     for (i=0; i<aNbFF; ++i) {
487       const BOPDS_InterfFF& aFF=aFFs(i);
488       aFF.Indices(nF1, nF2);
489       //
490       aFf[0]=(*(TopoDS_Face *)(&myDS->Shape(nF1)));
491       aFf[0].Orientation(TopAbs_FORWARD);
492       //
493       aFf[1]=(*(TopoDS_Face *)(&myDS->Shape(nF2)));
494       aFf[1].Orientation(TopAbs_FORWARD);
495       //
496       const BOPDS_VectorOfCurve& aVNC=aFF.Curves();
497       aNbC=aVNC.Extent();
498       for (k=0; k<aNbC; ++k) {
499         const BOPDS_Curve& aNC=aVNC(k);
500         const BOPDS_ListOfPaveBlock& aLPB=aNC.PaveBlocks();
501         aItLPB.Initialize(aLPB);
502         for(; aItLPB.More(); aItLPB.Next()) {
503           const Handle(BOPDS_PaveBlock)& aPB=aItLPB.Value();
504           nE=aPB->Edge();
505           const TopoDS_Edge& aE=(*(TopoDS_Edge *)(&myDS->Shape(nE))); 
506           //
507           for (m=0; m<2; ++m) {
508             if (bPCurveOnS[m]) {
509               BOPAlgo_MPC& aMPC=aVMPC.Append1();
510               aMPC.SetEdge(aE);
511               aMPC.SetFace(aFf[m]);
512               aMPC.SetFlag(bPCurveOnS[m]);
513               aMPC.SetProgressIndicator(myProgressIndicator);
514             }
515           }
516         }
517       }
518     }// for (i=0; i<aNbFF; ++i) {
519   }//if (bPCurveOnS1 || bPCurveOnS2 ) {
520   //
521   //======================================================
522   BOPAlgo_MPCCnt::Perform(myRunParallel, aVMPC);
523   //======================================================
524 }
525 //=======================================================================
526 // function: RefineFaceInfoOn
527 // purpose: 
528 //=======================================================================
529 void BOPAlgo_PaveFiller::RefineFaceInfoOn() 
530 {
531   Standard_Integer aNbPBP;
532   //
533   myErrorStatus=0;
534   //
535   BOPDS_VectorOfListOfPaveBlock& aPBP=myDS->ChangePaveBlocksPool();
536   aNbPBP=aPBP.Extent();
537   if(!aNbPBP) {
538     return;
539   }
540   //
541   Standard_Boolean bV1, bV2;
542   Standard_Integer i, nV1, nV2, aNbPB;
543   Handle(BOPDS_PaveBlock) aPB;
544   //
545   for (i=0; i<aNbPBP; ++i) {
546     BOPDS_ListOfPaveBlock& aLPB=aPBP(i);
547     //
548     aNbPB=aLPB.Extent();
549     if (aNbPB==1) {
550       aPB=aLPB.First();
551       aPB->Indices(nV1, nV2);
552       bV1=myDS->IsNewShape(nV1);
553       bV2=myDS->IsNewShape(nV2);
554       //
555       if (!(bV1 || bV2)) {
556         if (!myDS->IsCommonBlock(aPB)) {
557           // the PB seems to be untouced
558           aLPB.Clear();
559           continue;
560         }
561       }//if (!(bV1 || bV2)) {
562     }//if (aNbPB==1) {
563   }//for (i=0; i<aNbPBP; ++i) {
564   myDS->RefineFaceInfoOn();
565 }
566 //=======================================================================
567 //function : UpdateVertices
568 //purpose  : update tolerances of vertices comparing extremities of
569 //           3d and 2d curves
570 //=======================================================================
571 void UpdateVertices(const TopoDS_Edge& aE, 
572                     const TopoDS_Face& aF)
573 {
574   Standard_Integer j;
575   Standard_Real aT[2], aUx, aVx, aTolV2, aD2, aD;
576   gp_Pnt aP3D, aP3Dx;
577   gp_Pnt2d aP2Dx;
578   Handle(Geom_Surface) aS;
579   Handle(Geom_Curve) aC3D;
580   Handle(Geom2d_Curve) aC2D;
581   TopoDS_Edge aEf;
582   TopoDS_Vertex aV[2];
583   BRep_Builder aBB;
584   //
585   aEf=aE;
586   aEf.Orientation(TopAbs_FORWARD);
587   //
588   TopExp::Vertices(aEf, aV[0], aV[1]);
589   //
590   aS=BRep_Tool::Surface(aF);
591   aC3D=BRep_Tool::Curve(aEf, aT[0], aT[1]);
592   aC2D=BRep_Tool::CurveOnSurface(aEf, aF, aT[0], aT[1]);
593   //
594   for (j=0; j<2; ++j) {
595     aTolV2=BRep_Tool::Tolerance(aV[j]);
596     aTolV2=aTolV2*aTolV2;
597     //
598     aC3D->D0(aT[j], aP3D);
599     aC2D->D0(aT[j], aP2Dx);
600     aP2Dx.Coord(aUx, aVx);
601     aS->D0(aUx, aVx, aP3Dx);
602     aD2=aP3D.SquareDistance(aP3Dx);
603     if (aD2>aTolV2) {
604       aD=sqrt(aD2);
605       aBB.UpdateVertex(aV[j], aD);
606     }
607   }
608 }
609 //=======================================================================
610 // function: Prepare
611 // purpose: 
612 //=======================================================================
613 void BOPAlgo_PaveFiller::Prepare()
614 {
615   TopAbs_ShapeEnum aType[] = {
616     TopAbs_VERTEX,
617     TopAbs_EDGE,
618     TopAbs_FACE
619   };
620   Standard_Boolean bJustAdd, bIsBasedOnPlane;
621   Standard_Integer i, aNb, n1, nF;
622   TopExp_Explorer aExp;
623   BOPCol_MapOfShape aMF;
624   BOPCol_MapIteratorOfMapOfShape aItMF;
625   //
626   myErrorStatus=0;
627   //
628   aNb=3;
629   for(i=0; i<aNb; ++i) {
630     myIterator->Initialize(aType[i], aType[2]);
631     for (; myIterator->More(); myIterator->Next()) {
632       myIterator->Value(n1, nF, bJustAdd);
633       const TopoDS_Face& aF=(*(TopoDS_Face *)(&myDS->Shape(nF))); 
634       //
635       bIsBasedOnPlane=IsBasedOnPlane(aF);
636       if (bIsBasedOnPlane) {
637         aMF.Add(aF);
638       }
639     }
640   }
641   //
642   if (aMF.IsEmpty()) {
643     return;
644   }
645   //
646   BOPAlgo_VectorOfBPC aVBPC;
647   //
648   aItMF.Initialize(aMF);
649   for (; aItMF.More(); aItMF.Next()) {
650     const TopoDS_Face& aF=*((TopoDS_Face *)&aItMF.Key());
651     aExp.Init(aF, aType[1]);
652     for (; aExp.More(); aExp.Next()) {
653       const TopoDS_Edge& aE=*((TopoDS_Edge *)&aExp.Current());
654       BOPAlgo_BPC& aBPC=aVBPC.Append1();
655       aBPC.SetEdge(aE);
656       aBPC.SetFace(aF);
657     }
658   }
659   //
660   //======================================================
661   BOPAlgo_BPCCnt::Perform(myRunParallel, aVBPC);
662   //======================================================
663 }
664 //=======================================================================
665 //function : IsBasedOnPlane
666 //purpose  : 
667 //=======================================================================
668 Standard_Boolean IsBasedOnPlane(const TopoDS_Face& aF)
669 {
670   TopLoc_Location aLoc; 
671   Handle(Geom_RectangularTrimmedSurface) aGRTS;
672   Handle(Geom_Plane) aGP;
673   
674   const Handle(Geom_Surface)& aS = BRep_Tool::Surface(aF, aLoc);
675   aGRTS = Handle(Geom_RectangularTrimmedSurface)::DownCast(aS);
676   if(!aGRTS.IsNull()) {
677     aGP = Handle(Geom_Plane)::DownCast(aGRTS->BasisSurface());
678   }
679   else {
680     aGP = Handle(Geom_Plane)::DownCast(aS);
681   }
682   //
683   return (!aGP.IsNull()); 
684 }