0024639: Parallelization FillDS part of BO
authorpkv <pkv@opencascade.com>
Mon, 24 Mar 2014 05:34:34 +0000 (09:34 +0400)
committerbugmaster <bugmaster@opencascade.com>
Fri, 28 Mar 2014 11:55:13 +0000 (15:55 +0400)
Modifications to avoid compilation errors

src/BOPAlgo/BOPAlgo_PaveFiller.cdl
src/BOPAlgo/BOPAlgo_PaveFiller_2.cxx
src/BOPAlgo/BOPAlgo_PaveFiller_3.cxx
src/BOPAlgo/BOPAlgo_PaveFiller_7.cxx
src/BOPAlgo/BOPAlgo_PaveFiller_9.cxx [new file with mode: 0644]
src/BOPAlgo/FILES
src/BOPCol/BOPCol_TBB.hxx
src/BOPInt/BOPInt_ShrunkRange.cdl
src/BOPInt/BOPInt_ShrunkRange.cxx
src/BOPTools/BOPTools_AlgoTools.cxx
src/BOPTools/BOPTools_AlgoTools_2.cxx

index 5391514..32cc1d6 100644 (file)
@@ -20,7 +20,8 @@ class PaveFiller from BOPAlgo
     ---Purpose: 
 
 uses 
-    Pnt from gp,   
+    Pnt from gp,  
+    ShapeEnum from TopAbs,  
     Vertex from TopoDS,
     Face from TopoDS, 
     Edge from TopoDS,
@@ -139,7 +140,12 @@ is
     FillShrunkData(me:out; 
         thePB:out PaveBlock from BOPDS) 
       is protected;   
-        
+    FillShrunkData(me:out; 
+        theType1: ShapeEnum from TopAbs; 
+        theType2: ShapeEnum from TopAbs) 
+      is protected;     
     PerformVerticesEE(me:out; 
         theMVCPB:out IndexedDataMapOfShapeCoupleOfPaveBlocks from BOPDS; 
         theAllocator:out BaseAllocator from BOPCol) 
index da247b1..1d65993 100644 (file)
@@ -21,6 +21,9 @@
 #include <TopoDS_Edge.hxx>
 #include <BRep_Tool.hxx>
 
+#include <BOPCol_NCVector.hxx>
+#include <BOPCol_TBB.hxx>
+
 #include <BOPInt_Context.hxx>
 
 #include <BOPDS_Iterator.hxx>
 #include <BRepBndLib.hxx>
 #include <BRep_Builder.hxx>
 
-
+//=======================================================================
+//class    : BOPAlgo_VertexEdgeEdge
+//purpose  : 
+//=======================================================================
+class BOPAlgo_VertexEdge {
+ public:
+  BOPAlgo_VertexEdge()
+    : myIV(-1), myIE(-1), myIVx(-1), myFlag(-1), myT(-1.) {
+  };
+  //
+  ~BOPAlgo_VertexEdge(){
+  };
+  //
+  void SetIndices(const Standard_Integer nV,
+                  const Standard_Integer nE,
+                  const Standard_Integer nVx) {
+    myIV=nV;
+    myIE=nE;
+    myIVx=nVx;
+  }
+  //
+  void Indices(Standard_Integer& nV,
+               Standard_Integer& nE,
+               Standard_Integer& nVx) const {
+    nV=myIV;
+    nE=myIE;
+    nVx=myIVx;
+  }
+  //
+  void SetVertex(const TopoDS_Vertex& aV) {
+    myV=aV;
+  }
+  //
+  const TopoDS_Vertex& Vertex()const {
+    return myV;
+  }
+  //
+  void SetEdge(const TopoDS_Edge& aE) {
+    myE=aE;
+  }
+  //
+  const TopoDS_Edge& Edge()const {
+    return myE;
+  }
+  //
+  Standard_Integer Flag()const {
+    return myFlag;
+  }
+  //
+  Standard_Real Parameter()const {
+    return myT;
+  }
+  //
+  void SetContext(const Handle(BOPInt_Context)& aContext) {
+    myContext=aContext;
+  }
+  //
+  const Handle(BOPInt_Context)& Context()const {
+    return myContext;
+  }
+  //
+  void Perform() {
+    myFlag=myContext->ComputeVE (myV, myE, myT);
+  };
+  //
+ protected:
+  Standard_Integer myIV;
+  Standard_Integer myIE;
+  Standard_Integer myIVx;
+  Standard_Integer myFlag;
+  Standard_Real myT;
+  TopoDS_Vertex myV;
+  TopoDS_Edge myE;
+  Handle(BOPInt_Context) myContext;
+};
+//=======================================================================
+typedef BOPCol_NCVector
+  <BOPAlgo_VertexEdge> BOPAlgo_VectorOfVertexEdge; 
+//
+typedef BOPCol_TBBContextFunctor 
+  <BOPAlgo_VertexEdge,
+  BOPAlgo_VectorOfVertexEdge,
+  Handle_BOPInt_Context, 
+  BOPInt_Context> BOPAlgo_VertexEdgeFunctor;
+//
+typedef BOPCol_TBBContextCnt 
+  <BOPAlgo_VertexEdgeFunctor,
+  BOPAlgo_VectorOfVertexEdge,
+  Handle_BOPInt_Context> BOPAlgo_VertexEdgeCnt;
+//
 //=======================================================================
 // function: PerformVE
 // purpose: 
 //=======================================================================
-  void BOPAlgo_PaveFiller::PerformVE()
+void BOPAlgo_PaveFiller::PerformVE()
 {
   Standard_Boolean bJustAdd;
-  Standard_Integer iSize, nV, nE, nVSD, iFlag, nVx, i;
+  Standard_Integer iSize, nV, nE, nVSD, iFlag, nVx, i, k, aNbVE;;
   Standard_Real aT, aTolE, aTolV;
   BOPDS_Pave aPave;
   BOPDS_PassKey aPK;
   BOPDS_MapOfPassKey aMPK;
   BRep_Builder aBB;
+  BOPAlgo_VectorOfVertexEdge aVVE;
   //
   myErrorStatus=0;
   //
     const TopoDS_Edge& aE=(*(TopoDS_Edge *)(&aSIE.Shape())); 
     const TopoDS_Vertex& aV=(*(TopoDS_Vertex *)(&myDS->Shape(nVx))); 
     //
-    iFlag=myContext->ComputeVE (aV, aE, aT);
+    BOPAlgo_VertexEdge& aVESolver=aVVE.Append1();
+    //
+    aVESolver.SetIndices(nV, nE, nVx);
+    aVESolver.SetVertex(aV);
+    aVESolver.SetEdge(aE);
+    //
+  }// myIterator->Initialize(TopAbs_VERTEX, TopAbs_EDGE);
+  //
+  aNbVE=aVVE.Extent();
+  //=============================================================
+  BOPAlgo_VertexEdgeCnt::Perform(myRunParallel, aVVE, myContext);
+  //=============================================================
+  //
+  for (k=0; k < aNbVE; ++k) {
+    const BOPAlgo_VertexEdge& aVESolver=aVVE(k);
+    iFlag=aVESolver.Flag();
     if (!iFlag) {
+      aVESolver.Indices(nV, nE, nVx);
+      aT=aVESolver.Parameter();
+      const TopoDS_Vertex& aV=aVESolver.Vertex();
+      const TopoDS_Edge& aE=aVESolver.Edge();
       // 1
       i=aVEs.Append()-1;
       BOPDS_InterfVE& aVE=aVEs(i);
         BRepBndLib::Add(aV, aBoxDS);
       }
     }
-  }//for (; myIterator->More(); myIterator->Next()) {
+  }//for (k=0; k < aNbVE; ++k) {
 } 
index dca0122..e5929af 100644 (file)
@@ -98,60 +98,18 @@ class BOPAlgo_EdgeEdge : public IntTools_EdgeEdge {
   Handle(BOPDS_PaveBlock) myPB2;
 };
 //
-typedef BOPCol_NCVector<BOPAlgo_EdgeEdge> BOPAlgo_VectorOfEdgeEdge; 
+//=======================================================================
+typedef BOPCol_NCVector
+  <BOPAlgo_EdgeEdge> BOPAlgo_VectorOfEdgeEdge; 
 //
+typedef BOPCol_TBBFunctor 
+  <BOPAlgo_EdgeEdge,
+  BOPAlgo_VectorOfEdgeEdge> BOPAlgo_EdgeEdgeFunctor;
+//
+typedef BOPCol_TBBCnt 
+  <BOPAlgo_EdgeEdgeFunctor,
+  BOPAlgo_VectorOfEdgeEdge> BOPAlgo_EdgeEdgeCnt;
 //
-//=======================================================================
-//class    : BOPAlgo_EdgeEdgeFunctor
-//purpose  : 
-//=======================================================================
-class BOPAlgo_EdgeEdgeFunctor {
- protected:
-  BOPAlgo_VectorOfEdgeEdge* myPVEE;
-  //
- public:
-  //
-  BOPAlgo_EdgeEdgeFunctor(BOPAlgo_VectorOfEdgeEdge& aVEE) 
-    : myPVEE(&aVEE) {
-  }
-  //
-  void operator()( const flexible_range<Standard_Integer>& aBR ) const{
-    Standard_Integer i, iBeg, iEnd;
-    //
-    BOPAlgo_VectorOfEdgeEdge& aVEE=*myPVEE;
-    //
-    iBeg=aBR.begin();
-    iEnd=aBR.end();
-    for(i=iBeg; i!=iEnd; ++i) {
-      BOPAlgo_EdgeEdge& aEE=aVEE(i);
-      //
-      aEE.Perform();
-    }
-  }
-};
-//=======================================================================
-//class    : BOPAlgo_EdgeEdgeCnt
-//purpose  : 
-//=======================================================================
-class BOPAlgo_EdgeEdgeCnt {
- public:
-  //-------------------------------
-  // Perform
-  Standard_EXPORT 
-    static void Perform(const Standard_Boolean bRunParallel,
-                        BOPAlgo_VectorOfEdgeEdge& aVEdgeEdge) {
-    //
-    BOPAlgo_EdgeEdgeFunctor aEEF(aVEdgeEdge);
-    Standard_Integer aNbEE=aVEdgeEdge.Extent();
-    //
-    if (bRunParallel) {
-      flexible_for(flexible_range<Standard_Integer>(0,aNbEE), aEEF);
-    }
-    else {
-      aEEF.operator()(flexible_range<Standard_Integer>(0,aNbEE));
-    }
-  }
-};
 //=======================================================================
 // function: PerformEE
 // purpose: 
@@ -162,6 +120,8 @@ void BOPAlgo_PaveFiller::PerformEE()
   //
   myErrorStatus=0;
   //
+  FillShrunkData(TopAbs_EDGE, TopAbs_EDGE);
+  //
   myIterator->Initialize(TopAbs_EDGE, TopAbs_EDGE);
   iSize=myIterator->ExpectedLength();
   if (!iSize) {
@@ -214,10 +174,7 @@ void BOPAlgo_PaveFiller::PerformEE()
       //
       Handle(BOPDS_PaveBlock)& aPB1=aIt1.ChangeValue();
       if (!aPB1->HasShrunkData()) {
-        FillShrunkData(aPB1);
-        if (myWarningStatus) {
-          continue;
-        }
+        continue;
       }
       aPB1->ShrunkData(aTS11, aTS12, aBB1);
       //
@@ -227,10 +184,7 @@ void BOPAlgo_PaveFiller::PerformEE()
         //
         Handle(BOPDS_PaveBlock)& aPB2=aIt2.ChangeValue();
         if (!aPB2->HasShrunkData()) {
-          FillShrunkData(aPB2);
-          if (myWarningStatus) {
-            continue;
-          }
+          continue;
         }
         aPB2->ShrunkData(aTS21, aTS22, aBB2);
         //
@@ -744,7 +698,8 @@ void BOPAlgo_PaveFiller::FillShrunkData(Handle(BOPDS_PaveBlock)& thePB)
   nE=thePB->OriginalEdge();
   const TopoDS_Edge& aE=(*(TopoDS_Edge *)(&myDS->Shape(nE))); 
   //
-  aSR.SetData(aE, aT1, aT2, aV1, aV2, myContext);
+  aSR.SetContext(myContext);
+  aSR.SetData(aE, aT1, aT2, aV1, aV2);
   //
   aSR.Perform();
   iErr=aSR.ErrorStatus();
index c79acb1..fd7fc79 100644 (file)
@@ -34,6 +34,9 @@
 #include <Geom_Surface.hxx>
 #include <Geom2d_Curve.hxx>
 
+#include <BOPCol_NCVector.hxx>
+#include <BOPCol_TBB.hxx>
+
 #include <BOPTools_AlgoTools.hxx>
 #include <BOPTools_AlgoTools2D.hxx>
 
 #include <BOPDS_MapOfPaveBlock.hxx>
 #include <BOPDS_Curve.hxx>
 
+
 static void UpdateVertices(const TopoDS_Edge& aE, 
                            const TopoDS_Face& aF);
 
 //=======================================================================
+//class    : BOPAlgo_SplitEdge
+//purpose  : 
+//=======================================================================
+class BOPAlgo_SplitEdge {
+ public:
+  BOPAlgo_SplitEdge() {
+    myT1=0.;
+    myT2=0.;
+  }
+  //
+  ~BOPAlgo_SplitEdge() {
+  }
+  //
+  void SetData(const TopoDS_Edge& aE,
+               const TopoDS_Vertex& aV1,
+               const Standard_Real aT1,
+               const TopoDS_Vertex& aV2,
+               const Standard_Real aT2) {
+    myE=aE;
+    myV1=aV1;
+    myT1=aT1;
+    myV2=aV2;
+    myT2=aT2;
+    myESp=aE;
+  }
+  //
+  void SetPaveBlock(const Handle(BOPDS_PaveBlock)& aPB) {
+    myPB=aPB;
+  }
+  //
+  Handle(BOPDS_PaveBlock)& PaveBlock() {
+    return myPB;
+  }
+  //
+  void SetCommonBlock(const Handle(BOPDS_CommonBlock)& aCB) {
+    myCB=aCB;
+  }
+  //
+  Handle(BOPDS_CommonBlock)& CommonBlock() {
+    return myCB;
+  }
+  //
+  const TopoDS_Edge& SplitEdge() const {
+    return myESp;
+  }
+  //
+  const Bnd_Box Box() {
+    return myBox;
+  }
+  //
+  void Perform () {
+    BOPTools_AlgoTools::MakeSplitEdge(myE, 
+                                      myV1, myT1, 
+                                      myV2, myT2, 
+                                      myESp);
+    BRepBndLib::Add(myESp, myBox);  
+  }
+  //
+ protected:
+  // ->
+  TopoDS_Edge myE;
+  TopoDS_Vertex myV1;
+  Standard_Real myT1;
+  TopoDS_Vertex myV2;
+  Standard_Real myT2;
+  // <->
+  Handle(BOPDS_PaveBlock) myPB;
+  Handle(BOPDS_CommonBlock) myCB;
+  // <-
+  TopoDS_Edge myESp;
+  Bnd_Box myBox;
+};
+//
+//=======================================================================
+typedef BOPCol_NCVector
+  <BOPAlgo_SplitEdge> BOPAlgo_VectorOfSplitEdge; 
+//
+typedef BOPCol_TBBFunctor 
+  <BOPAlgo_SplitEdge,
+  BOPAlgo_VectorOfSplitEdge> BOPAlgo_SplitEdgeFunctor;
+//
+typedef BOPCol_TBBCnt 
+  <BOPAlgo_SplitEdgeFunctor,
+  BOPAlgo_VectorOfSplitEdge> BOPAlgo_SplitEdgeCnt;
+//
+//=======================================================================
 // function: MakeSplitEdges
 // purpose: 
 //=======================================================================
-  void BOPAlgo_PaveFiller::MakeSplitEdges()
+void BOPAlgo_PaveFiller::MakeSplitEdges()
 {
   Standard_Integer aNbPBP;
   //
@@ -72,26 +162,20 @@ static void UpdateVertices(const TopoDS_Edge& aE,
   }
   //
   Standard_Boolean bCB, bV1, bV2;
-  Standard_Integer i, nE, nV1, nV2, nSp, aNbPB;
+  Standard_Integer i, nE, nV1, nV2, nSp, aNbPB, aNbVBSE, k;
   Standard_Real aT1, aT2;
-  Handle(NCollection_IncAllocator) aAllocator;
   BOPDS_ListIteratorOfListOfPaveBlock aItPB, aItPBCB;
-  Handle(BOPDS_PaveBlock) aPB, aPBx;
-  //-----------------------------------------------------scope f
-  //
-  aAllocator=new NCollection_IncAllocator();
-  //
-  BOPDS_MapOfPaveBlock aMPB(100,aAllocator);
+  Handle(BOPDS_PaveBlock) aPB;
+  BOPDS_MapOfPaveBlock aMPB(100);
+  TopoDS_Vertex aV1, aV2;
+  TopoDS_Edge aE;
+  BOPAlgo_VectorOfSplitEdge aVBSE;
+  
   //
   for (i=0; i<aNbPBP; ++i) {
     BOPDS_ListOfPaveBlock& aLPB=aPBP(i);
     //
     aNbPB=aLPB.Extent();
-    //DEBf
-    if (aNbPB) {
-      aPBx=aLPB.First();
-    }
-    //DEBt
     if (aNbPB==1) {
       aPB=aLPB.First();
       aPB->Indices(nV1, nV2);
@@ -120,23 +204,57 @@ static void UpdateVertices(const TopoDS_Edge& aE,
         aPB->Indices(nV1, nV2);
         aPB->Range(aT1, aT2);
         //
-        nSp = SplitEdge(nE, nV1, aT1, nV2, aT2);
+        aE=(*(TopoDS_Edge *)(&myDS->Shape(nE))); 
+        aE.Orientation(TopAbs_FORWARD);
+        //
+        aV1=(*(TopoDS_Vertex *)(&myDS->Shape(nV1)));
+        aV1.Orientation(TopAbs_FORWARD); 
         //
+        aV2=(*(TopoDS_Vertex *)(&myDS->Shape(nV2)));
+        aV2.Orientation(TopAbs_REVERSED); 
+        //
+        BOPAlgo_SplitEdge& aBSE=aVBSE.Append1();
+        //
+        aBSE.SetData(aE, aV1, aT1, aV2, aT2);
+        aBSE.SetPaveBlock(aPB);
         if (bCB) {
-          aCB->SetEdge(nSp);
+          aBSE.SetCommonBlock(aCB);
         }
-        else {
-          aPB->SetEdge(nSp);
-        }
-      }// if (aMPB.Add(aPB)) {
-    }// for (; aItPB.More(); aItPB.Next()) {
-  }// for (i=0; i<aNbPBP; ++i) {
+      }
+    } // for (; aItPB.More(); aItPB.Next()) {
+  }  // for (i=0; i<aNbPBP; ++i) {      
+  //
+  aNbVBSE=aVBSE.Extent();
+  //======================================================
+  BOPAlgo_SplitEdgeCnt::Perform(myRunParallel, aVBSE);
+  //======================================================
+  //
+  BOPDS_ShapeInfo aSI;
   //
-  //-----------------------------------------------------scope t
-  aMPB.Clear();
-  aAllocator.Nullify();
+  aSI.SetShapeType(TopAbs_EDGE);
+  //
+  for (k=0; k < aNbVBSE; ++k) {
+    BOPAlgo_SplitEdge& aBSE=aVBSE(k);
+    //
+    const TopoDS_Edge& aSp=aBSE.SplitEdge();
+    const Bnd_Box& aBox=aBSE.Box();
+    //
+    Handle(BOPDS_PaveBlock) aPBk=aBSE.PaveBlock();
+    Handle(BOPDS_CommonBlock)& aCBk=aBSE.CommonBlock();
+    //
+    aSI.SetShape(aSp);
+    aSI.ChangeBox()=aBox;
+    //
+    nSp=myDS->Append(aSI);
+    //
+    if (!aCBk.IsNull()) {
+      aCBk->SetEdge(nSp);
+    }
+    else {
+      aPBk->SetEdge(nSp);
+    }
+  }
 }
-
 //=======================================================================
 // function: SplitEdge
 // purpose: 
@@ -173,12 +291,11 @@ Standard_Integer BOPAlgo_PaveFiller::SplitEdge(const Standard_Integer nE,
   nSp=myDS->Append(aSI);
   return nSp;
 }
-
 //=======================================================================
 // function: MakePCurves
 // purpose: 
 //=======================================================================
-  void BOPAlgo_PaveFiller::MakePCurves()
+void BOPAlgo_PaveFiller::MakePCurves()
 {
   Standard_Integer i, nF1, nF2, aNbC, k, nE, aNbFF, aNbFI;
   BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
@@ -262,12 +379,11 @@ Standard_Integer BOPAlgo_PaveFiller::SplitEdge(const Standard_Integer nE,
     }
   }
 }
-
 //=======================================================================
 // function: RefineFaceInfoOn
 // purpose: 
 //=======================================================================
-  void BOPAlgo_PaveFiller::RefineFaceInfoOn() 
+void BOPAlgo_PaveFiller::RefineFaceInfoOn() 
 {
   Standard_Integer aNbPBP;
   //
@@ -304,13 +420,13 @@ Standard_Integer BOPAlgo_PaveFiller::SplitEdge(const Standard_Integer nE,
   }//for (i=0; i<aNbPBP; ++i) {
   myDS->RefineFaceInfoOn();
 }
-
 //=======================================================================
 //function : UpdateVertices
 //purpose  : update tolerances of vertices comparing extremities of
 //           3d and 2d curves
 //=======================================================================
-void UpdateVertices(const TopoDS_Edge& aE, const TopoDS_Face& aF)
+void UpdateVertices(const TopoDS_Edge& aE, 
+                    const TopoDS_Face& aF)
 {
   Standard_Integer j;
   Standard_Real aT[2], aUx, aVx, aTolV2, aD2, aD;
diff --git a/src/BOPAlgo/BOPAlgo_PaveFiller_9.cxx b/src/BOPAlgo/BOPAlgo_PaveFiller_9.cxx
new file mode 100644 (file)
index 0000000..9a0d01d
--- /dev/null
@@ -0,0 +1,179 @@
+// Created by: Peter KURNEV
+// Copyright (c) 1999-2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <BOPAlgo_PaveFiller.ixx>
+//
+#include <Bnd_Box.hxx>
+
+#include <TopoDS_Edge.hxx>
+#include <TopoDS_Vertex.hxx>
+
+#include <BOPCol_NCVector.hxx>
+#include <BOPCol_MapOfInteger.hxx>
+#include <BOPCol_TBB.hxx>
+
+#include <BOPDS_ShapeInfo.hxx>
+#include <BOPDS_PaveBlock.hxx>
+#include <BOPDS_Iterator.hxx>
+#include <BOPDS_ListOfPaveBlock.hxx>
+
+#include <BOPInt_ShrunkRange.hxx>
+
+//=======================================================================
+//class    : BOPAlgo_ShrunkRange
+//purpose  : 
+//=======================================================================
+class BOPAlgo_ShrunkRange : public BOPInt_ShrunkRange {
+ public:
+  BOPAlgo_ShrunkRange() 
+  : BOPInt_ShrunkRange(),
+    myWarningStatus(0) {
+  }
+  //
+  virtual ~BOPAlgo_ShrunkRange() {
+  }
+  //
+  void SetPaveBlock(const Handle(BOPDS_PaveBlock)& aPB) {
+    myPB=aPB;
+  }
+  //
+  Handle(BOPDS_PaveBlock)& PaveBlock() {
+    return myPB;
+  }
+  //
+  virtual void Perform() {
+    //
+    myWarningStatus=0;
+    //
+    BOPInt_ShrunkRange::Perform();
+    if (myErrorStatus) {
+      myWarningStatus=1;
+    }
+  }
+  //
+  Standard_Integer WarningStatus() const {
+    return myWarningStatus;
+  }
+  //
+ protected:
+  Standard_Integer myWarningStatus;
+  Handle(BOPDS_PaveBlock) myPB;
+};
+//
+//=======================================================================
+typedef BOPCol_NCVector
+  <BOPAlgo_ShrunkRange> BOPAlgo_VectorOfShrunkRange; 
+//
+typedef BOPCol_TBBContextFunctor 
+  <BOPAlgo_ShrunkRange,
+  BOPAlgo_VectorOfShrunkRange,
+  Handle_BOPInt_Context, 
+  BOPInt_Context> BOPAlgo_ShrunkRangeFunctor;
+//
+typedef BOPCol_TBBContextCnt 
+  <BOPAlgo_ShrunkRangeFunctor,
+  BOPAlgo_VectorOfShrunkRange,
+  Handle_BOPInt_Context> BOPAlgo_ShrunkRangeCnt;
+//
+//=======================================================================
+// function: FillShrunkData
+// purpose: 
+//=======================================================================
+void BOPAlgo_PaveFiller::FillShrunkData(const TopAbs_ShapeEnum aType1,
+                                        const TopAbs_ShapeEnum aType2)
+{
+  Standard_Integer iSize;
+  
+  //
+  myErrorStatus=0;
+  //
+  myIterator->Initialize(aType1, aType2);
+  iSize=myIterator->ExpectedLength();
+  if (!iSize) {
+    return; 
+  }
+  //
+  Standard_Boolean bJustAdd;
+  Standard_Integer i, iEnd, nS[2], nE, nV1, nV2, aNbVSD, k, iWrn;
+  Standard_Real aT1, aT2, aTS1, aTS2;
+  BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
+  BOPCol_MapOfInteger aMI; 
+  BOPAlgo_VectorOfShrunkRange aVSD;
+  //
+  iEnd=(aType2==TopAbs_EDGE) ? 2 : 1;
+  //
+  for (; myIterator->More(); myIterator->Next()) {
+    myIterator->Value(nS[0], nS[1], bJustAdd);
+    if(bJustAdd) {
+      continue;
+    }
+    //
+    for (i=0; i<iEnd; ++i) {
+      nE=nS[i];
+      if (!aMI.Add(nE)) {
+        continue;
+      }
+      //
+      const BOPDS_ShapeInfo& aSIE=myDS->ShapeInfo(nE);
+      if (aSIE.HasFlag()){
+        continue;
+      }
+      //
+      BOPDS_ListOfPaveBlock& aLPB=myDS->ChangePaveBlocks(nE);
+      aItLPB.Initialize(aLPB);
+      for (; aItLPB.More(); aItLPB.Next()) {
+        const Handle(BOPDS_PaveBlock)& aPB=aItLPB.ChangeValue();
+        if (aPB->HasShrunkData()) {
+          continue;
+        }
+        //
+        // FillShrunkData(aPB);
+        aPB->Indices(nV1, nV2);
+        aPB->Range(aT1, aT2);
+        //
+        const TopoDS_Edge& aE=(*(TopoDS_Edge *)(&aSIE.Shape()));
+        //
+        const TopoDS_Vertex& aV1=
+          (*(TopoDS_Vertex *)(&myDS->Shape(nV1))); 
+        //
+        const TopoDS_Vertex& aV2=
+          (*(TopoDS_Vertex *)(&myDS->Shape(nV2))); 
+        //
+        BOPAlgo_ShrunkRange& aSD=aVSD.Append1();
+        //
+        aSD.SetPaveBlock(aPB);
+        aSD.SetData(aE, aT1, aT2, aV1, aV2); 
+      }
+    }
+  }
+  //
+  aNbVSD=aVSD.Extent();
+  //=============================================================
+  BOPAlgo_ShrunkRangeCnt::Perform(myRunParallel, aVSD, myContext);
+  //=============================================================
+  //
+  for (k=0; k < aNbVSD; ++k) {
+    BOPAlgo_ShrunkRange& aSD=aVSD(k);
+    iWrn=aSD.WarningStatus();
+    if (iWrn==1) {
+      continue;
+    }
+    //
+    Handle(BOPDS_PaveBlock)& aPB=aSD.PaveBlock();
+    aSD.ShrunkRange(aTS1, aTS2);
+    const Bnd_Box& aBox=aSD.BndBox();
+    //
+    aPB->SetShrunkData(aTS1, aTS2, aBox);
+  }
+}
index 7959228..1efa702 100644 (file)
@@ -16,3 +16,4 @@ BOPAlgo_ListOfCheckResult.hxx
 BOPAlgo_Builder_2Cnt.hxx
 BOPAlgo_CheckerSI_1.cxx
 
+BOPAlgo_PaveFiller_9.cxx
index 20c87c2..bc313a6 100755 (executable)
@@ -43,7 +43,7 @@ using namespace tbb;
 template <class Type> class serial_range {
  public:
   serial_range(const Type& aBegin,
-              const Type& aEnd)
+               const Type& aEnd)
     : myBegin(aBegin), myEnd(aEnd) {
   }
   //
@@ -72,5 +72,149 @@ static void serial_for( const Range& range, const Body& body ) {
   body.operator()(range);
 };
 #endif // not HAVE_TBB
+//
+// 2. Implementation of Functors/Starters
+//
+// 2.1. Pure version
+//
+//=======================================================================
+//class    : BOPCol_TBBFunctor
+//purpose  : 
+//=======================================================================
+template <class TypeSolver, 
+          class TypeSolverVector> class BOPCol_TBBFunctor {
+ public:
+  BOPCol_TBBFunctor(TypeSolverVector& aV) 
+    : myPV(&aV) {
+  }
+  //
+  ~BOPCol_TBBFunctor() {
+  }
+  //
+  void operator()( const flexible_range<Standard_Size>& aBR ) const{
+    Standard_Size i, iBeg, iEnd;
+    //
+    TypeSolverVector& aV=*myPV;
+    //
+    iBeg=aBR.begin();
+    iEnd=aBR.end();
+    for(i=iBeg; i!=iEnd; ++i) {
+      TypeSolver& aSolver=aV(i);
+      //
+      aSolver.Perform();
+    }
+  }
+  //
+ protected:
+  TypeSolverVector* myPV;
+};
+//=======================================================================
+//class    : BOPCol_TBBCnt
+//purpose  : 
+//=======================================================================
+template <class TypeFunctor, 
+          class TypeSolverVector> class BOPCol_TBBCnt {
+ public:
+  //-------------------------------
+  // Perform
+  Standard_EXPORT 
+    static void Perform(const Standard_Boolean bRunParallel,
+                        TypeSolverVector& aV) {
+    //
+    TypeFunctor aFunctor(aV);
+    Standard_Size aNb=aV.Extent();
+    //
+    if (bRunParallel) {
+      flexible_for(flexible_range<Standard_Size>(0,aNb), aFunctor);
+    }
+    else {
+      aFunctor.operator()(flexible_range<Standard_Size>(0,aNb));
+    }
+  }
+};
+//
+// 2.2. Context dependent version
+//
+#include <Standard_Macro.hxx>
+
+//=======================================================================
+//class    : BOPCol_TBBContextFunctor
+//purpose  : 
+//=======================================================================
+template <class TypeSolver, 
+          class TypeSolverVector,
+          class TypeContext, 
+          typename TN> class BOPCol_TBBContextFunctor  {
+ public:
+  BOPCol_TBBContextFunctor(TypeSolverVector& aV) 
+    : myPV(&aV) {
+  }
+  //
+  ~BOPCol_TBBContextFunctor() {
+  }
+  //
+  void SetContext(TypeContext& aCtx) {
+    myContext=aCtx;
+  }
+  //
+  void operator()( const flexible_range<Standard_Size>& aBR ) const{
+    Standard_Size i, iBeg, iEnd;
+    TypeContext aCtx;
+    //
+    if (myContext.IsNull()) {
+      aCtx=new TN
+        (NCollection_BaseAllocator::CommonBaseAllocator());
+    }
+    else {
+      aCtx=myContext;
+    }
+    //
+    TypeSolverVector& aV=*myPV;
+    //
+    iBeg=aBR.begin();
+    iEnd=aBR.end();
+    for(i=iBeg; i!=iEnd; ++i) {
+      TypeSolver& aSolver=aV(i);
+      //
+      aSolver.SetContext(aCtx);
+      aSolver.Perform();
+    }
+  }
+  //
+ protected:
+  TypeSolverVector* myPV;
+  TypeContext myContext;
+  //
+};
+
+//=======================================================================
+//class    : BOPCol_TBBContextCnt
+//purpose  : 
+//=======================================================================
+template <class TypeFunctor, 
+          class TypeSolverVector,
+          class TypeContext> class BOPCol_TBBContextCnt {
+ public:
+  //-------------------------------
+  // Perform
+  Standard_EXPORT 
+    static void Perform(const Standard_Boolean bRunParallel,
+                        TypeSolverVector& aV,
+                        TypeContext& aCtx) {
+    //
+    TypeFunctor aFunctor(aV);
+    Standard_Size aNb=aV.Extent();
+    //
+    if (bRunParallel) {
+      flexible_for(flexible_range<Standard_Size>(0,aNb), aFunctor);
+    }
+    else {
+      aFunctor.SetContext(aCtx);
+      aFunctor.operator()(flexible_range<Standard_Size>(0,aNb));
+    }
+  }
+};
 
 #endif
index 724767b..717a630 100644 (file)
 
 class ShrunkRange from BOPInt 
 
-       ---Purpose:  
-       ---  The class provides the computation of 
-       ---  a working (shrunk) range [t1, t2] for 
-       ---  the 3D-curve of the edge. 
-        
+ ---Purpose:  
+ ---  The class provides the computation of 
+ ---  a working (shrunk) range [t1, t2] for 
+     ---  the 3D-curve of the edge. 
+  
 uses
     Box from Bnd, 
     Edge from TopoDS, 
@@ -29,49 +29,56 @@ uses
 
 is 
     Create 
-       returns ShrunkRange from BOPInt;
-
+        returns ShrunkRange from BOPInt;
+    ---C++: alias "Standard_EXPORT virtual ~BOPInt_ShrunkRange();"  
+    
     SetData (me:out; 
-           aE  : Edge from TopoDS;  
-           aT1 : Real from Standard;              
-           aT2 : Real from Standard;     
-           aV1 : Vertex from TopoDS;              
-           aV2 : Vertex from TopoDS; 
-           ICtx: Context from BOPInt);   
-
+            aE  : Edge from TopoDS;  
+            aT1 : Real from Standard;              
+            aT2 : Real from Standard;     
+            aV1 : Vertex from TopoDS;              
+            aV2 : Vertex from TopoDS); 
+     
+    SetContext(me:out; 
+            aCtx: Context from BOPInt);  
+             
+    Context(me) 
+        returns Context from BOPInt;       
+    ---C++: return const &  
+    
     SetShrunkRange(me:out; 
-           aT1 : Real from Standard;   
-           aT2 : Real from Standard);   
+         aT1 : Real from Standard;   
+         aT2 : Real from Standard);   
 
     ShrunkRange(me; 
-           aT1 :out Real from Standard;   
-           aT2 :out Real from Standard); 
+         aT1 :out Real from Standard;   
+         aT2 :out Real from Standard); 
   
     BndBox  (me) 
-       returns Box from Bnd; 
+     returns Box from Bnd; 
     ---C++: return const & 
      
     Edge  (me) 
-       returns Edge from TopoDS; 
-    ---C++: return const &      
-            
+     returns Edge from TopoDS; 
+    ---C++: return const &  
+      
     Perform(me:out); 
-        
+  
     ErrorStatus(me) 
-       returns Integer from Standard;  
-       ---Purpose:
-       --- Returns code of computing shrunk range
-       --- completion
-       --- 0 - means successful completion
-       --- 1 - nothing has been done
-       --- 2 - initial range is out of edge's range
-       --- 3 - first boundary of initial range is more than
-       ---     last boundary
-       --- 4 - projection of first vertex failed
-       --- 5 - projection of second vertex failed
-       --- 6 - shrunk range can not be computed
-       ---     shrunk range is setted to initial range
-       ---
+     returns Integer from Standard;  
+ ---Purpose:
+ --- Returns code of computing shrunk range
+ --- completion
+ --- 0 - means successful completion
+ --- 1 - nothing has been done
+ --- 2 - initial range is out of edge's range
+ --- 3 - first boundary of initial range is more than
+ ---     last boundary
+ --- 4 - projection of first vertex failed
+ --- 5 - projection of second vertex failed
+ --- 6 - shrunk range can not be computed
+ ---     shrunk range is setted to initial range
+ ---
 
 fields
     myEdge        : Edge from TopoDS is protected; 
index da2ba4e..ad2584c 100644 (file)
   myErrorStatus=1;
 }
 //=======================================================================
+//function : ~
+//purpose  : 
+//=======================================================================
+BOPInt_ShrunkRange::~BOPInt_ShrunkRange () 
+{
+}
+//=======================================================================
 //function : SetData
 //purpose  : 
 //=======================================================================
-  void BOPInt_ShrunkRange::SetData(const TopoDS_Edge& aE,
-                                   const Standard_Real aT1,
-                                   const Standard_Real aT2,
-                                   const TopoDS_Vertex& aV1,
-                                   const TopoDS_Vertex& aV2,
-                                   const Handle(BOPInt_Context)& aCtx)
+void BOPInt_ShrunkRange::SetData(const TopoDS_Edge& aE,
+                                 const Standard_Real aT1,
+                                 const Standard_Real aT2,
+                                 const TopoDS_Vertex& aV1,
+                                 const TopoDS_Vertex& aV2)
 {
   myEdge=aE;
   myV1=aV1;
   myV2=aV2;
   myT1=aT1;
   myT2=aT2;
-  //myRange=aR;
-  myCtx=aCtx;
   myErrorStatus=1;
 }
 //=======================================================================
+//function : SetContext
+//purpose  : 
+//=======================================================================
+void BOPInt_ShrunkRange::SetContext(const Handle(BOPInt_Context)& aCtx)
+{
+  myCtx=aCtx;
+}
+//=======================================================================
+//function : Context
+//purpose  : 
+//=======================================================================
+const Handle(BOPInt_Context)& BOPInt_ShrunkRange::Context()const
+{
+  return myCtx;
+}
+//=======================================================================
 //function : Edge
 //purpose  : 
 //=======================================================================
-  const TopoDS_Edge& BOPInt_ShrunkRange::Edge() const
+const TopoDS_Edge& BOPInt_ShrunkRange::Edge() const
 {
   return myEdge;
 }
@@ -73,8 +93,8 @@
 //function : ShrunkRange
 //purpose  : 
 //=======================================================================
-  void BOPInt_ShrunkRange::ShrunkRange(Standard_Real& aT1,
-                                       Standard_Real& aT2) const
+void BOPInt_ShrunkRange::ShrunkRange(Standard_Real& aT1,
+                                     Standard_Real& aT2) const
 {
   aT1=myTS1;
   aT2=myTS2;
 //function : BndBox
 //purpose  : 
 //=======================================================================
-  const Bnd_Box& BOPInt_ShrunkRange::BndBox() const
+const Bnd_Box& BOPInt_ShrunkRange::BndBox() const
 {
   return myBndBox;
 }
 //function : ErrorStatus
 //purpose  : 
 //=======================================================================
-  Standard_Integer BOPInt_ShrunkRange::ErrorStatus() const
+Standard_Integer BOPInt_ShrunkRange::ErrorStatus() const
 {
   return myErrorStatus;
 }
 //function : SetShrunkRange
 //purpose  : 
 //=======================================================================
-  void BOPInt_ShrunkRange::SetShrunkRange(const Standard_Real aT1,
-                                          const Standard_Real aT2) 
+void BOPInt_ShrunkRange::SetShrunkRange(const Standard_Real aT1,
+                                        const Standard_Real aT2) 
 {
   myTS1=aT1;
   myTS2=aT2;
 //function : Perform
 //purpose  : 
 //=======================================================================
-  void BOPInt_ShrunkRange::Perform()
+void BOPInt_ShrunkRange::Perform()
 {
-  Standard_Real aCF, aCL, aTolE, aTolV1, aTolV2, t1, t11, t1C, t2, t12, t2C;
+  Standard_Real aCF, aCL, aTolE, aTolV1;
+  Standard_Real aTolV2, t1, t11, t1C, t2, t12, t2C;
   Standard_Real aCoeff1, aCoeff2, aTol1, aTol2, dt1, dt2, aR, anEps;
   Standard_Integer pri;
   Standard_Boolean bInf1, bInf2, bAppr;
     return;
   }
   //
-  bAppr = (fabs(t2 - t1) > 100) ? Standard_False : Standard_True;
+  bAppr = !(fabs(t2 - t1) > 100);
   if (fabs(t2 - t1) < anEps) {
     myErrorStatus=7;
     return;
       }
     }
   } // else {
-
-
+  //
   if (t1C>t2){
     t1C=0.5*(t2+t1);
     t2C=t1C+0.1*(t2-t1C);
index d6c5e9a..61e9c97 100644 (file)
@@ -104,10 +104,11 @@ static
 // function: MakeConnexityBlocks
 // purpose: 
 //=======================================================================
-void BOPTools_AlgoTools::MakeConnexityBlocks (const TopoDS_Shape& theS,
-                                              const TopAbs_ShapeEnum theType1,
-                                              const TopAbs_ShapeEnum theType2,
-                                              BOPCol_ListOfShape& theLCB)
+void BOPTools_AlgoTools::MakeConnexityBlocks 
+  (const TopoDS_Shape& theS,
+   const TopAbs_ShapeEnum theType1,
+   const TopAbs_ShapeEnum theType2,
+   BOPCol_ListOfShape& theLCB)
 {
   Standard_Integer  aNbF, aNbAdd, aNbAdd1, i;
   BRep_Builder aBB;
@@ -203,7 +204,9 @@ void BOPTools_AlgoTools::OrientFacesOnShell (TopoDS_Shape& aShell)
   //
   BOPTools_AlgoTools::MakeContainer(TopAbs_SHELL, aShellNew);
   //
-  BOPTools::MapShapesAndAncestors(aShell, TopAbs_EDGE, TopAbs_FACE, aEFMap);
+  BOPTools::MapShapesAndAncestors(aShell, 
+                                  TopAbs_EDGE, TopAbs_FACE, 
+                                  aEFMap);
   aNbE=aEFMap.Extent();
   // 
   // One seam edge  in aEFMap contains  2 equivalent faces.
@@ -334,18 +337,15 @@ TopAbs_Orientation Orientation(const TopoDS_Edge& anE,
   }
   return anOr;
 }
-
-////////////
-
-
 //=======================================================================
 // function: MakeConnexityBlock.
 // purpose: 
 //=======================================================================
-void BOPTools_AlgoTools::MakeConnexityBlock (BOPCol_ListOfShape& theLFIn,
-                                             BOPCol_IndexedMapOfShape& theMEAvoid,
-                                             BOPCol_ListOfShape& theLCB,
-                                             const Handle(NCollection_BaseAllocator)& theAllocator)
+void BOPTools_AlgoTools::MakeConnexityBlock 
+  (BOPCol_ListOfShape& theLFIn,
+   BOPCol_IndexedMapOfShape& theMEAvoid,
+   BOPCol_ListOfShape& theLCB,
+   const Handle(NCollection_BaseAllocator)& theAllocator)
 {
   Standard_Integer  aNbF, aNbAdd1, aNbAdd, i;
   TopExp_Explorer aExp;
@@ -422,10 +422,11 @@ void BOPTools_AlgoTools::MakeConnexityBlock (BOPCol_ListOfShape& theLFIn,
 // function:  ComputeStateByOnePoint
 // purpose: 
 //=======================================================================
-TopAbs_State BOPTools_AlgoTools::ComputeStateByOnePoint(const TopoDS_Shape& theS,
-                                                        const TopoDS_Solid& theRef,
-                                                        const Standard_Real theTol,
-                                                        Handle(BOPInt_Context)& theContext)
+TopAbs_State BOPTools_AlgoTools::ComputeStateByOnePoint
+  (const TopoDS_Shape& theS,
+   const TopoDS_Solid& theRef,
+   const Standard_Real theTol,
+   Handle(BOPInt_Context)& theContext)
 {
   TopAbs_State aState;
   TopAbs_ShapeEnum aType;
@@ -447,11 +448,12 @@ TopAbs_State BOPTools_AlgoTools::ComputeStateByOnePoint(const TopoDS_Shape& theS
 // function:  ComputeState
 // purpose: 
 //=======================================================================
-TopAbs_State BOPTools_AlgoTools::ComputeState(const TopoDS_Face& theF,
-                                              const TopoDS_Solid& theRef,
-                                              const Standard_Real theTol,
-                                              BOPCol_IndexedMapOfShape& theBounds,
-                                              Handle(BOPInt_Context)& theContext)
+TopAbs_State BOPTools_AlgoTools::ComputeState
+  (const TopoDS_Face& theF,
+   const TopoDS_Solid& theRef,
+   const Standard_Real theTol,
+   BOPCol_IndexedMapOfShape& theBounds,
+   Handle(BOPInt_Context)& theContext)
 {
   TopAbs_State aState;
   TopExp_Explorer aExp; 
@@ -470,7 +472,8 @@ TopAbs_State BOPTools_AlgoTools::ComputeState(const TopoDS_Face& theF,
     //
     if (!theBounds.Contains(aSE)) {
       const TopoDS_Edge& aE=(*(TopoDS_Edge*)(&aSE));
-      aState=BOPTools_AlgoTools::ComputeState(aE, theRef, theTol, theContext);
+      aState=BOPTools_AlgoTools::ComputeState(aE, theRef, theTol, 
+                                              theContext);
       return aState;
     }
     if (aE1.IsNull()) {
@@ -479,8 +482,10 @@ TopAbs_State BOPTools_AlgoTools::ComputeState(const TopoDS_Face& theF,
   }
   // !!<- process edges that are all on theRef
   if (!aE1.IsNull()) {
-    BOPTools_AlgoTools3D::PointNearEdge(aE1, theF, aP2D, aP3D, theContext);
-    aState=BOPTools_AlgoTools::ComputeState(aP3D, theRef, theTol, theContext);
+    BOPTools_AlgoTools3D::PointNearEdge(aE1, theF, 
+                                        aP2D, aP3D, theContext);
+    aState=BOPTools_AlgoTools::ComputeState(aP3D, theRef, theTol, 
+                                            theContext);
   }
   //
   return aState;
@@ -489,26 +494,29 @@ TopAbs_State BOPTools_AlgoTools::ComputeState(const TopoDS_Face& theF,
 // function:  ComputeState
 // purpose: 
 //=======================================================================
-TopAbs_State BOPTools_AlgoTools::ComputeState(const TopoDS_Vertex& theV,
-                                              const TopoDS_Solid& theRef,
-                                              const Standard_Real theTol,
-                                              Handle(BOPInt_Context)& theContext)
+TopAbs_State BOPTools_AlgoTools::ComputeState
+  (const TopoDS_Vertex& theV,
+   const TopoDS_Solid& theRef,
+   const Standard_Real theTol,
+   Handle(BOPInt_Context)& theContext)
 {
   TopAbs_State aState;
   gp_Pnt aP3D; 
   //
   aP3D=BRep_Tool::Pnt(theV);
-  aState=BOPTools_AlgoTools::ComputeState(aP3D, theRef, theTol, theContext);
+  aState=BOPTools_AlgoTools::ComputeState(aP3D, theRef, theTol, 
+                                          theContext);
   return aState;
 }
 //=======================================================================
 // function:  ComputeState
 // purpose: 
 //=======================================================================
-TopAbs_State BOPTools_AlgoTools::ComputeState(const TopoDS_Edge& theE,
-                                              const TopoDS_Solid& theRef,
-                                              const Standard_Real theTol,
-                                              Handle(BOPInt_Context)& theContext)
+TopAbs_State BOPTools_AlgoTools::ComputeState
+  (const TopoDS_Edge& theE,
+   const TopoDS_Solid& theRef,
+   const Standard_Real theTol,
+   Handle(BOPInt_Context)& theContext)
 {
   Standard_Real aT1, aT2, aT = 0.;
   TopAbs_State aState;
@@ -547,7 +555,8 @@ TopAbs_State BOPTools_AlgoTools::ComputeState(const TopoDS_Edge& theE,
     aC3D->D0(aT, aP3D);
   }
   //
-  aState=BOPTools_AlgoTools::ComputeState(aP3D, theRef, theTol, theContext);
+  aState=BOPTools_AlgoTools::ComputeState(aP3D, theRef, theTol, 
+                                          theContext);
   //
   return aState;
 }
@@ -555,10 +564,11 @@ TopAbs_State BOPTools_AlgoTools::ComputeState(const TopoDS_Edge& theE,
 // function:  ComputeState
 // purpose: 
 //=======================================================================
-TopAbs_State BOPTools_AlgoTools::ComputeState(const gp_Pnt& theP,
-                                              const TopoDS_Solid& theRef,
-                                              const Standard_Real theTol,
-                                              Handle(BOPInt_Context)& theContext)
+TopAbs_State BOPTools_AlgoTools::ComputeState
+  (const gp_Pnt& theP,
+   const TopoDS_Solid& theRef,
+   const Standard_Real theTol,
+   Handle(BOPInt_Context)& theContext)
 {
   TopAbs_State aState;
   //
@@ -633,7 +643,8 @@ Standard_Integer BOPTools_AlgoTools::IsInternalFace
         break;
       }
       //
-      iRet=BOPTools_AlgoTools::IsInternalFace(theFace, aE, aF1, aF1, theContext);
+      iRet=BOPTools_AlgoTools::IsInternalFace(theFace, aE, aF1, aF1, 
+                                              theContext);
       break;
     }
     //
@@ -643,7 +654,8 @@ Standard_Integer BOPTools_AlgoTools::IsInternalFace
       //
       if (aF2.IsSame(aF1) && BRep_Tool::IsClosed(aE, aF1)) {
         // treat as it was for 1 face
-        iRet=BOPTools_AlgoTools::IsInternalFace(theFace, aE, aF1, aF2, theContext);
+        iRet=BOPTools_AlgoTools::IsInternalFace(theFace, aE, aF1, aF2, 
+                                                theContext);
         break;
       }
     }
@@ -653,7 +665,8 @@ Standard_Integer BOPTools_AlgoTools::IsInternalFace
       return iRet; // it can not be so
     }
     else { // aNbF=2,4,6,8,...
-      iRet=BOPTools_AlgoTools::IsInternalFace(theFace, aE, aLF, theContext);
+      iRet=BOPTools_AlgoTools::IsInternalFace(theFace, aE, aLF, 
+                                              theContext);
       break;
     }
   }//for(; aExp.More(); aExp.Next()) {
@@ -675,7 +688,8 @@ Standard_Integer BOPTools_AlgoTools::IsInternalFace
   //
   BOPTools::MapShapes(theSolid, TopAbs_EDGE, aBounds);
   //
-  aState=BOPTools_AlgoTools::ComputeState(theFace, theSolid, theTol, aBounds, theContext);
+  aState=BOPTools_AlgoTools::ComputeState(theFace, theSolid, 
+                                          theTol, aBounds, theContext);
   //
   iRet=(aState==TopAbs_IN)? 1 : 0;
   //
@@ -685,10 +699,11 @@ Standard_Integer BOPTools_AlgoTools::IsInternalFace
 //function : IsInternalFace
 //purpose  : 
 //=======================================================================
-Standard_Integer BOPTools_AlgoTools::IsInternalFace(const TopoDS_Face& theFace,
-                                                    const TopoDS_Edge& theEdge,
-                                                    BOPCol_ListOfShape& theLF,
-                                                    Handle(BOPInt_Context)& theContext)
+Standard_Integer BOPTools_AlgoTools::IsInternalFace
+  (const TopoDS_Face& theFace,
+   const TopoDS_Edge& theEdge,
+   BOPCol_ListOfShape& theLF,
+   Handle(BOPInt_Context)& theContext)
 {
   Standard_Integer aNbF, iRet;
   //
@@ -698,7 +713,8 @@ Standard_Integer BOPTools_AlgoTools::IsInternalFace(const TopoDS_Face& theFace,
   if (aNbF==2) {
     const TopoDS_Face& aF1=(*(TopoDS_Face*)(&theLF.First()));
     const TopoDS_Face& aF2=(*(TopoDS_Face*)(&theLF.Last()));
-    iRet=BOPTools_AlgoTools::IsInternalFace(theFace, theEdge, aF1, aF2, theContext);
+    iRet=BOPTools_AlgoTools::IsInternalFace(theFace, theEdge, aF1, aF2, 
+                                            theContext);
     return iRet;
   }
   //
@@ -714,7 +730,8 @@ Standard_Integer BOPTools_AlgoTools::IsInternalFace(const TopoDS_Face& theFace,
       //
       const TopoDS_Face& aF1=(*(TopoDS_Face*)(&aCSFF.Shape1()));
       const TopoDS_Face& aF2=(*(TopoDS_Face*)(&aCSFF.Shape2()));
-      iRet=BOPTools_AlgoTools::IsInternalFace(theFace, theEdge, aF1, aF2, theContext);
+      iRet=BOPTools_AlgoTools::IsInternalFace(theFace, theEdge, aF1, aF2, 
+                                              theContext);
       if (iRet) {
         return iRet;
       }
@@ -813,7 +830,8 @@ Standard_Boolean BOPTools_AlgoTools::GetFaceOff
   aPL->Bounds(aUmin, aUsup, aVmin, aVsup);
   aProjPL.Init(aPL, aUmin, aUsup, aVmin, aVsup);
   //
-  GetFaceDir(theE1, theF1, aPx, aT, aDTgt, aDN1, aDBF, theContext, aProjPL);
+  GetFaceDir(theE1, theF1, aPx, aT, aDTgt, aDN1, aDBF, theContext, 
+             aProjPL);
   //
   aDTF=aDN1^aDBF;
   //
@@ -825,7 +843,8 @@ Standard_Boolean BOPTools_AlgoTools::GetFaceOff
     const TopoDS_Face& aF2=(*(TopoDS_Face*)(&aCS.Shape2()));
     //
     aDTgt2 = (aE2.Orientation()==aOr) ? aDTgt : aDTgt.Reversed();
-    GetFaceDir(aE2, aF2, aPx, aT, aDTgt2, aDN2, aDBF2, theContext, aProjPL);
+    GetFaceDir(aE2, aF2, aPx, aT, aDTgt2, aDN2, aDBF2, theContext, 
+               aProjPL);
     //Angle
     aAngle=AngleWithRef(aDBF, aDBF2, aDTF);
     //
@@ -888,9 +907,10 @@ Standard_Boolean BOPTools_AlgoTools::GetEdgeOff(const TopoDS_Edge& theE1,
 //function : AreFacesSameDomain
 //purpose  : 
 //=======================================================================
-Standard_Boolean BOPTools_AlgoTools::AreFacesSameDomain(const TopoDS_Face& theF1,
-                                                        const TopoDS_Face& theF2,
-                                                        Handle(BOPInt_Context)& theContext)
+Standard_Boolean BOPTools_AlgoTools::AreFacesSameDomain
+  (const TopoDS_Face& theF1,
+   const TopoDS_Face& theF2,
+   Handle(BOPInt_Context)& theContext)
 {
   Standard_Boolean bFlag;
   Standard_Integer iErr;
@@ -922,7 +942,8 @@ Standard_Boolean BOPTools_AlgoTools::AreFacesSameDomain(const TopoDS_Face& theF1
   aTolF2=BRep_Tool::Tolerance(aF2);
   aTol=aTolF1+aTolF2;
   //
-  iErr = BOPTools_AlgoTools3D::PointInFace(aF1, aP, aP2D, theContext);
+  iErr = BOPTools_AlgoTools3D::PointInFace(aF1, aP, aP2D,
+                                           theContext);
   if (!iErr) {
     bFlag=theContext->IsValidPointForFace(aP, aF2, aTol);
   }
@@ -934,9 +955,10 @@ Standard_Boolean BOPTools_AlgoTools::AreFacesSameDomain(const TopoDS_Face& theF1
 //function : CheckSameGeom
 //purpose  : 
 //=======================================================================
-Standard_Boolean BOPTools_AlgoTools::CheckSameGeom(const TopoDS_Face& theF1,
-                                                   const TopoDS_Face& theF2,
-                                                   Handle(BOPInt_Context)& theContext)
+Standard_Boolean BOPTools_AlgoTools::CheckSameGeom
+  (const TopoDS_Face& theF1,
+   const TopoDS_Face& theF2,
+   Handle(BOPInt_Context)& theContext)
 {
   Standard_Boolean bRet;
   Standard_Real aTolF1, aTolF2, aTol;
@@ -1009,9 +1031,10 @@ Standard_Integer BOPTools_AlgoTools::Sense (const TopoDS_Face& theF1,
 // function: IsSplitToReverse
 // purpose: 
 //=======================================================================
-Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse(const TopoDS_Shape& theSp,
-                                                      const TopoDS_Shape& theSr,
-                                                      Handle(BOPInt_Context)& theContext)
+Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse
+  (const TopoDS_Shape& theSp,
+   const TopoDS_Shape& theSr,
+   Handle(BOPInt_Context)& theContext)
 {
   Standard_Boolean bRet;
   TopAbs_ShapeEnum aType;
@@ -1043,9 +1066,10 @@ Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse(const TopoDS_Shape& theSp,
 //function :IsSplitToReverse
 //purpose  : 
 //=======================================================================
-Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse(const TopoDS_Face& theFSp,
-                                                      const TopoDS_Face& theFSr,
-                                                      Handle(BOPInt_Context)& theContext)
+Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse
+  (const TopoDS_Face& theFSp,
+   const TopoDS_Face& theFSr,
+   Handle(BOPInt_Context)& theContext)
 {
   Standard_Boolean bRet, bFound, bInFace;
   Standard_Real aT1, aT2, aT, aU, aV, aScPr;
@@ -1084,7 +1108,8 @@ Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse(const TopoDS_Face& theFSp,
     Standard_Integer iErr;
     gp_Pnt2d aP2DFSp;
     //
-    iErr=BOPTools_AlgoTools3D::PointInFace(theFSp, aPFSp, aP2DFSp, theContext);
+    iErr=BOPTools_AlgoTools3D::PointInFace(theFSp, aPFSp, aP2DFSp, 
+                                           theContext);
     if (iErr) {
       return bRet;
     }
@@ -1098,7 +1123,9 @@ Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse(const TopoDS_Face& theFSp,
   else {
     BRep_Tool::Range(aESp, aT1, aT2);
     aT=BOPTools_AlgoTools2D::IntermediatePoint(aT1, aT2);
-    BOPTools_AlgoTools3D::GetApproxNormalToFaceOnEdge(aESp, theFSp, aT, aPFSp, aDNFSp, theContext);
+    BOPTools_AlgoTools3D::GetApproxNormalToFaceOnEdge(aESp, theFSp, aT, 
+                                                      aPFSp, aDNFSp, 
+                                                      theContext);
   }
   //
   // Parts of theContext->ComputeVS(..) 
@@ -1132,9 +1159,10 @@ Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse(const TopoDS_Face& theFSp,
 //function :IsSplitToReverse
 //purpose  : 
 //=======================================================================
-Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse(const TopoDS_Edge& aEF1,
-                                                      const TopoDS_Edge& aEF2,
-                                                      Handle(BOPInt_Context)& theContext)
+Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse
+  (const TopoDS_Edge& aEF1,
+   const TopoDS_Edge& aEF2,
+   Handle(BOPInt_Context)& theContext)
 {
   Standard_Boolean bRet, bIsDegenerated;
   //
@@ -1322,7 +1350,8 @@ void BOPTools_AlgoTools::MakePCurve(const TopoDS_Edge& aE,
   aTolE=BRep_Tool::Tolerance(aE);
   //
   const Handle(Geom_Curve)& aC3DE=BRep_Tool::Curve(aE, aT1, aT2);
-  Handle(Geom_TrimmedCurve)aC3DETrim=new Geom_TrimmedCurve(aC3DE, aT1, aT2);
+  Handle(Geom_TrimmedCurve)aC3DETrim=
+    new Geom_TrimmedCurve(aC3DE, aT1, aT2);
   //
   for (i=0; i<2; ++i) {
     bPC = !i ? bPC1 : bPC2;
@@ -1350,10 +1379,12 @@ void BOPTools_AlgoTools::MakePCurve(const TopoDS_Edge& aE,
       }
     //
     if (aC3DE->IsPeriodic()) {
-      BOPTools_AlgoTools2D::AdjustPCurveOnFace(aFFWD, aT1, aT2,  aC2D, aC2DA); 
+      BOPTools_AlgoTools2D::AdjustPCurveOnFace(aFFWD, aT1, aT2,  aC2D, 
+                                               aC2DA); 
     }
     else {
-      BOPTools_AlgoTools2D::AdjustPCurveOnFace(aFFWD, aC3DETrim, aC2D, aC2DA); 
+      BOPTools_AlgoTools2D::AdjustPCurveOnFace(aFFWD, aC3DETrim, aC2D, 
+                                               aC2DA); 
     }
     //
     aBB.UpdateEdge(aE, aC2DA, aFFWD, aTolE);
@@ -1376,7 +1407,8 @@ void BOPTools_AlgoTools::MakeEdge(const IntTools_Curve& theIC,
   Standard_Real aTolV;
   BRep_Builder aBB;
   //
-  BOPTools_AlgoTools::MakeSectEdge (theIC, theV1, theT1, theV2, theT2, theE);
+  BOPTools_AlgoTools::MakeSectEdge (theIC, theV1, theT1, theV2, theT2, 
+                                    theE);
   //
   aBB.UpdateEdge(theE, theTolR3D);
   //
@@ -1486,9 +1518,10 @@ void BOPTools_AlgoTools::MakeVertex(BOPCol_ListOfShape& aLV,
 //function : GetEdgeOnFace
 //purpose  : 
 //=======================================================================
-Standard_Boolean BOPTools_AlgoTools::GetEdgeOnFace(const TopoDS_Edge& theE1,
-                                                   const TopoDS_Face& theF2,
-                                                   TopoDS_Edge& theE2)
+Standard_Boolean BOPTools_AlgoTools::GetEdgeOnFace
+(const TopoDS_Edge& theE1,
+ const TopoDS_Face& theF2,
+ TopoDS_Edge& theE2)
 {
   Standard_Boolean bFound;
   TopoDS_Iterator aItF, aItW;
@@ -1639,10 +1672,11 @@ Standard_Real AngleWithRef(const gp_Dir& theD1,
 // function: IsBlockInOnFace
 // purpose: 
 //=======================================================================
-Standard_Boolean BOPTools_AlgoTools::IsBlockInOnFace (const IntTools_Range& aShrR,
-                                                      const TopoDS_Face& aF,
-                                                      const TopoDS_Edge& aE1,
-                                                      Handle(BOPInt_Context)& aContext)
+Standard_Boolean BOPTools_AlgoTools::IsBlockInOnFace
+  (const IntTools_Range& aShrR,
+   const TopoDS_Face& aF,
+   const TopoDS_Edge& aE1,
+   Handle(BOPInt_Context)& aContext)
 {
   Standard_Boolean bFlag;
   Standard_Real f1, l1, ULD, VLD;
@@ -1729,8 +1763,9 @@ Standard_Boolean BOPTools_AlgoTools::IsBlockInOnFace (const IntTools_Range& aShr
 //function : IsMicroEdge
 //purpose  : 
 //=======================================================================
-Standard_Boolean BOPTools_AlgoTools::IsMicroEdge(const TopoDS_Edge& aE,
-                                                 const Handle(BOPInt_Context)& aCtx) 
+Standard_Boolean BOPTools_AlgoTools::IsMicroEdge
+  (const TopoDS_Edge& aE,
+   const Handle(BOPInt_Context)& aCtx) 
 {
   Standard_Boolean bRet;
   Standard_Integer iErr;
@@ -1755,7 +1790,8 @@ Standard_Boolean BOPTools_AlgoTools::IsMicroEdge(const TopoDS_Edge& aE,
   }
   //
   BOPInt_ShrunkRange aSR;
-  aSR.SetData(aE, aT1, aT2, aV1, aV2, aCtx);
+  aSR.SetContext(aCtx);
+  aSR.SetData(aE, aT1, aT2, aV1, aV2);
   aSR.Perform();
   iErr=aSR.ErrorStatus();
   bRet = !(iErr==0);
@@ -1785,7 +1821,8 @@ void GetFaceDir(const TopoDS_Edge& aE,
   //
   gp_Pnt aPx;
   if (!FindPointInFace(aE, aF, aP, aDB, aPx, theContext, aProjPL)) {
-    BOPTools_AlgoTools3D::GetApproxNormalToFaceOnEdge(aE, aF, aT, aPx, aDN, theContext);
+    BOPTools_AlgoTools3D::GetApproxNormalToFaceOnEdge(aE, aF, aT, aPx, 
+                                                      aDN, theContext);
     aProjPL.Perform(aPx);
     aPx = aProjPL.NearestPoint();
     gp_Vec aVec(aP, aPx);
@@ -1882,8 +1919,7 @@ Standard_Boolean FindPointInFace(const TopoDS_Edge& aE,
 //function : IsOpenShell
 //purpose  : 
 //=======================================================================
-Standard_Boolean 
-  BOPTools_AlgoTools::IsOpenShell(const TopoDS_Shell& aSh)
+Standard_Boolean BOPTools_AlgoTools::IsOpenShell(const TopoDS_Shell& aSh)
 {
   Standard_Boolean bRet;
   Standard_Integer i, aNbE, aNbF;
@@ -1909,7 +1945,7 @@ Standard_Boolean
       const TopoDS_Shape& aF=aItLS.Value();
       aOrF=aF.Orientation();
       if (aOrF==TopAbs_INTERNAL || aOrF==TopAbs_EXTERNAL) {
-       continue;
+        continue;
       }
       ++aNbF;
     }
index 0e70d91..78e6181 100644 (file)
@@ -40,8 +40,9 @@ static
 // function: UpdateVertex
 // purpose: 
 //=======================================================================
-  void BOPTools_AlgoTools::UpdateVertex (const TopoDS_Vertex& aVF,
-                                     const TopoDS_Vertex& aNewVertex)
+void BOPTools_AlgoTools::UpdateVertex
+  (const TopoDS_Vertex& aVF,
+   const TopoDS_Vertex& aNewVertex)
 {
   Standard_Real aTolVF, aTolNewVertex, aDist, aDTol=1.e-12, aNewTol;
   //
@@ -63,9 +64,9 @@ static
 // function: UpdateVertex
 // purpose: 
 //=======================================================================
-  void BOPTools_AlgoTools::UpdateVertex (const TopoDS_Edge& aE,
-                                     const Standard_Real  aT,
-                                     const TopoDS_Vertex& aV)
+void BOPTools_AlgoTools::UpdateVertex (const TopoDS_Edge& aE,
+                                       const Standard_Real  aT,
+                                       const TopoDS_Vertex& aV)
 {
   Standard_Real aTolV, aDist, aDTol=1.e-12, aFirst, aLast;
   gp_Pnt  aPc; 
@@ -86,9 +87,9 @@ static
 // function: UpdateVertex
 // purpose: 
 //=======================================================================
-  void BOPTools_AlgoTools::UpdateVertex (const IntTools_Curve& aC,
-                                     const Standard_Real  aT,
-                                     const TopoDS_Vertex& aV)
+void BOPTools_AlgoTools::UpdateVertex (const IntTools_Curve& aC,
+                                       const Standard_Real  aT,
+                                       const TopoDS_Vertex& aV)
 {
   Standard_Real aTolV, aDist, aDTol=1.e-12;
   gp_Pnt  aPc; 
@@ -108,12 +109,12 @@ static
 // function: MakeSectEdge
 // purpose: 
 //=======================================================================
-  void BOPTools_AlgoTools::MakeSectEdge(const IntTools_Curve& aIC,
-                                     const TopoDS_Vertex& aV1,
-                                     const Standard_Real  aP1,
-                                     const TopoDS_Vertex& aV2,
-                                     const Standard_Real  aP2,
-                                     TopoDS_Edge& aNewEdge)
+void BOPTools_AlgoTools::MakeSectEdge(const IntTools_Curve& aIC,
+                                      const TopoDS_Vertex& aV1,
+                                      const Standard_Real  aP1,
+                                      const TopoDS_Vertex& aV2,
+                                      const Standard_Real  aP2,
+                                      TopoDS_Edge& aNewEdge)
 {
   Handle(Geom_Curve) aC=aIC.Curve ();
   
@@ -133,23 +134,19 @@ static
 // function: MakeSplitEdge
 // purpose: 
 //=======================================================================
-  void BOPTools_AlgoTools::MakeSplitEdge(const TopoDS_Edge&   aE,
-                                     const TopoDS_Vertex& aV1,
-                                     const Standard_Real  aP1,
-                                     const TopoDS_Vertex& aV2,
-                                     const Standard_Real  aP2,
-                                     TopoDS_Edge& aNewEdge)
+void BOPTools_AlgoTools::MakeSplitEdge(const TopoDS_Edge&   aE,
+                                       const TopoDS_Vertex& aV1,
+                                       const Standard_Real  aP1,
+                                       const TopoDS_Vertex& aV2,
+                                       const Standard_Real  aP2,
+                                       TopoDS_Edge& aNewEdge)
 {
-  Standard_Real f, l, aTol;
-  Handle(Geom_Curve) aC=BRep_Tool::Curve (aE, f, l);
+  Standard_Real aTol;//f, l, 
   aTol=BRep_Tool::Tolerance(aE);
   //
-  // MakeEdge is used for chechking all input data only 
-  BRepBuilderAPI_MakeEdge aMakeEdge(aC, aV1, aV2, aP1, aP2);
-  //ZZ const TopoDS_Edge& E1=TopoDS::Edge(aMakeEdge.Shape());
   TopoDS_Edge E=aE;
   E.EmptyCopy();
-
+  //
   BRep_Builder BB;
   BB.Add  (E, aV1);
   BB.Add  (E, aV2);
@@ -162,9 +159,9 @@ static
 // function: MakeNewVertex
 // purpose: 
 //=======================================================================
-  void BOPTools_AlgoTools::MakeNewVertex(const TopoDS_Vertex& aV1,
-                                     const TopoDS_Vertex& aV2,
-                                     TopoDS_Vertex& aNewVertex)
+void BOPTools_AlgoTools::MakeNewVertex(const TopoDS_Vertex& aV1,
+                                       const TopoDS_Vertex& aV2,
+                                       TopoDS_Vertex& aNewVertex)
 {
   gp_Pnt aPnt1=BRep_Tool::Pnt(aV1);
   Standard_Real aTol1=BRep_Tool::Tolerance(aV1);
@@ -190,9 +187,9 @@ static
 // function: MakeNewVertex
 // purpose: 
 //=======================================================================
-  void BOPTools_AlgoTools::MakeNewVertex(const gp_Pnt& aP,
-                                     const Standard_Real aTol,
-                                     TopoDS_Vertex& aNewVertex)
+void BOPTools_AlgoTools::MakeNewVertex(const gp_Pnt& aP,
+                                       const Standard_Real aTol,
+                                       TopoDS_Vertex& aNewVertex)
 {
   BRep_Builder aBB;
   aBB.MakeVertex (aNewVertex, aP, aTol);
@@ -202,11 +199,11 @@ static
 // function: MakeNewVertex
 // purpose: 
 //=======================================================================
-  void BOPTools_AlgoTools::MakeNewVertex(const TopoDS_Edge& aE1,
-                                     const Standard_Real aParm1,
-                                     const TopoDS_Edge& aE2,
-                                     const Standard_Real aParm2,
-                                     TopoDS_Vertex& aNewVertex)
+void BOPTools_AlgoTools::MakeNewVertex(const TopoDS_Edge& aE1,
+                                       const Standard_Real aParm1,
+                                       const TopoDS_Edge& aE2,
+                                       const Standard_Real aParm2,
+                                       TopoDS_Vertex& aNewVertex)
 {
   Standard_Real aTol1, aTol2, aMaxTol, aDist; 
   gp_Pnt aPnt1, aPnt2;
@@ -233,10 +230,10 @@ static
 // function: MakeNewVertex
 // purpose: 
 //=======================================================================
-  void BOPTools_AlgoTools::MakeNewVertex(const TopoDS_Edge& aE1,
-                                     const Standard_Real aParm1,
-                                     const TopoDS_Face& aF1,
-                                     TopoDS_Vertex& aNewVertex)
+void BOPTools_AlgoTools::MakeNewVertex(const TopoDS_Edge& aE1,
+                                       const Standard_Real aParm1,
+                                       const TopoDS_Face& aF1,
+                                       TopoDS_Vertex& aNewVertex)
 {
   Standard_Real aTol1, aTol2, aMaxTol, delta=1.e-12; 
   gp_Pnt aPnt;
@@ -257,9 +254,9 @@ static
 // function: PointOnEdge
 // purpose: 
 //=======================================================================
-  void BOPTools_AlgoTools::PointOnEdge(const TopoDS_Edge& aE,
-                                   const Standard_Real aParm,
-                                   gp_Pnt& aPnt)
+void BOPTools_AlgoTools::PointOnEdge(const TopoDS_Edge& aE,
+                                     const Standard_Real aParm,
+                                     gp_Pnt& aPnt)
 {
   Standard_Real f, l;
   Handle(Geom_Curve) C1=BRep_Tool::Curve(aE, f, l);
@@ -270,10 +267,10 @@ static
 //function : CorrectRange
 //purpose  : 
 //=======================================================================
-  void BOPTools_AlgoTools::CorrectRange(const TopoDS_Edge& aE1,
-                                    const TopoDS_Edge& aE2,
-                                    const IntTools_Range& aSR,
-                                    IntTools_Range& aNewSR)
+void BOPTools_AlgoTools::CorrectRange(const TopoDS_Edge& aE1,
+                                      const TopoDS_Edge& aE2,
+                                      const IntTools_Range& aSR,
+                                      IntTools_Range& aNewSR)
 {
   Standard_Integer i;
   Standard_Real aRes, aTolE1, aTolE2, aTF, aTL, dT;
@@ -342,10 +339,10 @@ static
 //function : CorrectRange
 //purpose  : 
 //=======================================================================
-  void BOPTools_AlgoTools::CorrectRange(const TopoDS_Edge& aE,
-                                    const TopoDS_Face& aF,
-                                    const IntTools_Range& aSR,
-                                    IntTools_Range& aNewSR)
+void BOPTools_AlgoTools::CorrectRange(const TopoDS_Edge& aE,
+                                      const TopoDS_Face& aF,
+                                      const IntTools_Range& aSR,
+                                      IntTools_Range& aNewSR)
 {
   Standard_Integer i;
   Standard_Real aRes, aTolF, aTF, aTL, dT;
@@ -408,7 +405,7 @@ static
 //function : Dimension
 //purpose  : 
 //=======================================================================
-  Standard_Integer BOPTools_AlgoTools::Dimension(const TopoDS_Shape& theS)
+Standard_Integer BOPTools_AlgoTools::Dimension(const TopoDS_Shape& theS)
 {
   Standard_Integer i, iRet, iRx0 = 0, iRx = 0;
   TopAbs_ShapeEnum aTS;
@@ -462,8 +459,8 @@ static
 //function : TreatCompound
 //purpose  : 
 //=======================================================================
-  void TreatCompound(const TopoDS_Shape& theC1, 
-                     BOPCol_ListOfShape& theLSX)
+void TreatCompound(const TopoDS_Shape& theC1, 
+                   BOPCol_ListOfShape& theLSX)
 {
   Standard_Integer aNbC1;
   TopAbs_ShapeEnum aType;