0024940: WOK: Cyclic dependency detected between: BOPInt IntTools
authorpkv <pkv@opencascade.com>
Mon, 26 May 2014 06:48:29 +0000 (10:48 +0400)
committerapn <apn@opencascade.com>
Thu, 29 May 2014 11:27:31 +0000 (15:27 +0400)
Classes  BOPInt_Context, BOPInt_ShrunkRange, BOPInt_Tools have been removed.
Package BOPInt has been removed
Classes IntTools_Context, IntTools_ShrunkRange have been added to replace corresponding BOPInt_ classes.
The classes provide same functionality as corresponding BOPInt_ classes.
Classes :
BOPAlgo_ArgumentAnalyzer
BOPAlgo_Builder
BOPAlgo_BuilderArea
BOPAlgo_BuilderFace
BOPAlgo_BuilderSolid
BOPAlgo_CheckerSI
BOPAlgo_PaveFiller
BOPAlgo_ShellSplitter
BOPTools_AlgoTools3D
BRepFill_TrimShellCorner
IntTools_BeanFaceIntersector
IntTools_EdgeFace
IntTools_FaceFace
IntTools_Tools
have been modified to use new classes IntTools_Context IntTools_ShrunkRange

Class IntTools_Tools has been modofied to provide the functionality that was in BOPInt_Tools.

45 files changed:
adm/UDLIST
src/BOPAlgo/BOPAlgo.cdl
src/BOPAlgo/BOPAlgo_ArgumentAnalyzer.cxx
src/BOPAlgo/BOPAlgo_Builder.cdl
src/BOPAlgo/BOPAlgo_BuilderArea.cdl
src/BOPAlgo/BOPAlgo_BuilderArea.cxx
src/BOPAlgo/BOPAlgo_BuilderFace.cxx
src/BOPAlgo/BOPAlgo_BuilderSolid.cxx
src/BOPAlgo/BOPAlgo_Builder_2.cxx
src/BOPAlgo/BOPAlgo_Builder_3.cxx
src/BOPAlgo/BOPAlgo_CheckerSI.cxx
src/BOPAlgo/BOPAlgo_CheckerSI_1.cxx
src/BOPAlgo/BOPAlgo_PaveFiller.cdl
src/BOPAlgo/BOPAlgo_PaveFiller.cxx
src/BOPAlgo/BOPAlgo_PaveFiller_2.cxx
src/BOPAlgo/BOPAlgo_PaveFiller_3.cxx
src/BOPAlgo/BOPAlgo_PaveFiller_4.cxx
src/BOPAlgo/BOPAlgo_PaveFiller_5.cxx
src/BOPAlgo/BOPAlgo_PaveFiller_6.cxx
src/BOPAlgo/BOPAlgo_PaveFiller_9.cxx
src/BOPAlgo/BOPAlgo_ShellSplitter.cxx
src/BOPInt/BOPInt.cdl [deleted file]
src/BOPInt/BOPInt_Tools.cdl [deleted file]
src/BOPInt/BOPInt_Tools.cxx [deleted file]
src/BOPTools/BOPTools.cdl
src/BOPTools/BOPTools_AlgoTools.cdl
src/BOPTools/BOPTools_AlgoTools.cxx
src/BOPTools/BOPTools_AlgoTools3D.cdl
src/BOPTools/BOPTools_AlgoTools3D.cxx
src/BRepFill/BRepFill_TrimShellCorner.cxx
src/IntTools/IntTools.cdl
src/IntTools/IntTools_BeanFaceIntersector.cdl
src/IntTools/IntTools_BeanFaceIntersector.cxx
src/IntTools/IntTools_Context.cdl [moved from src/BOPInt/BOPInt_Context.cdl with 89% similarity]
src/IntTools/IntTools_Context.cxx [moved from src/BOPInt/BOPInt_Context.cxx with 82% similarity]
src/IntTools/IntTools_EdgeFace.cdl
src/IntTools/IntTools_EdgeFace.cxx
src/IntTools/IntTools_FaceFace.cdl
src/IntTools/IntTools_FaceFace.cxx
src/IntTools/IntTools_ShrunkRange.cdl [moved from src/BOPInt/BOPInt_ShrunkRange.cdl with 89% similarity]
src/IntTools/IntTools_ShrunkRange.cxx [moved from src/BOPInt/BOPInt_ShrunkRange.cxx with 91% similarity]
src/IntTools/IntTools_Tools.cdl
src/IntTools/IntTools_Tools.cxx
src/QANewModTopOpe/QANewModTopOpe_Tools.cxx
src/TKBO/PACKAGES

index bff9496..9e6d767 100644 (file)
@@ -475,4 +475,3 @@ p Font
 p BOPAlgo
 p BOPDS
 p BOPCol
-p BOPInt
index 4b3be38..44c49cf 100644 (file)
@@ -28,7 +28,6 @@ uses
     IntSurf,
     --
     BOPDS, 
-    BOPInt, 
     BOPCol, 
     BOPTools 
 is   
index 113d41c..9109072 100644 (file)
@@ -47,7 +47,7 @@
 #include <IntTools_EdgeEdge.hxx>
 #include <IntTools_CommonPrt.hxx>
 
-#include <BOPInt_Context.hxx>
+#include <IntTools_Context.hxx>
 
 #include <BOPTools_AlgoTools3D.hxx>
 #include <BOPTools_AlgoTools.hxx>
@@ -76,7 +76,6 @@ myMergeEdgeMode(Standard_False),
 myContinuityMode(Standard_False),
 myEmpty1(Standard_False),
 myEmpty2(Standard_False)
-// myMergeFaceMode(Standard_False)
 {
 }
 
@@ -379,9 +378,9 @@ void BOPAlgo_ArgumentAnalyzer::TestSmallEdge()
 {
   Standard_Integer i = 0;
   BRepExtrema_DistShapeShape aDist;
-  Handle(BOPInt_Context) aCtx;
+  Handle(IntTools_Context) aCtx;
   //
-  aCtx = new BOPInt_Context;
+  aCtx = new IntTools_Context;
   
   for(i = 0; i < 2; i++) {
     const TopoDS_Shape& aS = (i == 0) ? myShape1 : myShape2;
@@ -816,12 +815,3 @@ void BOPAlgo_ArgumentAnalyzer::TestContinuity()
     }
   }
 }
-
-// ================================================================================
-// function: TestMergeFace
-// purpose:
-// ================================================================================
-// void BOPAlgo_ArgumentAnalyzer::TestMergeFace() 
-// {
-  // not implemented
-// }
index f28ffd7..b67b272 100644 (file)
@@ -32,7 +32,7 @@ uses
     MapOfShape from BOPCol, 
     DataMapOfShapeShape from BOPCol, 
     DataMapOfShapeListOfShape from BOPCol,  
-    Context from BOPInt,
+    Context from IntTools,
     PDS from BOPDS, 
     PaveFiller  from BOPAlgo,
     PPaveFiller from BOPAlgo 
@@ -218,7 +218,7 @@ fields
     myMapFence   : MapOfShape from BOPCol is protected; 
     myPaveFiller : PPaveFiller from BOPAlgo is protected;  
     myDS         : PDS from BOPDS is protected; 
-    myContext    : Context from BOPInt is protected;   
+    myContext    : Context from IntTools is protected;   
     myEntryPoint : Integer from Standard is protected;
     -- 
     myImages     : DataMapOfShapeListOfShape from BOPCol is protected;  
index a69a968..7d6fa78 100644 (file)
 -- commercial license or contractual agreement.
 
 deferred class BuilderArea from BOPAlgo 
-       inherits Algo from BOPAlgo 
-        
-       ---Purpose: The root class for algorithms to build  
-       --          faces/solids from set of edges/faces  
+     inherits Algo from BOPAlgo 
+  
+ ---Purpose: The root class for algorithms to build  
+     --          faces/solids from set of edges/faces  
 
 uses 
     Shape from TopoDS, 
     BaseAllocator from BOPCol, 
     ListOfShape from BOPCol,
     MapOfOrientedShape from BOPCol, 
-    Context  from BOPInt 
+    Context  from IntTools 
     
 --raises
 
 is 
     Initialize  
-       returns BuilderArea from BOPAlgo; 
+     returns BuilderArea from BOPAlgo; 
     ---C++: alias "Standard_EXPORT virtual ~BOPAlgo_BuilderArea();"  
      
     Initialize(theAllocator: BaseAllocator from BOPCol)   
-       returns BuilderArea from BOPAlgo; 
+     returns BuilderArea from BOPAlgo; 
      
     SetContext(me:out; 
-           theContext:Context from BOPInt);  
-       
+         theContext:Context from IntTools);  
+     
     Shapes(me) 
-       returns ListOfShape from BOPCol;   
+     returns ListOfShape from BOPCol;   
     ---C++:  return const &   
     ---C++: alias "Standard_EXPORT void SetShapes(const BOPCol_ListOfShape& theLS);"  
     
     Loops(me)  
-       returns ListOfShape from BOPCol; 
+     returns ListOfShape from BOPCol; 
     ---C++:  return const &   
      
     Areas(me) 
-       returns ListOfShape from BOPCol; 
+     returns ListOfShape from BOPCol; 
     ---C++:  return const &     
      
     PerformShapesToAvoid(me:out) 
-       is deferred protected; 
-        
+     is deferred protected; 
+  
     PerformLoops(me:out) 
-       is deferred protected;  
-        
+     is deferred protected;  
+  
     PerformAreas(me:out)   
-       is deferred protected;  
+     is deferred protected;  
 
     PerformInternalShapes(me:out)   
-       is deferred protected;  
+     is deferred protected;  
 
 fields  
-    myContext        :  Context from BOPInt is protected; 
+    myContext        :  Context from IntTools is protected; 
     myShapes         :  ListOfShape from BOPCol is protected;  
     myLoops          :  ListOfShape from BOPCol is protected;  
     myLoopsInternal  :  ListOfShape from BOPCol is protected;
     
     myAreas          :  ListOfShape from BOPCol is protected;  
     myShapesToAvoid  :  MapOfOrientedShape from BOPCol is protected;  
-    --
-                
-
 end BuilderArea; 
 
index 92d88fc..4614570 100644 (file)
 //function : 
 //purpose  : 
 //=======================================================================
-  BOPAlgo_BuilderArea::BOPAlgo_BuilderArea()
+BOPAlgo_BuilderArea::BOPAlgo_BuilderArea()
 :
   BOPAlgo_Algo(),
-  //myContext(NULL),
   myShapes(myAllocator),
   myLoops(myAllocator),
   myLoopsInternal(myAllocator),
 //function : 
 //purpose  : 
 //=======================================================================
-  BOPAlgo_BuilderArea::BOPAlgo_BuilderArea(const Handle(NCollection_BaseAllocator)& theAllocator)
+BOPAlgo_BuilderArea::BOPAlgo_BuilderArea
+  (const Handle(NCollection_BaseAllocator)& theAllocator)
 :
   BOPAlgo_Algo(theAllocator),
-  //myContext(NULL),
   myShapes(myAllocator),
   myLoops(myAllocator),
   myLoopsInternal(myAllocator),
 //function : ~
 //purpose  : 
 //=======================================================================
-  BOPAlgo_BuilderArea::~BOPAlgo_BuilderArea()
+BOPAlgo_BuilderArea::~BOPAlgo_BuilderArea()
 {
 }
 //=======================================================================
 //function : SetContext
 //purpose  : 
 //=======================================================================
-  void BOPAlgo_BuilderArea::SetContext(const Handle(BOPInt_Context)& theContext)
+void BOPAlgo_BuilderArea::SetContext
+  (const Handle(IntTools_Context)& theContext)
 {
   myContext=theContext;
 }
@@ -85,7 +85,7 @@
 //function : Shapes
 //purpose  : 
 //=======================================================================
-  const BOPCol_ListOfShape& BOPAlgo_BuilderArea::Shapes()const
+const BOPCol_ListOfShape& BOPAlgo_BuilderArea::Shapes()const
 {
   return myShapes;
 }
@@ -93,7 +93,7 @@
 //function : Loops
 //purpose  : 
 //=======================================================================
-  const BOPCol_ListOfShape& BOPAlgo_BuilderArea::Loops()const
+const BOPCol_ListOfShape& BOPAlgo_BuilderArea::Loops()const
 {
   return myLoops;
 }
 {
   return myAreas;
 }
-/*
-//=======================================================================
-//function :PerformShapesToAvoid
-//purpose  : 
-//=======================================================================
-  void BOPAlgo_BuilderArea::PerformShapesToAvoid()
-{
-}
-//=======================================================================
-//function : PerformLoops
-//purpose  : 
-//=======================================================================
-  void BOPAlgo_BuilderArea::PerformLoops()
-{
-}
-//=======================================================================
-//function : PerformAreas
-//purpose  : 
-//=======================================================================
-  void BOPAlgo_BuilderArea::PerformAreas()
-{
-}
-//=======================================================================
-//function : PerformInternalShapes
-//purpose  : 
-//=======================================================================
-  void BOPAlgo_BuilderArea::PerformInternalShapes()
-{
-}
-*/
index 5b8fe08..620885c 100644 (file)
@@ -44,7 +44,7 @@
 #include <TopExp_Explorer.hxx>
 
 #include <IntTools_FClass2d.hxx>
-#include <BOPInt_Context.hxx>
+#include <IntTools_Context.hxx>
 
 //
 #include <BOPTools_AlgoTools.hxx>
@@ -67,13 +67,13 @@ static
 static 
   Standard_Boolean IsInside(const TopoDS_Shape& ,
                             const TopoDS_Shape& ,
-                            Handle(BOPInt_Context)& );
+                            Handle(IntTools_Context)& );
 static
   void MakeInternalWires(const BOPCol_MapOfShape& ,
                          BOPCol_ListOfShape& );
 static 
   void GetWire(const TopoDS_Shape& , 
-              TopoDS_Shape& ); 
+        TopoDS_Shape& ); 
 //
 #include <NCollection_UBTreeFiller.hxx>
 #include <BOPCol_Box2DBndTree.hxx>
@@ -199,7 +199,7 @@ void BOPAlgo_BuilderFace::CheckData()
     return;
   }
   if (myContext.IsNull()) {
-    myContext = new BOPInt_Context;
+    myContext = new IntTools_Context;
   }
 }
 //=======================================================================
@@ -261,9 +261,6 @@ void BOPAlgo_BuilderFace::PerformShapesToAvoid()
       if (!myShapesToAvoid.Contains(aE)) {
         BOPTools::MapShapesAndAncestors(aE, TopAbs_VERTEX, TopAbs_EDGE, aMVE);
       }
-      //else {
-       //int a=0;
-      //}
     }
     aNbV=aMVE.Extent();
     //
@@ -393,7 +390,10 @@ void BOPAlgo_BuilderFace::PerformLoops()
   aItM.Initialize(myShapesToAvoid);
   for (; aItM.More(); aItM.Next()) {
     const TopoDS_Shape& aEE=aItM.Key();
-    BOPTools::MapShapesAndAncestors(aEE, TopAbs_VERTEX, TopAbs_EDGE, aVEMap);
+    BOPTools::MapShapesAndAncestors(aEE, 
+                                    TopAbs_VERTEX, 
+                                    TopAbs_EDGE, 
+                                    aVEMap);
   }
   //
   bFlag=Standard_True;
@@ -492,11 +492,11 @@ void BOPAlgo_BuilderFace::PerformAreas()
       bIsHole=aClsf.IsHole();
       if (bIsHole) {
         BOPTools::MapShapes(aWire, TopAbs_EDGE, aMHE);
-       //
-       bIsHole=Standard_True;
+          //
+          bIsHole=Standard_True;
       }
       else {
-       bIsHole=Standard_False;
+        bIsHole=Standard_False;
       }
     }
     //
@@ -557,8 +557,8 @@ void BOPAlgo_BuilderFace::PerformAreas()
       }
       //
       if (aInOutMap.IsBound (aHole)){
-       const TopoDS_Shape& aF2=aInOutMap(aHole);
-       if (IsInside(aF, aF2, myContext)) {
+        const TopoDS_Shape& aF2=aInOutMap(aHole);
+        if (IsInside(aF, aF2, myContext)) {
           aInOutMap.UnBind(aHole);
           aInOutMap.Bind (aHole, aF);
         }
@@ -769,7 +769,7 @@ void MakeInternalWires(const BOPCol_MapOfShape& theME,
 //=======================================================================
 Standard_Boolean IsInside(const TopoDS_Shape& theHole,
                           const TopoDS_Shape& theF2,
-                          Handle(BOPInt_Context)& theContext)
+                          Handle(IntTools_Context)& theContext)
 {
   Standard_Boolean bRet;
   Standard_Real aT, aU, aV;
index f8ff7d4..216d5f1 100644 (file)
@@ -66,7 +66,7 @@
 #include <BOPTools_CoupleOfShape.hxx>
 #include <BOPTools_AlgoTools.hxx>
 //
-#include <BOPInt_Context.hxx>
+#include <IntTools_Context.hxx>
 //
 #include <BOPAlgo_ShellSplitter.hxx>
 
@@ -75,11 +75,11 @@ static
                                  const BOPCol_IndexedMapOfShape& );
 static
   Standard_Boolean IsHole(const TopoDS_Shape& ,
-                          Handle(BOPInt_Context)& );
+                          Handle(IntTools_Context)& );
 static
   Standard_Boolean IsInside(const TopoDS_Shape& ,
                             const TopoDS_Shape& ,
-                            Handle(BOPInt_Context)& );
+                            Handle(IntTools_Context)& );
 static
   void MakeInternalShells(const BOPCol_MapOfShape& ,
                           BOPCol_ListOfShape& );
@@ -185,7 +185,7 @@ void BOPAlgo_BuilderSolid::Perform()
   myErrorStatus=0;
   //
   if (myContext.IsNull()) {
-    myContext=new BOPInt_Context;
+    myContext=new IntTools_Context;
   }
   //
   TopoDS_Compound aC;
@@ -381,8 +381,8 @@ void BOPAlgo_BuilderSolid::PerformLoops()
   for (; aItM.More(); aItM.Next()) {
     const TopoDS_Shape& aFF=aItM.Key();
     BOPTools::MapShapesAndAncestors(aFF, 
-                                   TopAbs_EDGE, TopAbs_FACE, 
-                                   aEFMap);
+        TopAbs_EDGE, TopAbs_FACE, 
+        aEFMap);
   }
   //
   aItM.Initialize(myShapesToAvoid);
@@ -472,7 +472,7 @@ void BOPAlgo_BuilderSolid::PerformAreas()
       if (bIsHole) {
         aHoleShells.Append(aShell);
         BOPTools::MapShapes(aShell, TopAbs_FACE, aMHF);
-       aSB.SetShape(aShell);
+        aSB.SetShape(aShell);
       }
       else {
         // make a growth solid from a shell
@@ -480,7 +480,7 @@ void BOPAlgo_BuilderSolid::PerformAreas()
         aBB.Add (aSolid, aShell);
         //
         aNewSolids.Append (aSolid);
-       aSB.SetShape(aSolid);
+        aSB.SetShape(aSolid);
       }
     }
     //
@@ -537,8 +537,8 @@ void BOPAlgo_BuilderSolid::PerformAreas()
       }
       //
       if (aInOutMap.IsBound (aHole)){
-       const TopoDS_Shape& aHole2=aInOutMap(aHole);
-       if (IsInside(aHole, aHole2, myContext)) {
+        const TopoDS_Shape& aHole2=aInOutMap(aHole);
+        if (IsInside(aHole, aHole2, myContext)) {
           aInOutMap.UnBind(aHole);
           aInOutMap.Bind (aHole, aSolid);
         }
@@ -657,8 +657,8 @@ void BOPAlgo_BuilderSolid::PerformInternalShapes()
     }
     aMEF.Clear();
     BOPTools::MapShapesAndAncestors(aSolid, 
-                                   TopAbs_EDGE, TopAbs_FACE, 
-                                   aMEF);
+        TopAbs_EDGE, TopAbs_FACE, 
+        aMEF);
     //
     // 2.1 Separate faces to process aMFP
     aMFP.Clear();
@@ -667,10 +667,10 @@ void BOPAlgo_BuilderSolid::PerformInternalShapes()
       const TopoDS_Face& aF=(*(TopoDS_Face*)(&aItMF.Key()));
       if (!aMFx.Contains(aF)) {
         if (BOPTools_AlgoTools::IsInternalFace(aF, 
-                                              aSolid, 
-                                              aMEF, 
-                                              1.e-14, 
-                                              myContext)) {
+            aSolid, 
+            aMEF, 
+            1.e-14, 
+            myContext)) {
           aMFP.Add(aF);
         }
       }
@@ -732,8 +732,8 @@ void MakeInternalShells(const BOPCol_MapOfShape& theMF,
   for (; aItM.More(); aItM.Next()) {
     const TopoDS_Shape& aF=aItM.Key();
     BOPTools::MapShapesAndAncestors(aF, 
-                                   TopAbs_EDGE, TopAbs_FACE, 
-                                   aMEF);
+        TopAbs_EDGE, TopAbs_FACE, 
+        aMEF);
   }
   //
   aItM.Initialize(theMF);
@@ -775,7 +775,7 @@ void MakeInternalShells(const BOPCol_MapOfShape& theMF,
 //purpose  : 
 //=======================================================================
 Standard_Boolean IsHole(const TopoDS_Shape& theS2,
-                        Handle(BOPInt_Context)& theContext)
+                        Handle(IntTools_Context)& theContext)
 {
   TopoDS_Solid *pS2=(TopoDS_Solid *)&theS2;
   BRepClass3d_SolidClassifier& aClsf=theContext->SolidClassifier(*pS2);
@@ -790,7 +790,7 @@ Standard_Boolean IsHole(const TopoDS_Shape& theS2,
 //=======================================================================
 Standard_Boolean IsInside(const TopoDS_Shape& theS1,
                           const TopoDS_Shape& theS2,
-                          Handle(BOPInt_Context)& theContext)
+                          Handle(IntTools_Context)& theContext)
 {
   TopExp_Explorer aExp;
   TopAbs_State aState;
@@ -808,7 +808,7 @@ Standard_Boolean IsInside(const TopoDS_Shape& theS1,
     BOPTools::MapShapes(*pS2, TopAbs_EDGE, aBounds);
     const TopoDS_Face& aF = (*(TopoDS_Face*)(&aExp.Current()));
     aState=BOPTools_AlgoTools::ComputeState(aF, *pS2, 1.e-14, 
-                                           aBounds, theContext);
+                                            aBounds, theContext);
   }
   return (aState==TopAbs_IN);
 }
index 57248f9..4e41f7a 100644 (file)
@@ -38,7 +38,7 @@
 #include <BOPCol_NCVector.hxx>
 #include <BOPCol_TBB.hxx>
 //
-#include <BOPInt_Context.hxx>
+#include <IntTools_Context.hxx>
 //
 #include <BOPDS_PaveBlock.hxx>
 #include <BOPDS_ShapeInfo.hxx>
@@ -132,9 +132,9 @@ class BOPAlgo_BuilderSDFaceFunctor {
   void operator()( const flexible_range<Standard_Integer>& aBR ) const {
     Standard_Boolean bFlag;
     Standard_Integer i, iBeg, iEnd;
-    Handle(BOPInt_Context) aContext;
+    Handle(IntTools_Context) aContext;
     //
-    aContext=new BOPInt_Context;
+    aContext=new IntTools_Context;
     //
     BOPAlgo_VectorOfPairOfShapeBoolean& aVPSB=*myPVPSB;
     //
@@ -223,11 +223,11 @@ class BOPAlgo_VFI {
     return myFlag;
   }
   //
-  void SetContext(const Handle(BOPInt_Context)& aContext) {
+  void SetContext(const Handle(IntTools_Context)& aContext) {
     myContext=aContext;
   }
   //
-  const Handle(BOPInt_Context)& Context()const {
+  const Handle(IntTools_Context)& Context()const {
     return myContext;
   }
   //
@@ -241,7 +241,7 @@ class BOPAlgo_VFI {
   Standard_Integer myFlag;
   TopoDS_Vertex myV;
   TopoDS_Face myF;
-  Handle(BOPInt_Context) myContext;
+  Handle(IntTools_Context) myContext;
 };
 //
 typedef BOPCol_NCVector<BOPAlgo_VFI> BOPAlgo_VectorOfVFI; 
@@ -249,13 +249,13 @@ typedef BOPCol_NCVector<BOPAlgo_VFI> BOPAlgo_VectorOfVFI;
 typedef BOPCol_TBBContextFunctor 
   <BOPAlgo_VFI,
   BOPAlgo_VectorOfVFI,
-  Handle(BOPInt_Context), 
-  BOPInt_Context> BOPAlgo_VFIFunctor;
+  Handle(IntTools_Context), 
+  IntTools_Context> BOPAlgo_VFIFunctor;
 //
 typedef BOPCol_TBBContextCnt 
   <BOPAlgo_VFIFunctor,
   BOPAlgo_VectorOfVFI,
-  Handle(BOPInt_Context)> BOPAlgo_VFICnt;
+  Handle(IntTools_Context)> BOPAlgo_VFICnt;
 //
 //=======================================================================
 //function : FillImagesFaces
index 5d5d272..724ac72 100644 (file)
@@ -52,7 +52,7 @@
 #include <BOPCol_NCVector.hxx>
 #include <BOPCol_TBB.hxx>
 //
-#include <BOPInt_Context.hxx>
+#include <IntTools_Context.hxx>
 //
 #include <BOPDS_DS.hxx>
 #include <BOPDS_ShapeInfo.hxx>
@@ -434,9 +434,8 @@ void BOPAlgo_Builder::BuildDraftSolid(const TopoDS_Shape& theSolid,
               theLIF.Append(aFSDx);
             }
             else {
-              bToReverse=BOPTools_AlgoTools::IsSplitToReverse(aFSDx, 
-        aF, 
-        myContext); 
+              bToReverse=BOPTools_AlgoTools::IsSplitToReverse
+                (aFSDx, aF, myContext); 
               if (bToReverse) {
                 aFSDx.Reverse();
               }
index 859b5c9..02693e4 100644 (file)
@@ -39,7 +39,7 @@
 #include <BOPDS_VectorOfInterfEF.hxx>
 #include <BOPDS_VectorOfInterfFF.hxx>
 
-#include <BOPInt_Context.hxx>
+#include <IntTools_Context.hxx>
 
 #include <BOPTools.hxx>
 #include <BOPTools_AlgoTools.hxx>
@@ -115,7 +115,7 @@ void BOPAlgo_CheckerSI::Init()
   myIterator=theIterSI;
   //
   // 3 myContext
-  myContext=new BOPInt_Context;
+  myContext=new IntTools_Context;
   //
   myErrorStatus=0;
 }
index 41f76f7..74b8f02 100644 (file)
@@ -20,7 +20,7 @@
 
 #include <BOPDS_DS.hxx>
 #include <BOPDS_IteratorSI.hxx>
-#include <BOPInt_Context.hxx>
+#include <IntTools_Context.hxx>
 
 #include <BOPDS_Interf.hxx>
 #include <TopoDS_Solid.hxx>
index 33eabd7..6ad7fe3 100644 (file)
@@ -38,7 +38,7 @@ uses
     DataMapOfIntegerReal from BOPCol, 
     DataMapOfIntegerInteger from BOPCol,
     --  
-    Context from BOPInt,
+    Context from IntTools,
     -- 
     SectionAttribute from BOPAlgo, 
     
@@ -68,7 +68,7 @@ is
      
     Create (theAllocator: BaseAllocator from BOPCol) 
       returns PaveFiller from BOPAlgo;   
-       
     DS(me:out) 
       returns DS from BOPDS; 
     ---C++:return  const &   
@@ -87,7 +87,7 @@ is
     ---C++: alias "Standard_EXPORT void SetArguments(const BOPCol_ListOfShape& theLS);" 
 
     Context(me:out) 
-      returns Context from BOPInt;  
+      returns Context from IntTools;  
        
     SetSectionAttribute(me:out; 
         theSecAttr : SectionAttribute from BOPAlgo); 
@@ -114,10 +114,10 @@ is
      
     PerformVF(me:out) 
       is virtual protected;  
-        
+  
     PerformEE(me:out) 
       is virtual protected; 
-         
+   
     PerformEF(me:out) 
       is virtual protected; 
      
@@ -133,10 +133,10 @@ is
         
     MakeBlocks(me:out) 
       is protected; 
-        
+  
     MakePCurves(me:out) 
       is protected; 
-        
+  
     ProcessDE(me:out) 
       is protected;  
        
@@ -147,14 +147,14 @@ is
     FillShrunkData(me:out; 
         theType1: ShapeEnum from TopAbs; 
         theType2: ShapeEnum from TopAbs) 
-      is protected;     
+      is protected;   
  
     PerformVerticesEE(me:out; 
         theMVCPB:out IndexedDataMapOfShapeCoupleOfPaveBlocks from BOPDS; 
         theAllocator:out BaseAllocator from BOPCol) 
       returns Integer from Standard 
       is protected; 
-        
+  
     PerformVerticesEF(me:out; 
         theMVCPB:out IndexedDataMapOfShapeCoupleOfPaveBlocks from BOPDS; 
         theAllocator:out BaseAllocator from BOPCol) 
@@ -166,14 +166,14 @@ is
         theMIF:MapOfInteger from BOPCol) 
       returns Boolean from Standard 
       is protected;  
-         
+   
     CheckFacePaves(myclass; 
         theN:Integer from Standard; 
         theMIFOn:MapOfInteger from BOPCol; 
         theMIFIn:MapOfInteger from BOPCol) 
       returns Boolean from Standard 
       is protected;  
-        
+  
     IsExistingVertex(me; 
         theP:Pnt from gp; 
         theTol:Real from Standard; 
@@ -210,7 +210,7 @@ is
     -- 1 - checks only EE; 
     -- 2 - checks only EF;
     -- other - checks both types of intersections.
-        
+  
     PutBoundPaveOnCurve(me:out;  
         theF1: Face from TopoDS;  
         theF2: Face from TopoDS;  
@@ -263,12 +263,12 @@ is
         theLPB: ListOfPaveBlock from BOPDS; 
         thePB: PaveBlock from BOPDS) 
       is protected; 
-        
+  
     MakeSplitEdge(me:out;  
         theV:Integer from Standard; 
         theF:Integer from Standard) 
       is protected;  
-        
+      
     GetEFPnts(me:out;
         nF1 : Integer from Standard;
         nF2 : Integer from Standard;
@@ -348,7 +348,7 @@ is
         theMVB     : MapOfInteger from BOPCol; 
         theMPB     : out MapOfPaveBlock from BOPDS)
       is  protected; 
-    ---Purpose:             
+    ---Purpose:       
     -- Adds the existing edges from the map <theMPBOnIn> which interfere  
     -- with the vertices from <theMVB> map to the post treatment of section edges.
  
@@ -449,7 +449,7 @@ fields
     myArguments   : ListOfShape from BOPCol is protected;  
     myDS          : PDS from BOPDS is protected; 
     myIterator    : PIterator from BOPDS is protected; 
-    myContext     : Context from BOPInt is protected;   
+    myContext     : Context from IntTools is protected;   
     mySectionAttribute : SectionAttribute from BOPAlgo is protected;
 
 end PaveFiller;
index cb12233..3d9b696 100644 (file)
@@ -22,7 +22,7 @@
 
 #include <NCollection_BaseAllocator.hxx>
 
-#include <BOPInt_Context.hxx>
+#include <IntTools_Context.hxx>
 #include <BOPDS_DS.hxx>
 #include <BOPDS_Iterator.hxx>
 
@@ -93,7 +93,7 @@ BOPDS_PDS BOPAlgo_PaveFiller::PDS()
 //function : Context
 //purpose  : 
 //=======================================================================
-Handle(BOPInt_Context) BOPAlgo_PaveFiller::Context()
+Handle(IntTools_Context) BOPAlgo_PaveFiller::Context()
 {
   return myContext;
 }
@@ -150,7 +150,7 @@ void BOPAlgo_PaveFiller::Init()
   myIterator->Prepare();
   //
   // 3 myContext
-  myContext=new BOPInt_Context;
+  myContext=new IntTools_Context;
   //
   myErrorStatus=0;
 }
index f72f5f7..a85a070 100644 (file)
@@ -24,7 +24,7 @@
 #include <BOPCol_NCVector.hxx>
 #include <BOPCol_TBB.hxx>
 
-#include <BOPInt_Context.hxx>
+#include <IntTools_Context.hxx>
 
 #include <BOPDS_Iterator.hxx>
 #include <BOPDS_VectorOfInterfVE.hxx>
@@ -87,11 +87,11 @@ class BOPAlgo_VertexEdge {
     return myT;
   }
   //
-  void SetContext(const Handle(BOPInt_Context)& aContext) {
+  void SetContext(const Handle(IntTools_Context)& aContext) {
     myContext=aContext;
   }
   //
-  const Handle(BOPInt_Context)& Context()const {
+  const Handle(IntTools_Context)& Context()const {
     return myContext;
   }
   //
@@ -107,7 +107,7 @@ class BOPAlgo_VertexEdge {
   Standard_Real myT;
   TopoDS_Vertex myV;
   TopoDS_Edge myE;
-  Handle(BOPInt_Context) myContext;
+  Handle(IntTools_Context) myContext;
 };
 //=======================================================================
 typedef BOPCol_NCVector
@@ -116,13 +116,13 @@ typedef BOPCol_NCVector
 typedef BOPCol_TBBContextFunctor 
   <BOPAlgo_VertexEdge,
   BOPAlgo_VectorOfVertexEdge,
-  Handle(BOPInt_Context), 
-  BOPInt_Context> BOPAlgo_VertexEdgeFunctor;
+  Handle(IntTools_Context), 
+  IntTools_Context> BOPAlgo_VertexEdgeFunctor;
 //
 typedef BOPCol_TBBContextCnt 
   <BOPAlgo_VertexEdgeFunctor,
   BOPAlgo_VectorOfVertexEdge,
-  Handle(BOPInt_Context)> BOPAlgo_VertexEdgeCnt;
+  Handle(IntTools_Context)> BOPAlgo_VertexEdgeCnt;
 //
 //=======================================================================
 // function: PerformVE
index c94d3c9..f7f48a0 100644 (file)
@@ -49,9 +49,9 @@
 #include <BOPCol_NCVector.hxx>
 #include <BOPCol_TBB.hxx>
 //
-#include <BOPInt_Context.hxx>
-#include <BOPInt_ShrunkRange.hxx>
-#include <BOPInt_Tools.hxx>
+#include <IntTools_Context.hxx>
+#include <IntTools_ShrunkRange.hxx>
+#include <IntTools_Tools.hxx>
 //
 #include <BOPDS_DataMapOfPaveBlockListOfPaveBlock.hxx>
 #include <BOPDS_MapOfPaveBlock.hxx>
@@ -216,11 +216,11 @@ class BOPAlgo_PVE {
     return myT;
   }
   //
-  void SetContext(const Handle(BOPInt_Context)& aContext) {
+  void SetContext(const Handle(IntTools_Context)& aContext) {
     myContext=aContext;
   }
   //
-  const Handle(BOPInt_Context)& Context()const {
+  const Handle(IntTools_Context)& Context()const {
     return myContext;
   }
   //
@@ -236,7 +236,7 @@ class BOPAlgo_PVE {
   TopoDS_Vertex myV;
   TopoDS_Edge myE;
   Handle(BOPDS_PaveBlock) myPB;
-  Handle(BOPInt_Context) myContext;
+  Handle(IntTools_Context) myContext;
 };
 //=======================================================================
 typedef BOPCol_NCVector
@@ -245,13 +245,13 @@ typedef BOPCol_NCVector
 typedef BOPCol_TBBContextFunctor 
   <BOPAlgo_PVE,
   BOPAlgo_VectorOfPVE,
-  Handle(BOPInt_Context), 
-  BOPInt_Context> BOPAlgo_PVEFunctor;
+  Handle(IntTools_Context), 
+  IntTools_Context> BOPAlgo_PVEFunctor;
 //
 typedef BOPCol_TBBContextCnt 
   <BOPAlgo_PVEFunctor,
   BOPAlgo_VectorOfPVE,
-  Handle(BOPInt_Context)> BOPAlgo_PVECnt;
+  Handle(IntTools_Context)> BOPAlgo_PVECnt;
 /////////////////////////////////////////////////////////////////////////
 //=======================================================================
 // function: PerformEE
@@ -394,20 +394,20 @@ void BOPAlgo_PaveFiller::PerformEE()
           TopoDS_Vertex aVnew;
           IntTools_Range aCR1, aCR2;
           //
-          BOPInt_Tools::VertexParameters(aCPart, aT1, aT2);
+          IntTools_Tools::VertexParameters(aCPart, aT1, aT2);
           aTol = Precision::Confusion();
           aCR1 = aCPart.Range1();
           aCR2 = aCPart.Ranges2()(1);
           // 
           //decide to keep the pave or not
-          bIsOnPave[0] = BOPInt_Tools::IsOnPave1(aT1, aR11, aTol) ||
-            BOPInt_Tools::IsOnPave1(aR11.First(), aCR1, aTol);
-          bIsOnPave[1] = BOPInt_Tools::IsOnPave1(aT1, aR12, aTol) || 
-            BOPInt_Tools::IsOnPave1(aR12.Last(), aCR1, aTol);
-          bIsOnPave[2] = BOPInt_Tools::IsOnPave1(aT2, aR21, aTol) ||
-            BOPInt_Tools::IsOnPave1(aR21.First(), aCR2, aTol);
-          bIsOnPave[3] = BOPInt_Tools::IsOnPave1(aT2, aR22, aTol) ||
-            BOPInt_Tools::IsOnPave1(aR22.Last(), aCR2, aTol);
+          bIsOnPave[0] = IntTools_Tools::IsOnPave1(aT1, aR11, aTol) ||
+            IntTools_Tools::IsOnPave1(aR11.First(), aCR1, aTol);
+          bIsOnPave[1] = IntTools_Tools::IsOnPave1(aT1, aR12, aTol) || 
+            IntTools_Tools::IsOnPave1(aR12.Last(), aCR1, aTol);
+          bIsOnPave[2] = IntTools_Tools::IsOnPave1(aT2, aR21, aTol) ||
+            IntTools_Tools::IsOnPave1(aR21.First(), aCR2, aTol);
+          bIsOnPave[3] = IntTools_Tools::IsOnPave1(aT2, aR22, aTol) ||
+            IntTools_Tools::IsOnPave1(aR22.Last(), aCR2, aTol);
           //
           aPB1->Indices(nV[0], nV[1]);
           aPB2->Indices(nV[2], nV[3]);
@@ -824,7 +824,7 @@ void BOPAlgo_PaveFiller::FillShrunkData(Handle(BOPDS_PaveBlock)& thePB)
 {
   Standard_Integer nE, nV1, nV2, iErr;
   Standard_Real aT1, aT2, aTS1, aTS2;
-  BOPInt_ShrunkRange aSR;
+  IntTools_ShrunkRange aSR;
   //
   myErrorStatus=0;
   myWarningStatus = 0;
index 26fe905..ae274ba 100644 (file)
@@ -29,7 +29,7 @@
 #include <BOPCol_NCVector.hxx>
 #include <BOPCol_TBB.hxx>
 //
-#include <BOPInt_Context.hxx>
+#include <IntTools_Context.hxx>
 //
 #include <BOPDS_Iterator.hxx>
 #include <BOPDS_VectorOfInterfVF.hxx>
@@ -94,11 +94,11 @@ class BOPAlgo_VertexFace {
     aT2=myT2;
   }
   //
-  void SetContext(const Handle(BOPInt_Context)& aContext) {
+  void SetContext(const Handle(IntTools_Context)& aContext) {
     myContext=aContext;
   }
   //
-  const Handle(BOPInt_Context)& Context()const {
+  const Handle(IntTools_Context)& Context()const {
     return myContext;
   }
   //
@@ -115,7 +115,7 @@ class BOPAlgo_VertexFace {
   Standard_Real myT2;
   TopoDS_Vertex myV;
   TopoDS_Face myF;
-  Handle(BOPInt_Context) myContext;
+  Handle(IntTools_Context) myContext;
 };
 //=======================================================================
 typedef BOPCol_NCVector<BOPAlgo_VertexFace>
@@ -124,13 +124,13 @@ typedef BOPCol_NCVector<BOPAlgo_VertexFace>
 typedef BOPCol_TBBContextFunctor 
   <BOPAlgo_VertexFace,
   BOPAlgo_VectorOfVertexFace,
-  Handle(BOPInt_Context), 
-  BOPInt_Context> BOPAlgo_VertexFaceFunctor;
+  Handle(IntTools_Context), 
+  IntTools_Context> BOPAlgo_VertexFaceFunctor;
 //
 typedef BOPCol_TBBContextCnt 
   <BOPAlgo_VertexFaceFunctor,
   BOPAlgo_VectorOfVertexFace,
-  Handle(BOPInt_Context)> BOPAlgo_VertexFaceCnt;
+  Handle(IntTools_Context)> BOPAlgo_VertexFaceCnt;
 //
 //=======================================================================
 // function: PerformVF
index 6b1aeb4..2949177 100644 (file)
@@ -40,8 +40,8 @@
 #include <BOPCol_NCVector.hxx>
 #include <BOPCol_TBB.hxx>
 //
-#include <BOPInt_Context.hxx>
-#include <BOPInt_Tools.hxx>
+#include <IntTools_Context.hxx>
+#include <IntTools_Tools.hxx>
 //
 #include <BOPDS_Interf.hxx>
 #include <BOPDS_Iterator.hxx>
@@ -110,13 +110,13 @@ typedef BOPCol_NCVector<BOPAlgo_EdgeFace> BOPAlgo_VectorOfEdgeFace;
 typedef BOPCol_TBBContextFunctor 
   <BOPAlgo_EdgeFace,
   BOPAlgo_VectorOfEdgeFace,
-  Handle(BOPInt_Context), 
-  BOPInt_Context> BOPAlgo_EdgeFaceFunctor;
+  Handle(IntTools_Context), 
+  IntTools_Context> BOPAlgo_EdgeFaceFunctor;
 //
 typedef BOPCol_TBBContextCnt 
   <BOPAlgo_EdgeFaceFunctor,
   BOPAlgo_VectorOfEdgeFace,
-  Handle(BOPInt_Context)> BOPAlgo_EdgeFaceCnt;
+  Handle(IntTools_Context)> BOPAlgo_EdgeFaceCnt;
 //
 //=======================================================================
 //function : PerformEF
@@ -270,7 +270,7 @@ void BOPAlgo_PaveFiller::PerformEF()
           Standard_Real aT, aTolToDecide; 
           TopoDS_Vertex aVnew;
           //
-          BOPInt_Tools::VertexParameter(aCPart, aT);
+          IntTools_Tools::VertexParameter(aCPart, aT);
           BOPTools_AlgoTools::MakeNewVertex(aE, aT, aF, aVnew);
           //
           const IntTools_Range& aR=aCPart.Range1();
@@ -278,8 +278,8 @@ void BOPAlgo_PaveFiller::PerformEF()
           //
           IntTools_Range aR1(aT1,anewSR.First()),aR2(anewSR.Last(), aT2);
           //
-          bIsOnPave[0]=BOPInt_Tools::IsInRange(aR1, aR, aTolToDecide); 
-          bIsOnPave[1]=BOPInt_Tools::IsInRange(aR2, aR, aTolToDecide); 
+          bIsOnPave[0]=IntTools_Tools::IsInRange(aR1, aR, aTolToDecide); 
+          bIsOnPave[1]=IntTools_Tools::IsInRange(aR2, aR, aTolToDecide); 
           //
           if (bIsOnPave[0] && bIsOnPave[1]) {
             bV[0]=CheckFacePaves(nV[0], aMIFOn, aMIFIn);
index 9772be2..ca7c7b2 100644 (file)
@@ -65,8 +65,8 @@
 #include <BOPCol_NCVector.hxx>
 #include <BOPCol_TBB.hxx>
 
-#include <BOPInt_Context.hxx>
-#include <BOPInt_Tools.hxx>
+#include <IntTools_Context.hxx>
+#include <IntTools_Tools.hxx>
 
 #include <BOPDS_Interf.hxx>
 #include <BOPDS_Iterator.hxx>
@@ -89,7 +89,7 @@
 #include <BOPAlgo_Tools.hxx>
 #include <BRepBuilderAPI_MakeVertex.hxx>
 #include <TopExp.hxx>
-#include <BOPInt_ShrunkRange.hxx>
+#include <IntTools_ShrunkRange.hxx>
 #include <BOPDS_DataMapOfPaveBlockListOfPaveBlock.hxx>
 
 static void ToleranceFF(const BRepAdaptor_Surface& aBAS1,
@@ -313,7 +313,7 @@ void BOPAlgo_PaveFiller::PerformFF()
         //
         const IntTools_Curve& aIC=aCvsX(i);
         const Handle(Geom_Curve)& aC3D= aIC.Curve();
-        bValid=BOPInt_Tools::CheckCurve(aC3D, aTolR3D, aBox);
+        bValid=IntTools_Tools::CheckCurve(aC3D, aTolR3D, aBox);
         if (bValid) {
           iC=aVNC.Append()-1;
           BOPDS_Curve& aNC=aVNC(iC);
index 88e0a7f..2cbdec3 100644 (file)
 #include <BOPDS_Iterator.hxx>
 #include <BOPDS_ListOfPaveBlock.hxx>
 
-#include <BOPInt_ShrunkRange.hxx>
+#include <IntTools_ShrunkRange.hxx>
 
 //=======================================================================
 //class    : BOPAlgo_ShrunkRange
 //purpose  : 
 //=======================================================================
-class BOPAlgo_ShrunkRange : public BOPInt_ShrunkRange {
+class BOPAlgo_ShrunkRange : public IntTools_ShrunkRange {
  public:
   BOPAlgo_ShrunkRange() 
-  : BOPInt_ShrunkRange(),
+  : IntTools_ShrunkRange(),
     myWarningStatus(0) {
   }
   //
@@ -56,7 +56,7 @@ class BOPAlgo_ShrunkRange : public BOPInt_ShrunkRange {
     //
     myWarningStatus=0;
     //
-    BOPInt_ShrunkRange::Perform();
+    IntTools_ShrunkRange::Perform();
     if (myErrorStatus) {
       myWarningStatus=1;
     }
@@ -78,13 +78,13 @@ typedef BOPCol_NCVector
 typedef BOPCol_TBBContextFunctor 
   <BOPAlgo_ShrunkRange,
   BOPAlgo_VectorOfShrunkRange,
-  Handle(BOPInt_Context), 
-  BOPInt_Context> BOPAlgo_ShrunkRangeFunctor;
+  Handle(IntTools_Context), 
+  IntTools_Context> BOPAlgo_ShrunkRangeFunctor;
 //
 typedef BOPCol_TBBContextCnt 
   <BOPAlgo_ShrunkRangeFunctor,
   BOPAlgo_VectorOfShrunkRange,
-  Handle(BOPInt_Context)> BOPAlgo_ShrunkRangeCnt;
+  Handle(IntTools_Context)> BOPAlgo_ShrunkRangeCnt;
 //
 //=======================================================================
 // function: FillShrunkData
index 78d7078..b1b8a3b 100644 (file)
@@ -32,7 +32,7 @@
 #include <BOPCol_NCVector.hxx>
 #include <BOPCol_IndexedDataMapOfShapeListOfShape.hxx>
 //
-#include <BOPInt_Context.hxx>
+#include <IntTools_Context.hxx>
 //
 #include <BOPTools.hxx>
 #include <BOPTools_AlgoTools.hxx>
@@ -320,7 +320,7 @@ void BOPAlgo_ShellSplitter::SplitBlock(BOPTools_ConnexityBlock& aCB)
   BOPCol_MapOfOrientedShape AddedFacesMap;
   BOPCol_IndexedDataMapOfShapeListOfShape aEFMap, aMEFP;
   // 
-  Handle (BOPInt_Context) aContext=new BOPInt_Context;
+  Handle (IntTools_Context) aContext=new IntTools_Context;
   //
   const BOPCol_ListOfShape& myShapes=aCB.Shapes();
   //
diff --git a/src/BOPInt/BOPInt.cdl b/src/BOPInt/BOPInt.cdl
deleted file mode 100644 (file)
index 4ee819b..0000000
+++ /dev/null
@@ -1,46 +0,0 @@
--- 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.
-
-package BOPInt 
-
-       ---Purpose: 
-
-uses 
-     
-    gp,  
-    Bnd,
-    TopAbs, 
-    Geom,  
-    GeomAPI, 
-    Geom2dHatch,     
-    BRepClass3d,
-    TopoDS, 
-    TopTools, 
-    IntTools,  
-    --              
-    BOPCol 
-
-is 
-    --
-    -- classes 
-    -- 
-    class Context;
-    --class Range;
-    class ShrunkRange;
-    class Tools;
-    --
-    --  pointers
-    --
-    
-end BOPInt;
diff --git a/src/BOPInt/BOPInt_Tools.cdl b/src/BOPInt/BOPInt_Tools.cdl
deleted file mode 100644 (file)
index 6026c3a..0000000
+++ /dev/null
@@ -1,84 +0,0 @@
--- 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.
-
-class Tools from BOPInt 
-
----Purpose: 
-
-uses 
-    Box from Bnd,
-    Lin from gp, 
-    Pln from gp, 
-    Pnt from gp, 
-    Curve from Geom, 
-         
-    Edge from TopoDS, 
-    Face from TopoDS,
-    Range from IntTools, 
-    CommonPrt from IntTools
---raises
-
-is 
-    
-    CheckCurve(myclass; 
-        theC:Curve from Geom;  
-        theTol:Real from Standard; 
-        theBox:out Box from Bnd) 
-    returns Boolean from Standard;   
-     
-    IsOnPave(myclass; 
-        theT:Real from Standard;  
-        theRange:Range from IntTools; 
-        theTol: Real from Standard) 
-    returns Boolean from Standard;  
-
-    VertexParameters(myclass; 
-        theCP:CommonPrt from IntTools; 
-        theT1:out Real from Standard;  
-        theT2:out Real from Standard);  
-
-    VertexParameter(myclass; 
-        theCP:CommonPrt from IntTools; 
-        theT:out Real from Standard); 
-    IsOnPave1(myclass; 
-        theT:Real from Standard;  
-        theRange:Range from IntTools; 
-        theTol: Real from Standard) 
-    returns Boolean from Standard;     
-      
-    IsInRange(myclass;
-        theRRef : Range from IntTools; 
-        theR    : Range from IntTools; 
-        theTol  : Real  from Standard) 
-    returns Boolean from Standard;      
-    ---Purpose:  Checks if the range <theR> interfere with the range <theRRef>
-    
-    SegPln(myclass; 
-        theLin   :  Lin from gp; 
-        theTLin1 :  Real from Standard; 
-        theTLin2 :  Real from Standard; 
-        theTolLin:  Real from Standard;   
-        thePln   :  Pln  from gp; 
-        theTolPln:  Real from Standard; 
-        theP     :out Pnt from gp;   
-        theT     :out Real from Standard;  
-        theTolP  :out Real from Standard; 
-        theTmin  :out Real from Standard; 
-        theTmax  :out Real from Standard) 
-    returns Integer from Standard;     
---fields
-
-end Tools;
diff --git a/src/BOPInt/BOPInt_Tools.cxx b/src/BOPInt/BOPInt_Tools.cxx
deleted file mode 100644 (file)
index 0b769dd..0000000
+++ /dev/null
@@ -1,218 +0,0 @@
-// 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 <BOPInt_Tools.ixx>
-
-#include <gp_Pnt.hxx>
-#include <BndLib_Add3dCurve.hxx>
-#include <Bnd_Box.hxx>
-#include <Geom_Curve.hxx>
-#include <GeomAdaptor_Curve.hxx>
-
-//=======================================================================
-//function : CheckCurve
-//purpose  : 
-//=======================================================================
-  Standard_Boolean BOPInt_Tools::CheckCurve(const Handle (Geom_Curve)& aC3D,
-                                           const Standard_Real aTolR3D,
-                                           Bnd_Box& aBox)
-{
-  Standard_Boolean bRet;  
-  Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax, dX, dY, dZ;
-  Standard_Real dS, aTol;
-  GeomAdaptor_Curve aGAC;
-  //
-  aGAC.Load(aC3D);
-  BndLib_Add3dCurve::Add(aGAC, aTolR3D, aBox);
-  // 910/B1
-  aBox.Get(aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
-  dX=aXmax-aXmin;
-  dY=aYmax-aYmin;
-  dZ=aZmax-aZmin;
-  dS=1.e-12;
-  aTol=2.*aTolR3D+dS;
-  bRet=(dX>aTol ||  dY>aTol || dZ>aTol);
-  //
-  return bRet;
-}
-
-
-//=======================================================================
-//function : IsOnPave
-//purpose  : 
-//=======================================================================
-  Standard_Boolean BOPInt_Tools::IsOnPave(const Standard_Real aT1,
-                                         const IntTools_Range& aRange,
-                                         const Standard_Real aTolerance)
-{
-  Standard_Boolean firstisonpave1, firstisonpave2, bIsOnPave;
-  //
-  firstisonpave1  = (Abs(aRange.First() - aT1) < aTolerance);
-  firstisonpave2  = (Abs(aRange.Last()  - aT1) < aTolerance);
-  bIsOnPave=(firstisonpave1 || firstisonpave2);
-  return bIsOnPave;
-}
-//=======================================================================
-// function: VertexParameters
-// purpose: 
-//=======================================================================
-  void BOPInt_Tools::VertexParameters(const IntTools_CommonPrt& aCPart,
-                                     Standard_Real& aT1, 
-                                     Standard_Real& aT2)
-{
-  const IntTools_Range& aR1=aCPart.Range1();
-  aT1=0.5*(aR1.First()+aR1.Last());
-  //
-  if((aCPart.VertexParameter1() >= aR1.First()) &&
-     (aCPart.VertexParameter1() <= aR1.Last())) {
-    aT1 = aCPart.VertexParameter1();
-  }
-  //
-  const IntTools_SequenceOfRanges& aRanges2=aCPart.Ranges2();
-  const IntTools_Range& aR2=aRanges2(1);
-  aT2=0.5*(aR2.First()+aR2.Last());
-  //
-  if((aCPart.VertexParameter2() >= aR2.First()) &&
-     (aCPart.VertexParameter2() <= aR2.Last())) {
-    aT2 = aCPart.VertexParameter2();
-  }
-}
-//=======================================================================
-// function: VertexParameter
-// purpose: 
-//=======================================================================
-  void BOPInt_Tools::VertexParameter(const IntTools_CommonPrt& aCPart,
-                                    Standard_Real& aT)
-{
-  const IntTools_Range& aR=aCPart.Range1();
-  aT=0.5*(aR.First()+aR.Last());
-  if((aCPart.VertexParameter1() >= aR.First()) &&
-     (aCPart.VertexParameter1() <= aR.Last())) {
-    aT = aCPart.VertexParameter1();
-  }
-}
-//=======================================================================
-// function: IsOnPave1
-// purpose: 
-//=======================================================================
-  Standard_Boolean BOPInt_Tools::IsOnPave1(const Standard_Real aTR,
-                                          const IntTools_Range& aCPRange,
-                                          const Standard_Real aTolerance)
-{
-  Standard_Boolean bIsOnPave;
-  Standard_Real aT1, aT2, dT1, dT2;
-  //
-  aT1=aCPRange.First();
-  aT2=aCPRange.Last();
-  bIsOnPave=(aTR>=aT1 && aTR<=aT1);
-  if (bIsOnPave) {
-    return bIsOnPave;
-  }
-  //
-  dT1=Abs(aTR-aT1);  
-  dT2=Abs(aTR-aT2);
-  bIsOnPave=(dT1<=aTolerance || dT2<=aTolerance);
-  return bIsOnPave;
-}
-
-//=======================================================================
-// function: IsInRange
-// purpose: 
-//=======================================================================
-  Standard_Boolean BOPInt_Tools::IsInRange(const IntTools_Range& aRRef,
-                                           const IntTools_Range& aR,
-                                           const Standard_Real aTolerance)
-{
-  Standard_Boolean bIsIn;
-  Standard_Real aT1, aT2, aTRef1, aTRef2;
-  //
-  aR.Range(aT1, aT2);
-  aRRef.Range(aTRef1, aTRef2);
-  //
-  aTRef1-=aTolerance;
-  aTRef2+=aTolerance;
-  //
-  bIsIn = (aT1>=aTRef1 && aT1<=aTRef2) ||
-          (aT2>=aTRef1 && aT2<=aTRef2);
-  //
-  return bIsIn;
-}
-
-//=======================================================================
-//function : SegPln
-//purpose  : 
-//=======================================================================
-  Standard_Integer BOPInt_Tools::SegPln(const gp_Lin& theLin,
-                                       const Standard_Real theTLin1,
-                                       const Standard_Real theTLin2,
-                                       const Standard_Real theTolLin,
-                                       const gp_Pln& thePln,
-                                       const Standard_Real theTolPln,
-                                       gp_Pnt& theP,
-                                       Standard_Real& theTP,
-                                       Standard_Real& theTolP,
-                                       Standard_Real& theTPmin,
-                                       Standard_Real& theTPmax)
-{
-  Standard_Integer iRet;
-  Standard_Real aTol, aA, aB, aC, aD, aE, aH, aTP, aDist1, aDist2;
-  gp_Pnt aP1, aP2;
-  //
-  iRet=0;
-  aTol=theTolLin+theTolPln;
-  //
-  const gp_Ax3& aPosPln=thePln.Position();
-  const gp_Dir& aDirPln=aPosPln.Direction();
-  const gp_Pnt& aLocPln=aPosPln.Location();
-  //
-  const gp_Dir& aDirLin=theLin.Direction();
-  const gp_Pnt& aLocLin=theLin.Location();
-  //
-  aP1.SetXYZ(aLocLin.XYZ()+theTLin1*aDirLin.XYZ());
-  aDist1=aDirPln.X()*(aP1.X()-aLocPln.X())+
-         aDirPln.Y()*(aP1.Y()-aLocPln.Y())+
-         aDirPln.Z()*(aP1.Z()-aLocPln.Z());
-  //
-  aP2.SetXYZ(aLocLin.XYZ()+theTLin2*aDirLin.XYZ());
-  aDist2=aDirPln.X()*(aP2.X()-aLocPln.X())+
-         aDirPln.Y()*(aP2.Y()-aLocPln.Y())+
-         aDirPln.Z()*(aP2.Z()-aLocPln.Z());
-  //
-  if (aDist1<aTol && aDist2<aTol){
-    iRet=1; // common block
-    return iRet;
-  }
-  //
-  if (aDist1*aDist2 > 0.) {
-    iRet=2; // segment lays on one side to the Plane
-    return iRet;
-  } 
-  //
-  thePln.Coefficients(aA, aB, aC, aD);
-  aE=aA*aLocLin.X()+aB*aLocLin.Y()+aC*aLocLin.Z()+aD;
-  aH=aA*aDirLin.X()+aB*aDirLin.Y()+aC*aDirLin.Z();
-  aTP=-aE/aH;
-  if (aTP < theTLin1-aTol || aTP > theTLin2+aTol) {
-    iRet=3; // no intersections due to range of the Line
-    return iRet;
-  }
-  //
-  theTP=aTP;
-  theP.SetXYZ(aLocLin.XYZ()+aTP*aDirLin.XYZ());
-  theTolP=aTol;
-  theTPmin=theTP-theTolPln;
-  theTPmax=theTP+theTolPln;
-  iRet=0; // intersection point
-  return iRet;
-}
index 8a4f30c..5fd71b0 100644 (file)
@@ -29,8 +29,7 @@ uses
     IntTools,   
     ProjLib,
     --                 
-    BOPCol, 
-    BOPInt 
+    BOPCol 
 is 
 
     -- 
index d4db671..6425c57 100644 (file)
@@ -38,7 +38,7 @@ uses
     ListOfShape from BOPCol,  
     IndexedMapOfShape from BOPCol,
     IndexedDataMapOfShapeListOfShape from BOPCol,  
-    Context from BOPInt,     
+    Context from IntTools,     
     ListOfCoupleOfShape from BOPTools, 
     Range from IntTools
     
@@ -90,7 +90,7 @@ is
     IsSplitToReverse(myclass;  
             theSplit   :  Shape from TopoDS; 
             theShape   :  Shape from TopoDS; 
-            theContext:out Context from BOPInt)  
+            theContext:out Context from IntTools)  
     ---Purpose: Returns True if the shape theSplit has opposite 
     --          direction than theShape 
     --          theContext - cashed geometrical tools
@@ -99,7 +99,7 @@ is
     IsSplitToReverse(myclass;  
             theSplit  :  Face from TopoDS; 
             theShape  :  Face from TopoDS; 
-            theContext:out Context from BOPInt) 
+            theContext:out Context from IntTools) 
     ---Purpose: Returns True if normal direction of the face   
     --          theShape is not the same as for the face  
     --          theSplit 
@@ -109,20 +109,20 @@ is
     IsSplitToReverse  (myclass;  
             aE1:  Edge from TopoDS;         
             aE2:  Edge from TopoDS; 
-            aContext:out Context from BOPInt) 
+            aContext:out Context from IntTools) 
         returns Boolean from Standard; 
         
      
     AreFacesSameDomain(myclass;  
             theF1: Face from TopoDS;        
             theF2: Face from TopoDS; 
-            theContext:out Context from BOPInt) 
+            theContext:out Context from IntTools) 
         returns Boolean from Standard;  
        
     CheckSameGeom (myclass;  
             theF1: Face from TopoDS;        
             theF2: Face from TopoDS; 
-            theContext:out Context from BOPInt) 
+            theContext:out Context from IntTools) 
         returns Boolean from Standard; 
  
     Sense (myclass;  
@@ -145,7 +145,7 @@ is
             theFace    :Face  from TopoDS; 
             theLCEF    :out ListOfCoupleOfShape from BOPTools; 
             theFaceOff :out Face  from TopoDS; 
-            theContext :out Context from BOPInt)  
+            theContext :out Context from IntTools)  
         returns Boolean from Standard;  
     
      ---Purpose:  For the face theFace and its edge theEdge 
@@ -158,7 +158,7 @@ is
             theEdge  :Edge from TopoDS; 
             theFace1 :Face from TopoDS; 
             theFace2 :Face from TopoDS; 
-            theContext:out Context from BOPInt)
+            theContext:out Context from IntTools)
     ---Purpose: Returns True if the face theFace is inside of the  
     --          couple of faces theFace1, theFace2. 
     --          The faces theFace, theFace1, theFace2  must 
@@ -169,7 +169,7 @@ is
             theFace :Face  from TopoDS; 
             theEdge :Edge  from TopoDS; 
             theLF   :out ListOfShape from BOPCol; 
-            theContext:out Context from BOPInt)  
+            theContext:out Context from IntTools)  
     ---Purpose: Returns True if the face theFace is inside of the  
     --          appropriate couple of faces (from the set theLF)    . 
     --          The faces of the set theLF and theFace  must 
@@ -181,7 +181,7 @@ is
             theSolid :Solid from TopoDS; 
             theMEF   :out IndexedDataMapOfShapeListOfShape from BOPCol;
             theTol   :Real from Standard;       
-            theContext:out Context from BOPInt)  
+            theContext:out Context from IntTools)  
     ---Purpose: Returns True if the face theFace is inside the  
     --          solid theSolid. 
     --          theMEF - Map Edge/Faces for theSolid              
@@ -204,7 +204,7 @@ is
             thePoint :Pnt  from gp;  
             theSolid :Solid from TopoDS;  
             theTol   :Real from Standard;       
-            theContext:out Context from BOPInt) 
+            theContext:out Context from IntTools) 
     ---Purpose: Computes the 3-D state of the point thePoint 
     --          toward solid theSolid. 
     --          theTol - value of precision of computation   
@@ -216,7 +216,7 @@ is
             theVertex:Vertex from TopoDS;  
             theSolid :Solid from TopoDS;  
             theTol   :Real from Standard;       
-            theContext:out Context from BOPInt) 
+            theContext:out Context from IntTools) 
     ---Purpose: Computes the 3-D state of the vertex theVertex 
     --          toward solid theSolid. 
     --          theTol - value of precision of computation   
@@ -228,7 +228,7 @@ is
             theEdge  :Edge  from TopoDS;  
             theSolid :Solid from TopoDS;  
             theTol   :Real from Standard;       
-            theContext:out Context from BOPInt) 
+            theContext:out Context from IntTools) 
     ---Purpose: Computes the 3-D state of the edge theEdge 
     --          toward solid theSolid. 
     --          theTol - value of precision of computation   
@@ -241,7 +241,7 @@ is
             theSolid :Solid from TopoDS;  
             theTol   :Real from Standard;     
             theBounds:out IndexedMapOfShape from BOPCol;
-            theContext:out Context from BOPInt)               
+            theContext:out Context from IntTools)             
     ---Purpose: Computes the 3-D state of the face theFace 
     --          toward solid theSolid. 
     --          theTol - value of precision of computation   
@@ -254,7 +254,7 @@ is
             theShape :Shape from TopoDS;  
             theSolid :Solid from TopoDS;  
             theTol   :Real from Standard;       
-            theContext:out Context from BOPInt) 
+            theContext:out Context from IntTools) 
     ---Purpose: Computes the 3-D state of the shape theShape 
     --          toward solid theSolid. 
     --          theTol - value of precision of computation   
@@ -426,7 +426,7 @@ is
             aShR  : Range from IntTools; 
             aF    : Face from TopoDS;  
             aE    : Edge from TopoDS;  
-            aContext:out Context from BOPInt)
+            aContext:out Context from IntTools)
         returns Boolean from Standard;               
     ---Purpose:  
     --- Returns TRUE if PaveBlock <aPB> lays on the face <aF>, i.e 
@@ -434,7 +434,7 @@ is
      
     IsMicroEdge(myclass; 
             theEdge    : Edge from TopoDS; 
-            theContext : Context from BOPInt)  
+            theContext : Context from IntTools)  
         returns Boolean from Standard; 
     ---Purpose: 
     --- Checks if it is possible to compute shrunk range for the edge <aE>. 
index 67cba7f..297f198 100644 (file)
@@ -64,7 +64,7 @@
 #include <BOPCol_IndexedMapOfShape.hxx>
 #include <BOPCol_MapOfShape.hxx>
 //
-#include <BOPInt_ShrunkRange.hxx>
+#include <IntTools_ShrunkRange.hxx>
 //
 
 static
@@ -76,7 +76,7 @@ static
   Standard_Boolean FindFacePairs (const TopoDS_Edge& theE,
                                   const BOPCol_ListOfShape& thLF,
                                   BOPTools_ListOfCoupleOfShape& theLCFF,
-                                  Handle(BOPInt_Context)& theContext);
+                                  Handle(IntTools_Context)& theContext);
 static
   TopAbs_Orientation Orientation(const TopoDS_Edge& anE,
                                  const TopoDS_Face& aF);
@@ -89,7 +89,7 @@ static
                   const gp_Dir& aDTgt,
                   gp_Dir& aDN,
                   gp_Dir& aDB,
-                  Handle(BOPInt_Context)& theContext,
+                  Handle(IntTools_Context)& theContext,
                   GeomAPI_ProjectPointOnSurf& aProjPL,
                   const Standard_Real aDt);
 static
@@ -97,7 +97,7 @@ static
                                    const gp_Pnt& aP,
                                    gp_Dir& aDB,
                                    gp_Pnt& aPOut,
-                                   Handle(BOPInt_Context)& theContext,
+                                   Handle(IntTools_Context)& theContext,
                                    GeomAPI_ProjectPointOnSurf& aProjPL,
                                    const Standard_Real aDt);
 static 
@@ -432,7 +432,7 @@ TopAbs_State BOPTools_AlgoTools::ComputeStateByOnePoint
   (const TopoDS_Shape& theS,
    const TopoDS_Solid& theRef,
    const Standard_Real theTol,
-   Handle(BOPInt_Context)& theContext)
+   Handle(IntTools_Context)& theContext)
 {
   TopAbs_State aState;
   TopAbs_ShapeEnum aType;
@@ -459,7 +459,7 @@ TopAbs_State BOPTools_AlgoTools::ComputeState
    const TopoDS_Solid& theRef,
    const Standard_Real theTol,
    BOPCol_IndexedMapOfShape& theBounds,
-   Handle(BOPInt_Context)& theContext)
+   Handle(IntTools_Context)& theContext)
 {
   TopAbs_State aState;
   TopExp_Explorer aExp; 
@@ -504,7 +504,7 @@ TopAbs_State BOPTools_AlgoTools::ComputeState
   (const TopoDS_Vertex& theV,
    const TopoDS_Solid& theRef,
    const Standard_Real theTol,
-   Handle(BOPInt_Context)& theContext)
+   Handle(IntTools_Context)& theContext)
 {
   TopAbs_State aState;
   gp_Pnt aP3D; 
@@ -522,7 +522,7 @@ TopAbs_State BOPTools_AlgoTools::ComputeState
   (const TopoDS_Edge& theE,
    const TopoDS_Solid& theRef,
    const Standard_Real theTol,
-   Handle(BOPInt_Context)& theContext)
+   Handle(IntTools_Context)& theContext)
 {
   Standard_Real aT1, aT2, aT = 0.;
   TopAbs_State aState;
@@ -574,7 +574,7 @@ TopAbs_State BOPTools_AlgoTools::ComputeState
   (const gp_Pnt& theP,
    const TopoDS_Solid& theRef,
    const Standard_Real theTol,
-   Handle(BOPInt_Context)& theContext)
+   Handle(IntTools_Context)& theContext)
 {
   TopAbs_State aState;
   //
@@ -594,7 +594,7 @@ Standard_Integer BOPTools_AlgoTools::IsInternalFace
    const TopoDS_Solid& theSolid,
    BOPCol_IndexedDataMapOfShapeListOfShape& theMEF,
    const Standard_Real theTol,
-   Handle(BOPInt_Context)& theContext)
+   Handle(IntTools_Context)& theContext)
 {
   Standard_Boolean bDegenerated;
   Standard_Integer aNbF, iRet, iFound;
@@ -709,7 +709,7 @@ Standard_Integer BOPTools_AlgoTools::IsInternalFace
   (const TopoDS_Face& theFace,
    const TopoDS_Edge& theEdge,
    BOPCol_ListOfShape& theLF,
-   Handle(BOPInt_Context)& theContext)
+   Handle(IntTools_Context)& theContext)
 {
   Standard_Integer aNbF, iRet;
   //
@@ -754,7 +754,7 @@ Standard_Integer BOPTools_AlgoTools::IsInternalFace
    const TopoDS_Edge& theEdge,
    const TopoDS_Face& theFace1,
    const TopoDS_Face& theFace2,
-   Handle(BOPInt_Context)& theContext)
+   Handle(IntTools_Context)& theContext)
 {
   Standard_Boolean bRet;
   Standard_Integer iRet;
@@ -808,7 +808,7 @@ Standard_Boolean BOPTools_AlgoTools::GetFaceOff
    const TopoDS_Face& theF1,
    BOPTools_ListOfCoupleOfShape& theLCSOff,
    TopoDS_Face& theFOff,
-   Handle(BOPInt_Context)& theContext)
+   Handle(IntTools_Context)& theContext)
 {
   Standard_Boolean bRet;
   Standard_Real aT, aT1, aT2, aAngle, aTwoPI, aAngleMin, aDt3D;
@@ -917,7 +917,7 @@ Standard_Boolean BOPTools_AlgoTools::GetEdgeOff(const TopoDS_Edge& theE1,
 Standard_Boolean BOPTools_AlgoTools::AreFacesSameDomain
   (const TopoDS_Face& theF1,
    const TopoDS_Face& theF2,
-   Handle(BOPInt_Context)& theContext)
+   Handle(IntTools_Context)& theContext)
 {
   Standard_Boolean bFlag;
   Standard_Integer iErr;
@@ -965,7 +965,7 @@ Standard_Boolean BOPTools_AlgoTools::AreFacesSameDomain
 Standard_Boolean BOPTools_AlgoTools::CheckSameGeom
   (const TopoDS_Face& theF1,
    const TopoDS_Face& theF2,
-   Handle(BOPInt_Context)& theContext)
+   Handle(IntTools_Context)& theContext)
 {
   Standard_Boolean bRet;
   Standard_Real aTolF1, aTolF2, aTol;
@@ -1041,7 +1041,7 @@ Standard_Integer BOPTools_AlgoTools::Sense (const TopoDS_Face& theF1,
 Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse
   (const TopoDS_Shape& theSp,
    const TopoDS_Shape& theSr,
-   Handle(BOPInt_Context)& theContext)
+   Handle(IntTools_Context)& theContext)
 {
   Standard_Boolean bRet;
   TopAbs_ShapeEnum aType;
@@ -1076,7 +1076,7 @@ Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse
 Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse
   (const TopoDS_Face& theFSp,
    const TopoDS_Face& theFSr,
-   Handle(BOPInt_Context)& theContext)
+   Handle(IntTools_Context)& theContext)
 {
   Standard_Boolean bRet, bFound, bInFace;
   Standard_Real aT1, aT2, aT, aU, aV, aScPr;
@@ -1169,7 +1169,7 @@ Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse
 Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse
   (const TopoDS_Edge& aEF1,
    const TopoDS_Edge& aEF2,
-   Handle(BOPInt_Context)& theContext)
+   Handle(IntTools_Context)& theContext)
 {
   Standard_Boolean bRet, bIsDegenerated;
   //
@@ -1557,7 +1557,7 @@ Standard_Boolean BOPTools_AlgoTools::GetEdgeOnFace
 Standard_Boolean FindFacePairs (const TopoDS_Edge& theE,
                                 const BOPCol_ListOfShape& thLF,
                                 BOPTools_ListOfCoupleOfShape& theLCFF,
-                                Handle(BOPInt_Context)& theContext)
+                                Handle(IntTools_Context)& theContext)
 {
   Standard_Boolean bFound;
   Standard_Integer i, aNbCEF;
@@ -1683,7 +1683,7 @@ Standard_Boolean BOPTools_AlgoTools::IsBlockInOnFace
   (const IntTools_Range& aShrR,
    const TopoDS_Face& aF,
    const TopoDS_Edge& aE1,
-   Handle(BOPInt_Context)& aContext)
+   Handle(IntTools_Context)& aContext)
 {
   Standard_Boolean bFlag;
   Standard_Real f1, l1, ULD, VLD;
@@ -1772,7 +1772,7 @@ Standard_Boolean BOPTools_AlgoTools::IsBlockInOnFace
 //=======================================================================
 Standard_Boolean BOPTools_AlgoTools::IsMicroEdge
   (const TopoDS_Edge& aE,
-   const Handle(BOPInt_Context)& aCtx) 
+   const Handle(IntTools_Context)& aCtx) 
 {
   Standard_Boolean bRet;
   Standard_Integer iErr;
@@ -1796,7 +1796,7 @@ Standard_Boolean BOPTools_AlgoTools::IsMicroEdge
     aT2=aTmp;
   }
   //
-  BOPInt_ShrunkRange aSR;
+  IntTools_ShrunkRange aSR;
   aSR.SetContext(aCtx);
   aSR.SetData(aE, aT1, aT2, aV1, aV2);
   aSR.Perform();
@@ -1817,7 +1817,7 @@ void GetFaceDir(const TopoDS_Edge& aE,
                 const gp_Dir& aDTgt,
                 gp_Dir& aDN,
                 gp_Dir& aDB,
-                Handle(BOPInt_Context)& theContext,
+                Handle(IntTools_Context)& theContext,
                 GeomAPI_ProjectPointOnSurf& aProjPL,
                 const Standard_Real aDt)
 {
@@ -1846,7 +1846,7 @@ Standard_Boolean FindPointInFace(const TopoDS_Face& aF,
                                  const gp_Pnt& aP,
                                  gp_Dir& aDB,
                                  gp_Pnt& aPOut,
-                                 Handle(BOPInt_Context)& theContext,
+                                 Handle(IntTools_Context)& theContext,
                                  GeomAPI_ProjectPointOnSurf& aProjPL,
                                  const Standard_Real aDt)
 {
index 2de494e..186cdfc 100644 (file)
@@ -38,7 +38,7 @@ uses
 
     ListOfShape from BOPCol,  
      
-    Context     from BOPInt,
+    Context     from IntTools,
 
     IndexedDataMapOfShapeListOfShape from BOPCol
 
@@ -95,7 +95,7 @@ is
               aT:  Real from Standard;  
               aPx:out Pnt from gp;
               aD:out Dir from gp; 
-              theContext:out Context from BOPInt); 
+              theContext:out Context from IntTools); 
           ---Purpose:  
           --- Computes normal to the face <aF> for the 3D-point that 
           --- belonds to the edge <aE> at parameter <aT>. 
@@ -136,7 +136,7 @@ is
               aT:  Real from Standard;  
               aP2D:out Pnt2d from  gp; 
               aPx:out Pnt from gp; 
-              theContext:out Context from BOPInt);
+              theContext:out Context from IntTools);
           ---Purpose: 
           --- Computes the point <aPx>,  (<aP2D>)  that is near to  
           --- the edge <aE>   at parameter <aT>  towards to the  
@@ -148,7 +148,7 @@ is
               aF:  Face from TopoDS;   
               aP2D:out Pnt2d from  gp; 
               aPx:out Pnt from gp; 
-              theContext:out Context from BOPInt);
+              theContext:out Context from IntTools);
           ---Purpose: 
           --- Compute the point <aPx>,  (<aP2D>)  that is near to  
           --- the edge <aE>   at arbitrary  parameter  towards to the  
@@ -183,7 +183,7 @@ is
               theF:Face from TopoDS;
               theP:out Pnt from gp;
               theP2D:out Pnt2d from gp; 
-              theContext:out Context from BOPInt) 
+              theContext:out Context from IntTools) 
           returns Integer from Standard; 
           ---Purpose: Computes a point <theP> inside the face <theF>. <br>
           --          <theP2D> -  2D  representation of <theP> <br>
index e268dc0..1231b73 100644 (file)
@@ -68,7 +68,7 @@
 #include <BRep_TFace.hxx>
 #include <Poly_Triangulation.hxx>
 #include <BRep_Builder.hxx>
-#include <BOPInt_Context.hxx>
+#include <IntTools_Context.hxx>
 #include <Geom2dAdaptor_Curve.hxx>
 #include <Geom2dHatch_Hatcher.hxx>
 #include <HatchGen_Domain.hxx>
@@ -355,7 +355,7 @@ void BOPTools_AlgoTools3D::GetApproxNormalToFaceOnEdge
    const Standard_Real aT,
    gp_Pnt& aPNear,
    gp_Dir& aDNF,
-   Handle(BOPInt_Context)& theContext)
+   Handle(IntTools_Context)& theContext)
 {
   Standard_Real aFirst, aLast;
   Handle(Geom2d_Curve) aC2D= 
@@ -471,7 +471,7 @@ void BOPTools_AlgoTools3D::PointNearEdge
    const Standard_Real aT, 
    gp_Pnt2d& aPx2DNear,
    gp_Pnt& aPxNear,
-   Handle(BOPInt_Context)& theContext)
+   Handle(IntTools_Context)& theContext)
 {
   Standard_Real aTolE, aTolF, dTx, dT2D;
   Handle(Geom_Surface) aS;
@@ -530,7 +530,7 @@ void  BOPTools_AlgoTools3D::PointNearEdge
    const TopoDS_Face& aF, 
    gp_Pnt2d& aPInFace2D, 
    gp_Pnt& aPInFace,
-   Handle(BOPInt_Context)& theContext)
+   Handle(IntTools_Context)& theContext)
 {
   Standard_Real aT, aT1, aT2;
   //
@@ -718,7 +718,7 @@ Standard_Integer BOPTools_AlgoTools3D::PointInFace
   (const TopoDS_Face& aF,
    gp_Pnt& theP,
    gp_Pnt2d& theP2D,
-   Handle(BOPInt_Context)& theContext)
+   Handle(IntTools_Context)& theContext)
 {
   Standard_Boolean bIsDone, bHasFirstPoint, bHasSecondPoint;
   Standard_Integer iErr, aIx, aNbDomains;
index 140233c..23cb581 100644 (file)
@@ -25,7 +25,7 @@
 #include <TopoDS_Compound.hxx>
 
 #include <IntTools_BeanFaceIntersector.hxx>
-#include <BOPInt_Context.hxx>
+#include <IntTools_Context.hxx>
 #include <IntTools_Range.hxx>
 
 #include <Geom_Curve.hxx>
@@ -58,7 +58,7 @@
 #include <TColgp_SequenceOfPnt.hxx>
 #include <gce_MakeLin.hxx>
 
-#include <BOPInt_Tools.hxx>
+#include <IntTools_Tools.hxx>
 #include <BOPAlgo_PaveFiller.hxx>
 #include <BOPDS_DS.hxx>
 #include <BOPAlgo_BOP.hxx>
@@ -971,9 +971,9 @@ Standard_Boolean FindCommonVertex(const BOPDS_PDS&         theDS,
       if(aCP.Type() == TopAbs_VERTEX) {
         theCommonVertex = *(TopoDS_Vertex*)&theDS->Shape(aEE.IndexNew());
         if (theEIndex1 == aEE.Index1()) {
-          BOPInt_Tools::VertexParameters(aCP, theParamOnE1, theParamOnE2);
+          IntTools_Tools::VertexParameters(aCP, theParamOnE1, theParamOnE2);
         } else {
-          BOPInt_Tools::VertexParameters(aCP, theParamOnE2, theParamOnE1);
+          IntTools_Tools::VertexParameters(aCP, theParamOnE2, theParamOnE1);
         }
         //
         bvertexfound = Standard_True;
@@ -1931,7 +1931,7 @@ Standard_Boolean FilterSectionEdges(const BOPDS_VectorOfCurve&       theBCurves,
         BRep_Tool::Range(anEdge, f, l);
         anIntersector.SetBeanParameters(f, l);
         //
-        Handle(BOPInt_Context) aContext = new BOPInt_Context;
+        Handle(IntTools_Context) aContext = new IntTools_Context;
         anIntersector.SetContext(aContext);
         //
         anIntersector.Perform();
index f7dc546..082b74b 100644 (file)
@@ -15,8 +15,8 @@
 
 package IntTools
 
-       ---Purpose: Contains classes for intersection and classification
-       ---         purposes and accompanying classes
+ ---Purpose: Contains classes for intersection and classification
+ ---         purposes and accompanying classes
 uses
     
     TCollection, 
@@ -43,186 +43,191 @@ uses
     BRepClass3d, 
     TColgp, 
     MMgt, 
-    BOPInt
+    Geom2dHatch, 
+    
+    BOPCol
 
 is
-       
-    class  Range;              
-    class  CommonPrt; 
-    class  Root; 
-    class  Compare; 
-    class  CompareRange;     
+    class Context; 
+    class ShrunkRange; 
+    --
+    class Range;         
+    class CommonPrt; 
+    class Root; 
+    class Compare; 
+    class CompareRange;     
 
     class  EdgeEdge;
-       ---Purpose: class provides the Edge/Edge algorithm 
+     ---Purpose: class provides the Edge/Edge algorithm 
 
     class  EdgeFace;
-       ---Purpose: class provides the Edge/Face algorithm 
+     ---Purpose: class provides the Edge/Face algorithm 
 
     class  FClass2d;
-       ---Purpose: class provides classification of a point in a face
+     ---Purpose: class provides classification of a point in a face
 
     class  LineConstructor;
-       ---Purpose: class provides post-processing of results of 
-       ---         surfaces intersection
+    ---Purpose: class provides post-processing of results of 
+    ---         surfaces intersection
 
     -----
     class MarkedRangeSet;
-       ---Purpose: auxiliary class for range management
+    ---Purpose: auxiliary class for range management
 
     class BaseRangeSample;
-       ---Purpose: base class for range index management
+    ---Purpose: base class for range index management
     
     class CurveRangeSample;
-       ---Purpose: class for range index management of curve
+    ---Purpose: class for range index management of curve
     
     class SurfaceRangeSample;
-       ---Purpose: class for range index management of surface
+    ---Purpose: class for range index management of surface
 
     class CurveRangeLocalizeData;
     
     class SurfaceRangeLocalizeData;
    
     class BeanFaceIntersector;
-       ---Purpose: class provides computing ranges of parameters
-       ---         of edge/face intersection.
+    ---Purpose: class provides computing ranges of parameters
+    ---         of edge/face intersection.
 
     -----
     class  Curve;
-       ---Purpose: class is a container of
-       ---         one 3d curve
-       ---         two 2d curves
+    ---Purpose: class is a container of
+    ---         one 3d curve
+    ---         two 2d curves
     -----
 
     class  PntOnFace;
     class  PntOn2Faces; 
       
     class  TopolTool;
-       ---Purpose: class redefines TopolTool from Adaptor3d
+    ---Purpose: class redefines TopolTool from Adaptor3d
 
     class  FaceFace;
-       ---Purpose: class provides the Face/Face algorithm
+    ---Purpose: class provides the Face/Face algorithm
     --- 
 
     class  Tools; 
-       ---Purpose: class is a container of usefull geometrical and
-       ---         topological algorithms
+    ---Purpose: class is a container of usefull geometrical and
+    ---         topological algorithms
     
     generic class CArray1;   
     ---
     ---                 I  n  s  t  a  n  t  i  a  t  i  o  n  s  
     ---   
     class SequenceOfPntOn2Faces instantiates  
-       Sequence from TCollection(PntOn2Faces from IntTools); 
+     Sequence from TCollection(PntOn2Faces from IntTools); 
     --
     class SequenceOfCurves instantiates  
-       Sequence from TCollection(Curve from IntTools); 
-       
+     Sequence from TCollection(Curve from IntTools); 
     
     class  SequenceOfRanges  instantiates  
-       Sequence from TCollection(Range from IntTools); 
+     Sequence from TCollection(Range from IntTools); 
 
     class  CArray1OfInteger  instantiates  
-       CArray1(Integer from Standard); 
+     CArray1(Integer from Standard); 
   
     class  CArray1OfReal  instantiates  
-       CArray1(Real from Standard); 
-        
+     CArray1(Real from Standard); 
+  
     class  SequenceOfRoots   instantiates  
-       Sequence from TCollection(Root  from IntTools); 
-        
+     Sequence from TCollection(Root  from IntTools); 
+  
     class  Array1OfRoots     instantiates  
-       Array1    from TCollection  (Root from IntTools);  
+     Array1    from TCollection  (Root from IntTools);  
      
     class  Array1OfRange     instantiates  
-       Array1    from TCollection  (Range from IntTools); 
-        
+     Array1    from TCollection  (Range from IntTools); 
+  
     class  QuickSort         instantiates  
-       QuickSort from SortTools   (Root from IntTools, 
-                                   Array1OfRoots from IntTools, 
-                                   Compare from IntTools); 
-                                   
+     QuickSort from SortTools   (Root from IntTools, 
+                    Array1OfRoots from IntTools, 
+                    Compare from IntTools); 
+        
     class  QuickSortRange    instantiates  
-       QuickSort from SortTools   (Range from IntTools, 
-                                   Array1OfRange from IntTools, 
-                                   CompareRange from IntTools); 
+     QuickSort from SortTools   (Range from IntTools, 
+                    Array1OfRange from IntTools, 
+                    CompareRange from IntTools); 
     class  SequenceOfCommonPrts   instantiates  
-       Sequence from TCollection(CommonPrt from IntTools);                         
-        
+     Sequence from TCollection(CommonPrt from IntTools);        
+  
     class  IndexedDataMapOfTransientAddress instantiates
-       IndexedDataMap from TCollection(Transient      from Standard,
-                                       Address        from Standard,
-                                        MapTransientHasher from TColStd);      
+     IndexedDataMap from TCollection(Transient      from Standard,
+                     Address        from Standard,
+                                        MapTransientHasher from TColStd); 
     
---modified by NIZHNY-MKK  Wed Oct  5 18:06:39 2005
+
     class  ListOfCurveRangeSample  instantiates  
-       List from TCollection(CurveRangeSample from IntTools);
+     List from TCollection(CurveRangeSample from IntTools);
 
     class  ListOfSurfaceRangeSample  instantiates  
-       List from TCollection(SurfaceRangeSample from IntTools);
+     List from TCollection(SurfaceRangeSample from IntTools);
 
     class  ListOfBox  instantiates  
-       List from TCollection(Box from Bnd);
-       
+     List from TCollection(Box from Bnd);
     class CurveRangeSampleMapHasher;
-       ---Purpose: class for range index management of curve
+     ---Purpose: class for range index management of curve
     
     class SurfaceRangeSampleMapHasher;
     
     class MapOfCurveSample instantiates 
-       Map from TCollection(CurveRangeSample from IntTools,
+     Map from TCollection(CurveRangeSample from IntTools,
                              CurveRangeSampleMapHasher from IntTools);
-                            
+        
     class MapOfSurfaceSample instantiates 
-       Map from TCollection(SurfaceRangeSample from IntTools,
-                            SurfaceRangeSampleMapHasher from IntTools);
+     Map from TCollection(SurfaceRangeSample from IntTools,
+                    SurfaceRangeSampleMapHasher from IntTools);
     
     class DataMapOfCurveSampleBox instantiates 
-       DataMap from TCollection(CurveRangeSample from IntTools,
-                                Box              from Bnd,
-                                CurveRangeSampleMapHasher from IntTools);
+     DataMap from TCollection(CurveRangeSample from IntTools,
+                 Box              from Bnd,
+     CurveRangeSampleMapHasher from IntTools);
 
     class DataMapOfSurfaceSampleBox instantiates 
-       DataMap from TCollection(SurfaceRangeSample from IntTools,
-                                Box              from Bnd,
-                                SurfaceRangeSampleMapHasher from IntTools);
+     DataMap from TCollection(SurfaceRangeSample from IntTools,
+                 Box              from Bnd,
+     SurfaceRangeSampleMapHasher from IntTools);
     -----------------------------------------------------
     --  Block  of  static  functions  
     -----------------------------------------------------  
     Length  (E : Edge from TopoDS) 
-       returns  Real  from  Standard; 
-    ---Purpose:  returns the length of the edge;        
+     returns  Real  from  Standard; 
+    ---Purpose:  returns the length of the edge;  
 
     RemoveIdenticalRoots  (aSeq  :out SequenceOfRoots from IntTools; 
-                          anEpsT:    Real from Standard); 
+                  anEpsT:    Real from Standard); 
     ---Purpose: Remove from  the  sequence aSeq the Roots  that  have  
     --          values ti and tj such as  |ti-tj]  <  anEpsT.     
 
     SortRoots (aSeq  :out SequenceOfRoots from IntTools; 
-              anEpsT:    Real from Standard);   
+            anEpsT:    Real from Standard);  
     ---Purpose: Sort the sequence aSeq of the Roots to arrange the 
-    --          Roons  in  increasing  order 
+    --          Roons  in  increasing  order  
+    
     FindRootStates  (aSeq  :out SequenceOfRoots from IntTools; 
                      anEpsNull:    Real from Standard);
     ---Purpose: Find the states (before  and  after) for  each  Root  
     --          from  the sequence aSeq 
      
     Parameter (P          : Pnt   from gp; 
-              Curve      : Curve from Geom; 
-               aParm      : out Real  from  Standard) 
-       returns  Integer from Standard;                 
+                Curve      : Curve from Geom; 
+                aParm      : out Real  from  Standard) 
+        returns  Integer from Standard;          
  
     GetRadius(C:  Curve  from  BRepAdaptor; 
-             t1,t3:Real  from  Standard; 
-             R:out Real  from  Standard) 
+           t1,t3:Real  from  Standard; 
+            R:out Real  from  Standard) 
         returns  Integer from Standard;    
-        
+  
 
     PrepareArgs(C:  in out Curve  from  BRepAdaptor;  
                 tMax,tMin:  Real  from  Standard; 
-               Discret  :  Integer from Standard;    
-               Deflect  :  Real  from  Standard;  
-               anArgs   :  out  CArray1OfReal  from IntTools) 
+                Discret  :  Integer from Standard;    
+                Deflect  :  Real  from  Standard;  
+                anArgs   :  out  CArray1OfReal  from IntTools) 
         returns  Integer from Standard; 
 
 end IntTools; 
index 739208f..222cd2d 100644 (file)
@@ -28,14 +28,14 @@ uses
     SequenceOfRoots    from IntTools,
     MarkedRangeSet     from IntTools,
     SequenceOfRanges   from IntTools,
-    Context            from BOPInt,
+    Context            from IntTools,
     ExtCS              from Extrema,
     ProjectPointOnSurf from GeomAPI,
     Edge               from TopoDS,
     Face               from TopoDS,
     Curve              from BRepAdaptor,
     Surface            from BRepAdaptor,
-    Box                       from Bnd,
+    Box                from Bnd,
     CurveRangeSample   from IntTools,
     SurfaceRangeSample from IntTools,
     ListOfCurveRangeSample   from IntTools,
@@ -48,176 +48,176 @@ is
     Create returns BeanFaceIntersector from IntTools;
 
     Create(theEdge: Edge from TopoDS;
-          theFace: Face from TopoDS)
-          returns BeanFaceIntersector from IntTools;
-       ---Purpose: 
-       --- Initializes the algorithm
-       ---
-       --  Warning: 
-       --- The parts of the edge which are on
-       --- the surface of the face and belong to
-       --- the whole in the face (if there is)
-       --- is considered as result
-       ---
+        theFace: Face from TopoDS)
+    returns BeanFaceIntersector from IntTools;
+    ---Purpose: 
+    --- Initializes the algorithm
+    ---
+    --  Warning: 
+    --- The parts of the edge which are on
+    --- the surface of the face and belong to
+    --- the whole in the face (if there is)
+    --- is considered as result
+    ---
 
     Create(theCurve        : Curve   from BRepAdaptor;
-          theSurface      : Surface from BRepAdaptor;
-          theBeanTolerance: Real    from Standard;
-          theFaceTolerance: Real    from Standard)
-          returns BeanFaceIntersector from IntTools;
-       ---Purpose: 
-       --- Initializes the algorithm
-       ---
+        theSurface      : Surface from BRepAdaptor;
+        theBeanTolerance: Real    from Standard;
+        theFaceTolerance: Real    from Standard)
+    returns BeanFaceIntersector from IntTools;
+    ---Purpose: 
+    --- Initializes the algorithm
+    ---
 
     Create(theCurve          : Curve   from BRepAdaptor;
-          theSurface        : Surface from BRepAdaptor;
-          theFirstParOnCurve: Real from Standard;
-          theLastParOnCurve : Real from Standard;
-          theUMinParameter  : Real from Standard;
-          theUMaxParameter  : Real from Standard;
-          theVMinParameter  : Real from Standard;
-          theVMaxParameter  : Real from Standard;
-          theBeanTolerance  : Real from Standard;
-          theFaceTolerance  : Real from Standard)
-          returns BeanFaceIntersector from IntTools;
-       ---Purpose: 
-       --- Initializes the algorithm
-       --- theUMinParameter, ... are used for
-       --- optimization purposes
-       ---
+        theSurface        : Surface from BRepAdaptor;
+        theFirstParOnCurve: Real from Standard;
+        theLastParOnCurve : Real from Standard;
+        theUMinParameter  : Real from Standard;
+        theUMaxParameter  : Real from Standard;
+        theVMinParameter  : Real from Standard;
+        theVMaxParameter  : Real from Standard;
+        theBeanTolerance  : Real from Standard;
+        theFaceTolerance  : Real from Standard)
+    returns BeanFaceIntersector from IntTools;
+    ---Purpose: 
+    --- Initializes the algorithm
+    --- theUMinParameter, ... are used for
+    --- optimization purposes
+    ---
 
     Init(me: in out;theEdge: Edge from TopoDS;
-                   theFace: Face from TopoDS);
-       ---Purpose: 
-       --- Initializes the algorithm
-       ---
-       --  Warning: 
-       --- The parts of the edge which are on
-       --- the surface of the face and belong to
-       --- the whole in the face (if there is)
-       --- is considered as result
-       ---
+                 theFace: Face from TopoDS);
+     ---Purpose: 
+    --- Initializes the algorithm
+    ---
+    --  Warning: 
+    --- The parts of the edge which are on
+    --- the surface of the face and belong to
+    --- the whole in the face (if there is)
+    --- is considered as result
+    ---
 
     Init(me: in out;theCurve        : Curve   from BRepAdaptor;
-                   theSurface      : Surface from BRepAdaptor;
-                   theBeanTolerance: Real from Standard;
-                   theFaceTolerance: Real from Standard);
-       ---Purpose: 
-       --- Initializes the algorithm
-       ---
+               theSurface      : Surface from BRepAdaptor;
+              theBeanTolerance: Real from Standard;
+              theFaceTolerance: Real from Standard);
+    ---Purpose: 
+    --- Initializes the algorithm
+    ---
 
     Init(me: in out;theCurve          : Curve   from BRepAdaptor;
-                   theSurface        : Surface from BRepAdaptor;
-                   theFirstParOnCurve: Real from Standard;
-                   theLastParOnCurve : Real from Standard;
-                   theUMinParameter  : Real from Standard;
-                   theUMaxParameter  : Real from Standard;
-                   theVMinParameter  : Real from Standard;
-                   theVMaxParameter  : Real from Standard;
-                   theBeanTolerance  : Real from Standard;
-                   theFaceTolerance  : Real from Standard);
-       ---Purpose: 
-       --- Initializes the algorithm
-       --- theUMinParameter, ... are used for
-       --- optimization purposes
-       ---
+              theSurface        : Surface from BRepAdaptor;
+          theFirstParOnCurve: Real from Standard;
+          theLastParOnCurve : Real from Standard;
+          theUMinParameter  : Real from Standard;
+              theUMaxParameter  : Real from Standard;
+              theVMinParameter  : Real from Standard;
+              theVMaxParameter  : Real from Standard;
+              theBeanTolerance  : Real from Standard;
+              theFaceTolerance  : Real from Standard);
+    ---Purpose: 
+    --- Initializes the algorithm
+    --- theUMinParameter, ... are used for
+    --- optimization purposes
+    ---
 
     SetContext(me: in out;  
-           theContext: Context from BOPInt);
-       ---Purpose:
-       --- Sets the intersecton context
-       ---
+         theContext: Context from IntTools);
+    ---Purpose:
+    --- Sets the intersecton context
+    ---
     Context(me) 
-       returns Context from BOPInt; 
-    ---C++:  return const &    
+     returns Context from IntTools; 
+    ---C++:  return const &  
     ---Purpose:
-       --- Gets the intersecton context
-       ---       
+    --- Gets the intersecton context
+    ---   
     SetBeanParameters(me: in out;theFirstParOnCurve : Real from Standard;
-                                theLastParOnCurve  : Real from Standard);
-       ---Purpose: 
-       --- Set restrictions for curve
-       ---
+                 theLastParOnCurve  : Real from Standard);
+    ---Purpose: 
+    --- Set restrictions for curve
+    ---
 
     SetSurfaceParameters(me: in out;theUMinParameter : Real from Standard;
-                                   theUMaxParameter : Real from Standard;
-                                   theVMinParameter : Real from Standard;
-                                   theVMaxParameter : Real from Standard);
-       ---Purpose: 
-       --- Set restrictions for surface
-       ---
+            theUMaxParameter : Real from Standard;
+                theVMinParameter : Real from Standard;
+                theVMaxParameter : Real from Standard);
+    ---Purpose: 
+    --- Set restrictions for surface
+    ---
 
     Perform(me: in out);
-       ---Purpose: 
-       --- Launches the algorithm
-       ---
+    ---Purpose: 
+    --- Launches the algorithm
+    ---
 
     IsDone(me) returns Boolean from Standard;
-       ---C++: inline
+     ---C++: inline
 
     Result(me)
-       returns SequenceOfRanges from IntTools;
-       ---C++: return const &
+     returns SequenceOfRanges from IntTools;
+    ---C++: return const &
 
     Result(me; theResults: out SequenceOfRanges from IntTools);
 
     -- private
 
     ComputeAroundExactIntersection(me: in out)
-       is private;
+     is private;
 
     ComputeLinePlane(me: in out)
-       is private;
+     is private;
  
     FastComputeExactIntersection(me: in out)
         returns Integer from Standard is private; 
 
     ComputeUsingExtremum(me: in out)
-       is private;
+     is private;
 
     ComputeNearRangeBoundaries(me: in out)
-       is private;
+     is private;
 
     ComputeLocalized(me: in out)
-       returns Boolean from Standard is private;
-       
+     returns Boolean from Standard is private;
     ComputeRangeFromStartPoint(me: in out; ToIncreaseParameter : Boolean from Standard;
-                                          theParameter        : Real from Standard;
-                                          theUParameter       : Real from Standard;
-                                          theVParameter       : Real from Standard)
-       is private;
+                            theParameter        : Real from Standard;
+                            theUParameter       : Real from Standard;
+                            theVParameter       : Real from Standard)
+     is private;
 
     ComputeRangeFromStartPoint(me: in out; ToIncreaseParameter : Boolean from Standard;
-                                          theParameter        : Real from Standard;
-                                          theUParameter       : Real from Standard;
-                                          theVParameter       : Real from Standard;
-                                          theIndex            : Integer from Standard)
-       is private;
+                            theParameter        : Real from Standard;
+                            theUParameter       : Real from Standard;
+                            theVParameter       : Real from Standard;
+                            theIndex            : Integer from Standard)
+     is private;
 
     Distance(me: in out; theArg       : Real from Standard;
-                        theUParameter: out Real from Standard;
-                        theVParameter: out Real from Standard)
-       returns Real from Standard
-       is private;
+                theUParameter: out Real from Standard;
+                theVParameter: out Real from Standard)
+     returns Real from Standard
+     is private;
 
     Distance(me: in out; theArg: Real from Standard)
-       returns Real from Standard
-       is private;
+     returns Real from Standard
+     is private;
 
     LocalizeSolutions(me: in out; theCurveRange  : CurveRangeSample from IntTools;
-                                 theBoxCurve    : Box from Bnd;
-                                 theSurfaceRange: SurfaceRangeSample from IntTools;
-                                 theBoxSurface  : Box from Bnd;
-                                 theCurveData   : in out CurveRangeLocalizeData   from IntTools;
-                                 theSurfaceData : in out SurfaceRangeLocalizeData from IntTools;
-                                 theListCurveRange: in out ListOfCurveRangeSample from IntTools;
-                                 theListSurfaceRange: in out ListOfSurfaceRangeSample from IntTools)
-       returns Boolean from Standard
-       is private;
+                      theBoxCurve    : Box from Bnd;
+                      theSurfaceRange: SurfaceRangeSample from IntTools;
+      theBoxSurface  : Box from Bnd;
+      theCurveData   : in out CurveRangeLocalizeData   from IntTools;
+      theSurfaceData : in out SurfaceRangeLocalizeData from IntTools;
+                      theListCurveRange: in out ListOfCurveRangeSample from IntTools;
+                      theListSurfaceRange: in out ListOfSurfaceRangeSample from IntTools)
+     returns Boolean from Standard
+     is private;
 
     TestComputeCoinside(me: in out)
-       returns Boolean from Standard
-       is private;
+     returns Boolean from Standard
+        is private;
 
 fields
 
@@ -242,7 +242,7 @@ fields
     myProjector      : ProjectPointOnSurf from GeomAPI;
     myRangeManager   : MarkedRangeSet from IntTools;
     myDeflection     : Real from Standard;
-    myContext        : Context from BOPInt;
+    myContext        : Context from IntTools;
     
     -- results
     myResults        : SequenceOfRanges from IntTools;
index 877e2a2..0a7e6cb 100644 (file)
@@ -41,7 +41,7 @@
 #include <Extrema_ExtCS.hxx>
 #include <Extrema_ExtPS.hxx>
 #include <IntTools.hxx>
-#include <BOPInt_Context.hxx>
+#include <IntTools_Context.hxx>
 #include <IntTools_Tools.hxx>
 #include <GeomAPI_ProjectPointOnCurve.hxx>
 #include <IntCurveSurface_HInter.hxx>
 #include <ElSLib.hxx>
 
 static Standard_Boolean AdjustPeriodic(const Standard_Real U, 
-                                      const Standard_Real UFirst,
-                                      const Standard_Real ULast,
-                                      const Standard_Real Period,
-                                      Standard_Real&      UResult);
+                                       const Standard_Real UFirst,
+                                       const Standard_Real ULast,
+                                       const Standard_Real Period,
+                                       Standard_Real&      UResult);
 
 static Standard_Boolean SetEmptyResultRange(const Standard_Real      theParameter, 
-                                           IntTools_MarkedRangeSet& theMarkedRange);
+                                            IntTools_MarkedRangeSet& theMarkedRange);
+
 
-// static Standard_Boolean TestCoinside(const BRepAdaptor_Curve&   theCurve,
-//                                      const BRepAdaptor_Surface& theSurface);
 
-//  Modified by skv - Wed Nov  2 15:21:11 2005 Optimization Begin
 static Bnd_Box GetSurfaceBox
-               (const Handle(Geom_BSplineSurface)        &theSurf,
-               const Standard_Real                       theFirstU,
-               const Standard_Real                       theLastU,
-               const Standard_Real                       theFirstV,
-               const Standard_Real                       theLastV,
-               const Standard_Real                       theTolerance,
-                     IntTools_SurfaceRangeLocalizeData  &theSurfaceData);
+  (const Handle(Geom_BSplineSurface)        &theSurf,
+   const Standard_Real                       theFirstU,
+   const Standard_Real                       theLastU,
+   const Standard_Real                       theFirstV,
+   const Standard_Real                       theLastV,
+   const Standard_Real                       theTolerance,
+   IntTools_SurfaceRangeLocalizeData  &theSurfaceData);
 
 static void ComputeGridPoints
-               (const Handle(Geom_BSplineSurface)       &theSurf,
-               const Standard_Real                      theFirstU,
-               const Standard_Real                      theLastU,
-               const Standard_Real                      theFirstV,
-               const Standard_Real                      theLastV,
-               const Standard_Real                      theTolerance,
-                     IntTools_SurfaceRangeLocalizeData &theSurfaceData);
+  (const Handle(Geom_BSplineSurface)       &theSurf,
+   const Standard_Real                      theFirstU,
+   const Standard_Real                      theLastU,
+   const Standard_Real                      theFirstV,
+   const Standard_Real                      theLastV,
+   const Standard_Real                      theTolerance,
+   IntTools_SurfaceRangeLocalizeData &theSurfaceData);
 
 static void BuildBox(const Handle(Geom_BSplineSurface)       &theSurf,
-                    const Standard_Real                      theFirstU,
-                    const Standard_Real                      theLastU,
-                    const Standard_Real                      theFirstV,
-                    const Standard_Real                      theLastV,
-                          IntTools_SurfaceRangeLocalizeData &theSurfaceData,
-                          Bnd_Box                           &theBox);
-//  Modified by skv - Wed Nov  2 15:21:11 2005 Optimization End
-
+                     const Standard_Real                      theFirstU,
+                     const Standard_Real                      theLastU,
+                     const Standard_Real                      theFirstV,
+                     const Standard_Real                      theLastV,
+                     IntTools_SurfaceRangeLocalizeData &theSurfaceData,
+                     Bnd_Box                           &theBox);
+     
 static void MergeSolutions(const IntTools_ListOfCurveRangeSample& theListCurveRange,
-                          const IntTools_ListOfSurfaceRangeSample& theListSurfaceRange,
-                          IntTools_ListOfCurveRangeSample& theListCurveRangeSort,
-                          IntTools_ListOfSurfaceRangeSample& theListSurfaceRangeSort);
+                           const IntTools_ListOfSurfaceRangeSample& theListSurfaceRange,
+                           IntTools_ListOfCurveRangeSample& theListCurveRangeSort,
+                           IntTools_ListOfSurfaceRangeSample& theListSurfaceRangeSort);
 
 static void CheckSampling(const IntTools_CurveRangeSample& theCurveRange,
-                         const IntTools_SurfaceRangeSample& theSurfaceRange,
-                         const IntTools_CurveRangeLocalizeData& theCurveData,
-                         const IntTools_SurfaceRangeLocalizeData& theSurfaceData,
-                         const Standard_Real DiffC,
-                         const Standard_Real DiffU,
-                         const Standard_Real DiffV,
-                         Standard_Boolean& bAllowSamplingC,
-                         Standard_Boolean& bAllowSamplingU,
-                         Standard_Boolean& bAllowSamplingV);
+                          const IntTools_SurfaceRangeSample& theSurfaceRange,
+                          const IntTools_CurveRangeLocalizeData& theCurveData,
+                          const IntTools_SurfaceRangeLocalizeData& theSurfaceData,
+                          const Standard_Real DiffC,
+                          const Standard_Real DiffU,
+                          const Standard_Real DiffV,
+                          Standard_Boolean& bAllowSamplingC,
+                          Standard_Boolean& bAllowSamplingU,
+                          Standard_Boolean& bAllowSamplingV);
+
 // ==================================================================================
 // function: IntTools_BeanFaceIntersector
 // purpose: 
@@ -139,17 +137,17 @@ myIsDone(Standard_False)
 // purpose: 
 // ==================================================================================
 IntTools_BeanFaceIntersector::IntTools_BeanFaceIntersector(const TopoDS_Edge& theEdge,
-                                                          const TopoDS_Face& theFace) :
-myFirstParameter(0.),
-myLastParameter(0.),
-myUMinParameter(0.),
-myUMaxParameter(0.),
-myVMinParameter(0.),
-myVMaxParameter(0.),
-myBeanTolerance(0.),
-myFaceTolerance(0.),
-myDeflection(0.01),
-myIsDone(Standard_False)
+                                                           const TopoDS_Face& theFace) :
+       myFirstParameter(0.),
+       myLastParameter(0.),
+       myUMinParameter(0.),
+       myUMaxParameter(0.),
+       myVMinParameter(0.),
+       myVMaxParameter(0.),
+       myBeanTolerance(0.),
+       myFaceTolerance(0.),
+       myDeflection(0.01),
+       myIsDone(Standard_False)
 {
   Init(theEdge, theFace);
 }
@@ -159,17 +157,17 @@ myIsDone(Standard_False)
 // purpose: 
 // ==================================================================================
 IntTools_BeanFaceIntersector::IntTools_BeanFaceIntersector(const BRepAdaptor_Curve&   theCurve,
-                                                          const BRepAdaptor_Surface& theSurface,
-                                                          const Standard_Real        theBeanTolerance,
+                                                           const BRepAdaptor_Surface& theSurface,
+                                                           const Standard_Real        theBeanTolerance,
                                                            const Standard_Real        theFaceTolerance) :
-myFirstParameter(0.),
-myLastParameter(0.),
-myUMinParameter(0.),
-myUMaxParameter(0.),
-myVMinParameter(0.),
-myVMaxParameter(0.),
-myDeflection(0.01),
-myIsDone(Standard_False)
+       myFirstParameter(0.),
+       myLastParameter(0.),
+       myUMinParameter(0.),
+       myUMaxParameter(0.),
+       myVMinParameter(0.),
+       myVMaxParameter(0.),
+       myDeflection(0.01),
+       myIsDone(Standard_False)
 {
   Init(theCurve, theSurface, theBeanTolerance, theFaceTolerance);
 }
@@ -179,28 +177,28 @@ myIsDone(Standard_False)
 // purpose: 
 // ==================================================================================
 IntTools_BeanFaceIntersector::IntTools_BeanFaceIntersector(const BRepAdaptor_Curve&   theCurve,
-                                                          const BRepAdaptor_Surface& theSurface,
-                                                          const Standard_Real        theFirstParOnCurve,
-                                                          const Standard_Real        theLastParOnCurve,
-                                                          const Standard_Real        theUMinParameter,
-                                                          const Standard_Real        theUMaxParameter,
-                                                          const Standard_Real        theVMinParameter,
-                                                          const Standard_Real        theVMaxParameter,
-                                                          const Standard_Real        theBeanTolerance,
-                                                          const Standard_Real        theFaceTolerance) :
-myFirstParameter(theFirstParOnCurve),
-myLastParameter(theLastParOnCurve),
-myUMinParameter(theUMinParameter),
-myUMaxParameter(theUMaxParameter),
-myVMinParameter(theVMinParameter),
-myVMaxParameter(theVMaxParameter),
-myBeanTolerance(theBeanTolerance),
-myFaceTolerance(theFaceTolerance),
-myDeflection(0.01),
-myIsDone(Standard_False)
+                                                           const BRepAdaptor_Surface& theSurface,
+                                                           const Standard_Real        theFirstParOnCurve,
+                                                           const Standard_Real        theLastParOnCurve,
+                                                           const Standard_Real        theUMinParameter,
+                                                           const Standard_Real        theUMaxParameter,
+                                                           const Standard_Real        theVMinParameter,
+                                                           const Standard_Real        theVMaxParameter,
+                                                           const Standard_Real        theBeanTolerance,
+                                                           const Standard_Real        theFaceTolerance) :
+       myFirstParameter(theFirstParOnCurve),
+       myLastParameter(theLastParOnCurve),
+       myUMinParameter(theUMinParameter),
+       myUMaxParameter(theUMaxParameter),
+       myVMinParameter(theVMinParameter),
+       myVMaxParameter(theVMaxParameter),
+       myBeanTolerance(theBeanTolerance),
+       myFaceTolerance(theFaceTolerance),
+       myDeflection(0.01),
+       myIsDone(Standard_False)
 {
   myCurve = theCurve;
-
+  
   myCriteria = myBeanTolerance + myFaceTolerance;
   myCurveResolution = myCurve.Resolution(myCriteria);
 
@@ -213,19 +211,19 @@ myIsDone(Standard_False)
 // purpose: 
 // ==================================================================================
 void IntTools_BeanFaceIntersector::Init(const TopoDS_Edge& theEdge,
-                                       const TopoDS_Face& theFace) 
+                                        const TopoDS_Face& theFace) 
 {
   myCurve.Initialize(theEdge);
   mySurface.Initialize(theFace);
   myTrsfSurface = Handle(Geom_Surface)::DownCast(mySurface.Surface().Surface()->Transformed(mySurface.Trsf()));
   myBeanTolerance = BRep_Tool::Tolerance(theEdge);
   myFaceTolerance = BRep_Tool::Tolerance(theFace);
-
+  
   myCriteria = myBeanTolerance + myFaceTolerance;
   myCurveResolution = myCurve.Resolution(myCriteria);
 
   SetSurfaceParameters(mySurface.FirstUParameter(), mySurface.LastUParameter(), 
-                      mySurface.FirstVParameter(), mySurface.LastVParameter());
+                       mySurface.FirstVParameter(), mySurface.LastVParameter());
   myResults.Clear();
 }
 
@@ -234,21 +232,21 @@ void IntTools_BeanFaceIntersector::Init(const TopoDS_Edge& theEdge,
 // purpose: 
 // ==================================================================================
 void IntTools_BeanFaceIntersector::Init(const BRepAdaptor_Curve&   theCurve,
-                                       const BRepAdaptor_Surface& theSurface,
-                                       const Standard_Real        theBeanTolerance,
-                                       const Standard_Real        theFaceTolerance) 
+                                        const BRepAdaptor_Surface& theSurface,
+                                        const Standard_Real        theBeanTolerance,
+                                        const Standard_Real        theFaceTolerance) 
 {
   myCurve = theCurve;
   mySurface = theSurface;
   myTrsfSurface = Handle(Geom_Surface)::DownCast(mySurface.Surface().Surface()->Transformed(mySurface.Trsf()));
   myBeanTolerance = theBeanTolerance;
   myFaceTolerance = theFaceTolerance;
-
+  
   myCriteria = myBeanTolerance + myFaceTolerance;
   myCurveResolution = myCurve.Resolution(myCriteria);
-
+  
   SetSurfaceParameters(mySurface.FirstUParameter(), mySurface.LastUParameter(), 
-                      mySurface.FirstVParameter(), mySurface.LastVParameter());
+                       mySurface.FirstVParameter(), mySurface.LastVParameter());
   myResults.Clear();
 }
 
@@ -257,15 +255,15 @@ void IntTools_BeanFaceIntersector::Init(const BRepAdaptor_Curve&   theCurve,
 // purpose: 
 // ==================================================================================
 void IntTools_BeanFaceIntersector::Init(const BRepAdaptor_Curve&   theCurve,
-                                       const BRepAdaptor_Surface& theSurface,
-                                       const Standard_Real        theFirstParOnCurve,
-                                       const Standard_Real        theLastParOnCurve,
-                                       const Standard_Real        theUMinParameter,
-                                       const Standard_Real        theUMaxParameter,
-                                       const Standard_Real        theVMinParameter,
-                                       const Standard_Real        theVMaxParameter,
-                                       const Standard_Real        theBeanTolerance,
-                                       const Standard_Real        theFaceTolerance) 
+                                        const BRepAdaptor_Surface& theSurface,
+                                        const Standard_Real        theFirstParOnCurve,
+                                        const Standard_Real        theLastParOnCurve,
+                                        const Standard_Real        theUMinParameter,
+                                        const Standard_Real        theUMaxParameter,
+                                        const Standard_Real        theVMinParameter,
+                                        const Standard_Real        theVMaxParameter,
+                                        const Standard_Real        theBeanTolerance,
+                                        const Standard_Real        theFaceTolerance) 
 {
   Init(theCurve, theSurface, theBeanTolerance, theFaceTolerance);
   SetBeanParameters(theFirstParOnCurve, theLastParOnCurve);
@@ -276,7 +274,7 @@ void IntTools_BeanFaceIntersector::Init(const BRepAdaptor_Curve&   theCurve,
 // function: SetContext
 // purpose: 
 // ==================================================================================
-void IntTools_BeanFaceIntersector::SetContext(const Handle(BOPInt_Context)& theContext) 
+void IntTools_BeanFaceIntersector::SetContext(const Handle(IntTools_Context)& theContext) 
 {
   myContext = theContext;
 }
@@ -284,7 +282,7 @@ void IntTools_BeanFaceIntersector::SetContext(const Handle(BOPInt_Context)& theC
 // function: Context
 // purpose: 
 // ==================================================================================
-const Handle(BOPInt_Context)& IntTools_BeanFaceIntersector::Context()const
+const Handle(IntTools_Context)& IntTools_BeanFaceIntersector::Context()const
 {
   return myContext;
 }
@@ -294,7 +292,7 @@ const Handle(BOPInt_Context)& IntTools_BeanFaceIntersector::Context()const
 // purpose: 
 // ==================================================================================
 void IntTools_BeanFaceIntersector::SetBeanParameters(const Standard_Real theFirstParOnCurve,
-                                                    const Standard_Real theLastParOnCurve) 
+                                                     const Standard_Real theLastParOnCurve) 
 {
   myFirstParameter = theFirstParOnCurve;
   myLastParameter  = theLastParOnCurve;
@@ -305,9 +303,9 @@ void IntTools_BeanFaceIntersector::SetBeanParameters(const Standard_Real theFirs
 // purpose: 
 // ==================================================================================
 void IntTools_BeanFaceIntersector::SetSurfaceParameters(const Standard_Real theUMinParameter,
-                                                       const Standard_Real theUMaxParameter,
-                                                       const Standard_Real theVMinParameter,
-                                                       const Standard_Real theVMaxParameter) 
+                                                        const Standard_Real theUMaxParameter,
+                                                        const Standard_Real theVMinParameter,
+                                                        const Standard_Real theVMaxParameter) 
 {
   myUMinParameter  = theUMinParameter;
   myUMaxParameter  = theUMaxParameter;
@@ -329,7 +327,7 @@ void IntTools_BeanFaceIntersector::Perform()
   myDeflection = aRelativeDeflection;
   //
   if (myContext.IsNull()) {
-    myContext=new BOPInt_Context;
+    myContext=new IntTools_Context;
   }
   //
   if(myCurve.GetType()==GeomAbs_Line && mySurface.GetType()==GeomAbs_Plane) {
@@ -390,11 +388,11 @@ void IntTools_BeanFaceIntersector::Perform()
     IntTools_CArray1OfReal aParams;
     
     if(IntTools::PrepareArgs(myCurve, 
-                            myLastParameter, 
-                            myFirstParameter, 
-                            aDiscretization, 
-                            aRelativeDeflection, 
-                            aParams)) {
+                             myLastParameter, 
+                             myFirstParameter, 
+                             aDiscretization, 
+                             aRelativeDeflection, 
+                             aParams)) {
       return;
     }
 
@@ -519,7 +517,7 @@ Standard_Real IntTools_BeanFaceIntersector::Distance(const Standard_Real theArg)
        useMinMaxPoints = Standard_False;
        
        if(aDistance > aProjectorOnCurve.LowerDistance())
-         aDistance = aProjectorOnCurve.LowerDistance();
+  aDistance = aProjectorOnCurve.LowerDistance();
       }
     }
 
@@ -539,11 +537,11 @@ Standard_Real IntTools_BeanFaceIntersector::Distance(const Standard_Real theArg)
 // purpose: 
 // ==================================================================================
 Standard_Real IntTools_BeanFaceIntersector::Distance(const Standard_Real theArg,
-                                                    Standard_Real&      theUParameter,
-                                                    Standard_Real&      theVParameter)  
+                                                     Standard_Real&      theUParameter,
+                                                     Standard_Real&      theVParameter)  
 {
   gp_Pnt aPoint = myCurve.Value(theArg);
-
+  
   theUParameter = myUMinParameter;
   theVParameter = myVMinParameter;
   // 
@@ -569,46 +567,46 @@ Standard_Real IntTools_BeanFaceIntersector::Distance(const Standard_Real theArg,
       gp_Pnt aPointMin = (i < 2) ? mySurface.Value(anIsoParameter, aMinParameter) : mySurface.Value(aMinParameter, anIsoParameter);
       gp_Pnt aPointMax = (i < 2) ? mySurface.Value(anIsoParameter, aMaxParameter) : mySurface.Value(aMaxParameter, anIsoParameter);
       gp_Pnt aPointMid = (i < 2) ? mySurface.Value(anIsoParameter, aMidParameter) : mySurface.Value(aMidParameter, anIsoParameter);
-
+      
       Standard_Boolean useMinMaxPoints = Standard_True;
       Standard_Boolean computeisoline = Standard_True;
       
       if(aPointMin.IsEqual(aPointMax, myCriteria) &&
-        aPointMin.IsEqual(aPointMid, myCriteria) &&
-        aPointMax.IsEqual(aPointMid, myCriteria)) {
-       computeisoline = Standard_False;
-      }
-
+         aPointMin.IsEqual(aPointMid, myCriteria) &&
+         aPointMax.IsEqual(aPointMid, myCriteria)) {
+        computeisoline = Standard_False;
+                                                           }
+      
       if(computeisoline) {
-       Handle(Geom_Curve) aCurve = (i < 2) ? myTrsfSurface->UIso(anIsoParameter) : myTrsfSurface->VIso(anIsoParameter);
-       GeomAPI_ProjectPointOnCurve aProjectorOnCurve(aPoint, aCurve, aMinParameter, aMaxParameter);
-       
-       if(aProjectorOnCurve.NbPoints() > 0) {
-         useMinMaxPoints = Standard_False;
-
-         if(aDistance > aProjectorOnCurve.LowerDistance()) {
-           theUParameter = (i<=1) ? anIsoParameter : aProjectorOnCurve.LowerDistanceParameter();
-           theVParameter = (i>=2) ? anIsoParameter : aProjectorOnCurve.LowerDistanceParameter();
-           aDistance = aProjectorOnCurve.LowerDistance();
-         }
-       }
+        Handle(Geom_Curve) aCurve = (i < 2) ? myTrsfSurface->UIso(anIsoParameter) : myTrsfSurface->VIso(anIsoParameter);
+        GeomAPI_ProjectPointOnCurve aProjectorOnCurve(aPoint, aCurve, aMinParameter, aMaxParameter);
+        
+        if(aProjectorOnCurve.NbPoints() > 0) {
+          useMinMaxPoints = Standard_False;
+          
+          if(aDistance > aProjectorOnCurve.LowerDistance()) {
+            theUParameter = (i<=1) ? anIsoParameter : aProjectorOnCurve.LowerDistanceParameter();
+            theVParameter = (i>=2) ? anIsoParameter : aProjectorOnCurve.LowerDistanceParameter();
+            aDistance = aProjectorOnCurve.LowerDistance();
+          }
+        }
       }
-
+      
       if(useMinMaxPoints) {
-       Standard_Real aPPDistance = aPoint.Distance(aPointMin);
-       
-       if(aPPDistance < aDistance) {
-         theUParameter = (i<=1) ? anIsoParameter : aMinParameter;
-         theVParameter = (i>=2) ? anIsoParameter : aMinParameter;
-         aDistance = aPPDistance;
-       }
-       aPPDistance = aPoint.Distance(aPointMax);
-       
-       if(aPPDistance < aDistance) {
-         theUParameter = (i<=1) ? anIsoParameter : aMaxParameter;
-         theVParameter = (i>=2) ? anIsoParameter : aMaxParameter;
-         aDistance = aPPDistance;
-       }
+        Standard_Real aPPDistance = aPoint.Distance(aPointMin);
+        
+        if(aPPDistance < aDistance) {
+          theUParameter = (i<=1) ? anIsoParameter : aMinParameter;
+          theVParameter = (i>=2) ? anIsoParameter : aMinParameter;
+          aDistance = aPPDistance;
+        }
+        aPPDistance = aPoint.Distance(aPointMax);
+        
+        if(aPPDistance < aDistance) {
+          theUParameter = (i<=1) ? anIsoParameter : aMaxParameter;
+          theVParameter = (i>=2) ? anIsoParameter : aMaxParameter;
+          aDistance = aPPDistance;
+        }
       }
     }
   }
@@ -616,7 +614,7 @@ Standard_Real IntTools_BeanFaceIntersector::Distance(const Standard_Real theArg,
   theUParameter = (myUMaxParameter < theUParameter) ? myUMaxParameter : theUParameter;
   theVParameter = (myVMinParameter > theVParameter) ? myVMinParameter : theVParameter;
   theVParameter = (myVMaxParameter < theVParameter) ? myVMaxParameter : theVParameter;
-
+  
   return aDistance;
 }
 
@@ -630,77 +628,77 @@ void IntTools_BeanFaceIntersector::ComputeAroundExactIntersection()
   
   Handle(BRepAdaptor_HCurve) aCurve     = new BRepAdaptor_HCurve(myCurve);
   Handle(BRepAdaptor_HSurface) aSurface = new BRepAdaptor_HSurface(mySurface);
-
+  
   anExactIntersector.Perform(aCurve, aSurface);
-
+  
   if(anExactIntersector.IsDone()) {
     Standard_Integer i = 0;
-
+    
     for(i = 1; i <= anExactIntersector.NbPoints(); i++) {
       const IntCurveSurface_IntersectionPoint& aPoint = anExactIntersector.Point(i);
       
       if((aPoint.W() >= myFirstParameter) && (aPoint.W() <= myLastParameter)) {
-       Standard_Boolean UIsNotValid = ((myUMinParameter > aPoint.U()) || (aPoint.U() > myUMaxParameter));
-       Standard_Boolean VIsNotValid = ((myVMinParameter > aPoint.V()) || (aPoint.V() > myVMaxParameter));
-       Standard_Boolean solutionIsValid = !UIsNotValid && !VIsNotValid;
-       Standard_Real U = aPoint.U();
-       Standard_Real V = aPoint.V();
-
-       if(UIsNotValid || VIsNotValid) {
-// modified by NIZHNY-MKK  Thu Jun 17 12:50:39 2004
-         Standard_Boolean bUCorrected = Standard_True;
-
-         if(UIsNotValid) {
-// modified by NIZHNY-MKK  Thu Jun 17 12:50:37 2004
-           bUCorrected = Standard_False;
-           solutionIsValid = Standard_False;
-           
-           if(mySurface.IsUPeriodic()) {
-             Standard_Real aNewU = U;
-             
-             if(AdjustPeriodic(U, myUMinParameter, myUMaxParameter, mySurface.UPeriod(), aNewU)) {
-               solutionIsValid = Standard_True;
-// modified by NIZHNY-MKK  Thu Jun 17 12:51:01 2004
-               bUCorrected = Standard_True;
-               U = aNewU;
-             }
-           }
-         }
-         // modified by NIZHNY-MKK  Thu Jun 17 12:51:03 2004
-//       if(solutionIsValid && VIsNotValid) {
-         if(bUCorrected && VIsNotValid) {
-           solutionIsValid = Standard_False;
-           
-           if(mySurface.IsVPeriodic()) {
-             Standard_Real aNewV = V;
-             
-             if(AdjustPeriodic(V, myVMinParameter, myVMaxParameter, mySurface.VPeriod(), aNewV)) {
-               solutionIsValid = Standard_True;
-               V = aNewV;
-             }
-           }
-         }
-       }
-       
-       if(!solutionIsValid)
-         continue;
-
-       Standard_Integer aNbRanges = myRangeManager.Length();
-
-       ComputeRangeFromStartPoint(Standard_False, aPoint.W(), U, V);
-       ComputeRangeFromStartPoint(Standard_True, aPoint.W(), U, V);
-
-       if(aNbRanges == myRangeManager.Length()) {        
-         SetEmptyResultRange(aPoint.W(), myRangeManager);
-       } // end if(aNbRanges == myRangeManager.Length())
+        Standard_Boolean UIsNotValid = ((myUMinParameter > aPoint.U()) || (aPoint.U() > myUMaxParameter));
+        Standard_Boolean VIsNotValid = ((myVMinParameter > aPoint.V()) || (aPoint.V() > myVMaxParameter));
+        Standard_Boolean solutionIsValid = !UIsNotValid && !VIsNotValid;
+        Standard_Real U = aPoint.U();
+        Standard_Real V = aPoint.V();
+        
+        if(UIsNotValid || VIsNotValid) {
+          // modified by NIZHNY-MKK  Thu Jun 17 12:50:39 2004
+          Standard_Boolean bUCorrected = Standard_True;
+          
+          if(UIsNotValid) {
+            // modified by NIZHNY-MKK  Thu Jun 17 12:50:37 2004
+            bUCorrected = Standard_False;
+            solutionIsValid = Standard_False;
+            
+            if(mySurface.IsUPeriodic()) {
+              Standard_Real aNewU = U;
+              
+              if(AdjustPeriodic(U, myUMinParameter, myUMaxParameter, mySurface.UPeriod(), aNewU)) {
+                solutionIsValid = Standard_True;
+                // modified by NIZHNY-MKK  Thu Jun 17 12:51:01 2004
+                bUCorrected = Standard_True;
+                U = aNewU;
+              }
+            }
+          }
+          // modified by NIZHNY-MKK  Thu Jun 17 12:51:03 2004
+          //   if(solutionIsValid && VIsNotValid) {
+          if(bUCorrected && VIsNotValid) {
+            solutionIsValid = Standard_False;
+            
+            if(mySurface.IsVPeriodic()) {
+              Standard_Real aNewV = V;
+              
+              if(AdjustPeriodic(V, myVMinParameter, myVMaxParameter, mySurface.VPeriod(), aNewV)) {
+                solutionIsValid = Standard_True;
+                V = aNewV;
+              }
+            }
+          }
+        }
+        
+        if(!solutionIsValid)
+          continue;
+        
+        Standard_Integer aNbRanges = myRangeManager.Length();
+        
+        ComputeRangeFromStartPoint(Standard_False, aPoint.W(), U, V);
+        ComputeRangeFromStartPoint(Standard_True, aPoint.W(), U, V);
+        
+        if(aNbRanges == myRangeManager.Length()) {  
+          SetEmptyResultRange(aPoint.W(), myRangeManager);
+        } // end if(aNbRanges == myRangeManager.Length())
       }
     }
-
+    
     for(i = 1; i <= anExactIntersector.NbSegments(); i++) {
       const IntCurveSurface_IntersectionSegment& aSegment = anExactIntersector.Segment(i);
       IntCurveSurface_IntersectionPoint aPoint1, aPoint2;
       aSegment.Values(aPoint1, aPoint2);
-
+      
       Standard_Real aFirstParameter = (aPoint1.W() < myFirstParameter) ? myFirstParameter : aPoint1.W();
       Standard_Real aLastParameter = (myLastParameter < aPoint2.W())   ? myLastParameter  : aPoint2.W();
 
@@ -1037,11 +1035,11 @@ void IntTools_BeanFaceIntersector::ComputeUsingExtremum()
   Tol = Precision::PConfusion();
   Handle(Geom_Curve) aCurve = BRep_Tool::Curve  (myCurve.Edge(), af, al);
   GeomAdaptor_Surface aGASurface (myTrsfSurface, 
-                                 myUMinParameter, 
-                                 myUMaxParameter, 
-                                 myVMinParameter, 
-                                 myVMaxParameter);
-
+                                  myUMinParameter, 
+                                  myUMaxParameter, 
+                                  myVMinParameter, 
+                                  myVMaxParameter);
+  
   Bnd_Box FBox;
   BndLib_AddSurface::Add(mySurface, 0., FBox);
   FBox.Enlarge(myFaceTolerance);
@@ -1058,7 +1056,7 @@ void IntTools_BeanFaceIntersector::ComputeUsingExtremum()
     if(anarg2 - anarg1 < Precision::PConfusion()) {
 
       if(((i > 1) && (myRangeManager.Flag(i-1) == 2)) ||
-        ((i <  myRangeManager.Length()) && (myRangeManager.Flag(i+1) == 2))) {
+ ((i <  myRangeManager.Length()) && (myRangeManager.Flag(i+1) == 2))) {
        myRangeManager.SetFlag(i, 1);
        continue;
       }
@@ -1074,108 +1072,108 @@ void IntTools_BeanFaceIntersector::ComputeUsingExtremum()
       myRangeManager.SetFlag(i, 1);
       continue;
     }
-
+    
     GeomAdaptor_Curve aGACurve(aCurve, anarg1, anarg2);
     Extrema_ExtCS theExtCS(aGACurve, aGASurface, Tol, Tol);
     myExtrema = theExtCS; 
     
     if(myExtrema.IsDone() && (myExtrema.NbExt() || myExtrema.IsParallel())) {
       Standard_Integer anOldNbRanges = myRangeManager.Length();
-
+      
       if (myExtrema.IsParallel()) {
-
-       if(myExtrema.SquareDistance(1) < myCriteria * myCriteria) {
-         Standard_Real U1, V1, U2, V2;
-         Standard_Real adistance1 = Distance(anarg1, U1, V1);
-         Standard_Real adistance2 = Distance(anarg2, U2, V2);
-         Standard_Boolean validdistance1 = (adistance1 < myCriteria);
-         Standard_Boolean validdistance2 = (adistance2 < myCriteria);
-
-         if (validdistance1 && validdistance2) {
-           myRangeManager.InsertRange(anarg1, anarg2, 2);
-           continue;
-         }
-         else {
-           if(validdistance1) {
-             ComputeRangeFromStartPoint(Standard_True, anarg1, U1, V1);
-           }
-           else {
-             if(validdistance2) {
-               ComputeRangeFromStartPoint(Standard_False, anarg2, U2, V2);
-             }
-             else {
-               Standard_Real a  = anarg1;
-               Standard_Real b  = anarg2;
-               Standard_Real da = adistance1;
-               Standard_Real db = adistance2;
-               Standard_Real asolution = a;
-               Standard_Boolean found = Standard_False;
-
-               while(((b - a) > myCurveResolution) && !found) {
-                 asolution = (a+b)*0.5;
-                 Standard_Real adist = Distance(asolution, U1, V1);
-                 
-                 if(adist < myCriteria) {
-                   found = Standard_True;
-                 }
-                 else {
-                   if(da < db) {
-                     b = asolution;
-                     db = adist;
-                   }
-                   else {
-                     a = asolution;
-                     da = adist;
-                   }
-                 }
-               } // end while
-
-               if(found) {
-                 ComputeRangeFromStartPoint(Standard_False, asolution, U1, V1);
-                 ComputeRangeFromStartPoint(Standard_True, asolution, U1, V1);
-               }
-               else {
-                 myRangeManager.SetFlag(i, 1);
-               }
-             }
-           }
-         }
-       }
-       else {
-         myRangeManager.SetFlag(i, 1);
-       }
+        
+        if(myExtrema.SquareDistance(1) < myCriteria * myCriteria) {
+          Standard_Real U1, V1, U2, V2;
+          Standard_Real adistance1 = Distance(anarg1, U1, V1);
+          Standard_Real adistance2 = Distance(anarg2, U2, V2);
+          Standard_Boolean validdistance1 = (adistance1 < myCriteria);
+          Standard_Boolean validdistance2 = (adistance2 < myCriteria);
+          
+          if (validdistance1 && validdistance2) {
+            myRangeManager.InsertRange(anarg1, anarg2, 2);
+            continue;
+          }
+          else {
+            if(validdistance1) {
+              ComputeRangeFromStartPoint(Standard_True, anarg1, U1, V1);
+            }
+            else {
+              if(validdistance2) {
+                ComputeRangeFromStartPoint(Standard_False, anarg2, U2, V2);
+              }
+              else {
+                Standard_Real a  = anarg1;
+                Standard_Real b  = anarg2;
+                Standard_Real da = adistance1;
+                Standard_Real db = adistance2;
+                Standard_Real asolution = a;
+                Standard_Boolean found = Standard_False;
+                
+                while(((b - a) > myCurveResolution) && !found) {
+                  asolution = (a+b)*0.5;
+                  Standard_Real adist = Distance(asolution, U1, V1);
+                  
+                  if(adist < myCriteria) {
+                    found = Standard_True;
+                  }
+                  else {
+                    if(da < db) {
+                      b = asolution;
+                      db = adist;
+                    }
+                    else {
+                      a = asolution;
+                      da = adist;
+                    }
+                  }
+                } // end while
+                
+                if(found) {
+                  ComputeRangeFromStartPoint(Standard_False, asolution, U1, V1);
+                  ComputeRangeFromStartPoint(Standard_True, asolution, U1, V1);
+                }
+                else {
+                  myRangeManager.SetFlag(i, 1);
+                }
+              }
+            }
+          }
+        }
+        else {
+          myRangeManager.SetFlag(i, 1);
+        }
       }
       else {
-       Standard_Boolean solutionfound = Standard_False;
-
-       for(Standard_Integer j = 1 ; j <= myExtrema.NbExt(); j++) {
-
-         if(myExtrema.SquareDistance(j) < myCriteria * myCriteria) {
-           Extrema_POnCurv p1;
-           Extrema_POnSurf p2;
-           myExtrema.Points(j, p1, p2);
-           Standard_Real U, V;
-           p2.Parameter(U, V);
-
-           Standard_Integer aNbRanges = myRangeManager.Length();
-           ComputeRangeFromStartPoint(Standard_False, p1.Parameter(), U, V);
-           ComputeRangeFromStartPoint(Standard_True, p1.Parameter(), U, V);
-           solutionfound = Standard_True;
-           
-           if(aNbRanges == myRangeManager.Length()) {
-             SetEmptyResultRange(p1.Parameter(), myRangeManager);
-           }
-         }
-       } //end for
-
-       if(!solutionfound) {
-         myRangeManager.SetFlag(i, 1);
-       }
+        Standard_Boolean solutionfound = Standard_False;
+        
+        for(Standard_Integer j = 1 ; j <= myExtrema.NbExt(); j++) {
+          
+          if(myExtrema.SquareDistance(j) < myCriteria * myCriteria) {
+            Extrema_POnCurv p1;
+            Extrema_POnSurf p2;
+            myExtrema.Points(j, p1, p2);
+            Standard_Real U, V;
+            p2.Parameter(U, V);
+            
+            Standard_Integer aNbRanges = myRangeManager.Length();
+            ComputeRangeFromStartPoint(Standard_False, p1.Parameter(), U, V);
+            ComputeRangeFromStartPoint(Standard_True, p1.Parameter(), U, V);
+            solutionfound = Standard_True;
+            
+            if(aNbRanges == myRangeManager.Length()) {
+              SetEmptyResultRange(p1.Parameter(), myRangeManager);
+            }
+          }
+        } //end for
+        
+        if(!solutionfound) {
+          myRangeManager.SetFlag(i, 1);
+        }
       }
       Standard_Integer adifference = myRangeManager.Length() - anOldNbRanges;
       
       if(adifference > 0) {
-       i+=adifference;
+        i+=adifference;
       }
     } // end if(myExtrema.IsDone() && (myExtrema.NbExt() || myExtrema.IsParallel()))
   }
@@ -1189,41 +1187,41 @@ void IntTools_BeanFaceIntersector::ComputeNearRangeBoundaries()
 {
   Standard_Real U = myUMinParameter;
   Standard_Real V = myVMinParameter;
-
+  
   for(Standard_Integer i = 1; i <= myRangeManager.Length(); i++) {
 
     if(myRangeManager.Flag(i) > 0)
       continue;
-
+    
     if((i > 1) && (myRangeManager.Flag(i-1) > 0))
       continue;
-
+    
     IntTools_Range aParamRange = myRangeManager.Range(i);
-
+    
     if(Distance(aParamRange.First(), U, V) < myCriteria) {
       Standard_Integer aNbRanges = myRangeManager.Length();
       
       if(i > 1) {
-       ComputeRangeFromStartPoint(Standard_False, aParamRange.First(), U, V, i-1);
+        ComputeRangeFromStartPoint(Standard_False, aParamRange.First(), U, V, i-1);
       }
       ComputeRangeFromStartPoint(Standard_True, aParamRange.First(), U, V, i + (myRangeManager.Length() - aNbRanges));
-
+      
       if(aNbRanges == myRangeManager.Length()) {
-       SetEmptyResultRange(aParamRange.First(), myRangeManager);
+        SetEmptyResultRange(aParamRange.First(), myRangeManager);
       }
     }
   }
-
+  
   if(myRangeManager.Flag(myRangeManager.Length()) == 0) {
     IntTools_Range aParamRange = myRangeManager.Range(myRangeManager.Length());
-
+    
     if(Distance(aParamRange.Last(), U, V) < myCriteria) {
       Standard_Integer aNbRanges = myRangeManager.Length();
       
       ComputeRangeFromStartPoint(Standard_False, aParamRange.Last(), U, V, myRangeManager.Length());
       
       if(aNbRanges == myRangeManager.Length()) {
-       SetEmptyResultRange(aParamRange.Last(), myRangeManager);
+        SetEmptyResultRange(aParamRange.Last(), myRangeManager);
       }
     }
   }
@@ -1236,16 +1234,16 @@ void IntTools_BeanFaceIntersector::ComputeNearRangeBoundaries()
 //           decreasing parameter on curve if ToIncreaseParameter == Standard_False
 // ==================================================================================
 void IntTools_BeanFaceIntersector::ComputeRangeFromStartPoint(const Standard_Boolean ToIncreaseParameter,
-                                                             const Standard_Real    theParameter,
-                                                             const Standard_Real    theUParameter,
-                                                             const Standard_Real    theVParameter) 
+        const Standard_Real    theParameter,
+        const Standard_Real    theUParameter,
+        const Standard_Real    theVParameter) 
 {
   Standard_Integer aFoundIndex = myRangeManager.GetIndex(theParameter, ToIncreaseParameter);
-
+  
   if(aFoundIndex == 0) {
     return;
   }
-
+  
   ComputeRangeFromStartPoint(ToIncreaseParameter, theParameter, theUParameter, theVParameter, aFoundIndex);
 }
 
@@ -1257,16 +1255,16 @@ void IntTools_BeanFaceIntersector::ComputeRangeFromStartPoint(const Standard_Boo
 //           theIndex indicate that theParameter belong the range number theIndex.
 // ==================================================================================
 void IntTools_BeanFaceIntersector::ComputeRangeFromStartPoint(const Standard_Boolean ToIncreaseParameter,
-                                                             const Standard_Real    theParameter,
-                                                             const Standard_Real    theUParameter,
-                                                             const Standard_Real    theVParameter,
-                                                             const Standard_Integer theIndex) 
+        const Standard_Real    theParameter,
+        const Standard_Real    theUParameter,
+        const Standard_Real    theVParameter,
+        const Standard_Integer theIndex) 
 {
   if(myRangeManager.Flag(theIndex) > 0)
     return;
-
-    Standard_Integer aValidIndex = theIndex;
-
+  
+  Standard_Integer aValidIndex = theIndex;
+  
   Standard_Real aMinDelta        = myCurveResolution * 0.5;
   Standard_Real aDeltaRestrictor = myLastParameter - myFirstParameter;
 
@@ -1301,12 +1299,12 @@ void IntTools_BeanFaceIntersector::ComputeRangeFromStartPoint(const Standard_Boo
     // 
     gp_Pnt aPoint = myCurve.Value(aCurPar);
     Extrema_GenLocateExtPS anExtrema(aPoint, mySurface, U, V, 1.e-10, 1.e-10);
-
+    
     if(anExtrema.IsDone()) {
       if(anExtrema.SquareDistance() < myCriteria * myCriteria) {
-       Extrema_POnSurf aPOnSurf = anExtrema.Point();
+        Extrema_POnSurf aPOnSurf = anExtrema.Point();
        aPOnSurf.Parameter(U, V);
-       pointfound = Standard_True;
+        pointfound = Standard_True;
       }
     }
     else {
@@ -1316,68 +1314,68 @@ void IntTools_BeanFaceIntersector::ComputeRangeFromStartPoint(const Standard_Boo
     if(pointfound) {
       aPrevPar = aCurPar;
       anotherSolutionFound = Standard_True;
-
+      
       if(BoundaryCondition && (isboundaryindex || !isvalidindex))
-       break;
+        break;
     }
     else {
       aDeltaRestrictor = aDelta;
     }
-
+    
     // if point found decide to increase aDelta using derivative of distance function
     //
-
+    
     aDelta = (pointfound) ? (aDelta * 2.) : (aDelta * 0.5);
     aDelta = (aDelta < aDeltaRestrictor) ? aDelta : aDeltaRestrictor;
     
     aCurPar = (ToIncreaseParameter) ? (aPrevPar + aDelta) : (aPrevPar - aDelta);
-
-
+    
+    
     // prevent infinite loop when (aPrevPar +/- aDelta) == aPrevPar == 0.
     //
-
+    
     if( aCurPar == aPrevPar )
       break;
-
+    
     BoundaryCondition  = (ToIncreaseParameter) ? (aCurPar > aCurrentRange.Last()) : (aCurPar < aCurrentRange.First());
-
+    
     isboundaryindex = Standard_False;
     isvalidindex = Standard_True;
-
+    
     if(BoundaryCondition) {
       isboundaryindex = ((!ToIncreaseParameter && (aValidIndex == 1)) ||
-                        (ToIncreaseParameter && (aValidIndex == myRangeManager.Length())));
-
+                         (ToIncreaseParameter && (aValidIndex == myRangeManager.Length())));
+      
       if(!isboundaryindex) {
-
-       if(pointfound) {
-         Standard_Integer aFlag = (ToIncreaseParameter) ? myRangeManager.Flag(aValidIndex + 1) : myRangeManager.Flag(aValidIndex - 1);
-
-         if(aFlag==0) {            
-           aValidIndex = (ToIncreaseParameter) ? (aValidIndex + 1) : (aValidIndex - 1);
-           aCurrentRange = myRangeManager.Range(aValidIndex);
-
-           if((ToIncreaseParameter && (aCurPar > aCurrentRange.Last())) ||
-              (!ToIncreaseParameter && (aCurPar < aCurrentRange.First()))) {
-             aCurPar = (aCurrentRange.First() + aCurrentRange.Last()) * 0.5;
-             aDelta*=0.5;
-           }
-         }
-         else {
-           isvalidindex = Standard_False;
-           aCurPar = (ToIncreaseParameter) ? aCurrentRange.Last() : aCurrentRange.First();
-         }
-       }
+        
+        if(pointfound) {
+          Standard_Integer aFlag = (ToIncreaseParameter) ? myRangeManager.Flag(aValidIndex + 1) : myRangeManager.Flag(aValidIndex - 1);
+          
+          if(aFlag==0) {    
+            aValidIndex = (ToIncreaseParameter) ? (aValidIndex + 1) : (aValidIndex - 1);
+            aCurrentRange = myRangeManager.Range(aValidIndex);
+            
+            if((ToIncreaseParameter && (aCurPar > aCurrentRange.Last())) ||
+               (!ToIncreaseParameter && (aCurPar < aCurrentRange.First()))) {
+              aCurPar = (aCurrentRange.First() + aCurrentRange.Last()) * 0.5;
+              aDelta*=0.5;
+            }
+          }
+          else {
+            isvalidindex = Standard_False;
+            aCurPar = (ToIncreaseParameter) ? aCurrentRange.Last() : aCurrentRange.First();
+          }
+        }
       }
       else {
-       aCurPar = (ToIncreaseParameter) ? aCurrentRange.Last() : aCurrentRange.First();
+        aCurPar = (ToIncreaseParameter) ? aCurrentRange.Last() : aCurrentRange.First();
       }      
-
+      
       if(aDelta < tenOfMinDelta) {
-       loopcounter++;
+        loopcounter++;
       }
       else {
-       loopcounter = 0;
+        loopcounter = 0;
       }
     } // if(BoundaryCondition)
   }
@@ -1395,10 +1393,10 @@ void IntTools_BeanFaceIntersector::ComputeRangeFromStartPoint(const Standard_Boo
 // purpose:  
 // ---------------------------------------------------------------------------------
 static Standard_Boolean AdjustPeriodic(const Standard_Real U, 
-                                      const Standard_Real UFirst,
-                                      const Standard_Real ULast,
-                                      const Standard_Real Period,
-                                      Standard_Real&      UResult) {
+                                       const Standard_Real UFirst,
+                                       const Standard_Real ULast,
+                                       const Standard_Real Period,
+                                       Standard_Real&      UResult) {
   UResult = U;
   Standard_Real u = U;
   Standard_Real Eps = Epsilon(Period);
@@ -1406,7 +1404,7 @@ static Standard_Boolean AdjustPeriodic(const Standard_Real U,
   while (Eps > (ULast -u)) u -= Period;
   if ( u < UFirst) 
     return Standard_False;
-
+  
   UResult = u;
   return Standard_True;
 }
@@ -1416,8 +1414,8 @@ static Standard_Boolean AdjustPeriodic(const Standard_Real U,
 // purpose:  
 // ---------------------------------------------------------------------------------
 static Standard_Boolean SetEmptyResultRange(const Standard_Real      theParameter, 
-                                           IntTools_MarkedRangeSet& theMarkedRange) {
-
+                                            IntTools_MarkedRangeSet& theMarkedRange) {
+  
   const TColStd_SequenceOfInteger& anIndices = theMarkedRange.GetIndices(theParameter);
   Standard_Boolean add = (anIndices.Length() > 0);
   
@@ -1499,16 +1497,16 @@ static Standard_Boolean SetEmptyResultRange(const Standard_Real      theParamete
 // purpose: 
 // ======================================================================================================================
 Standard_Boolean IntTools_BeanFaceIntersector::LocalizeSolutions(const IntTools_CurveRangeSample& theCurveRange,
-                                                                const Bnd_Box& theBoxCurve,
-                                                                const IntTools_SurfaceRangeSample& theSurfaceRange,
-                                                                const Bnd_Box& theBoxSurface,
-                                                                IntTools_CurveRangeLocalizeData& theCurveData,
-                                                                IntTools_SurfaceRangeLocalizeData& theSurfaceData,
-                                                                IntTools_ListOfCurveRangeSample& theListCurveRange,
-                                                                IntTools_ListOfSurfaceRangeSample& theListSurfaceRange) 
+           const Bnd_Box& theBoxCurve,
+           const IntTools_SurfaceRangeSample& theSurfaceRange,
+           const Bnd_Box& theBoxSurface,
+           IntTools_CurveRangeLocalizeData& theCurveData,
+           IntTools_SurfaceRangeLocalizeData& theSurfaceData,
+           IntTools_ListOfCurveRangeSample& theListCurveRange,
+           IntTools_ListOfSurfaceRangeSample& theListSurfaceRange) 
 {
   Standard_Integer tIt = 0, uIt = 0, vIt = 0;
-
+  
   // 
   IntTools_CurveRangeSample aRootRangeC(0);
   aRootRangeC.SetDepth(0);
@@ -1558,17 +1556,17 @@ Standard_Boolean IntTools_BeanFaceIntersector::LocalizeSolutions(const IntTools_
 
   // check
   CheckSampling(theCurveRange, theSurfaceRange, theCurveData, theSurfaceData,
-               localdiffC, aLocalDiffU, aLocalDiffV,
-               bAllowSamplingC, bAllowSamplingU, bAllowSamplingV);
+                localdiffC, aLocalDiffU, aLocalDiffV,
+                bAllowSamplingC, bAllowSamplingU, bAllowSamplingV);
   //
-
+  
   if(!bAllowSamplingC && !bAllowSamplingU && !bAllowSamplingV) {
     theListCurveRange.Append(theCurveRange);
     theListSurfaceRange.Append(theSurfaceRange);
     return Standard_True;
   }
   // ranges check.end
-
+  
   // init template. begin
   IntTools_CurveRangeSample aNewRangeCTemplate;
 
@@ -1628,232 +1626,232 @@ Standard_Boolean IntTools_BeanFaceIntersector::LocalizeSolutions(const IntTools_
       IntTools_SurfaceRangeSample aNewRangeS = aNewRangeSTemplate;
 
       if(bAllowSamplingU) {
-       aNewRangeS.SetIndexU(aCurIndexU);
+        aNewRangeS.SetIndexU(aCurIndexU);
       }
-
+      
       if(bAllowSamplingV) {
-       aNewRangeS.SetIndexV(aCurIndexV);
+        aNewRangeS.SetIndexV(aCurIndexV);
       }
-
+      
       if(theSurfaceData.IsRangeOut(aNewRangeS)) {
-       bHasOutV = Standard_True;
-       continue;
+        bHasOutV = Standard_True;
+        continue;
       }
-
+      
       // ///////
-
+      
       Bnd_Box aBoxS;
-
+      
       if(!theSurfaceData.FindBox(aNewRangeS, aBoxS)) {
-
-       if(mySurface.GetType() == GeomAbs_BSplineSurface) {
-//     if(Standard_False ) {
-         Handle(Geom_BSplineSurface) aSurfBspl = Handle(Geom_BSplineSurface)::DownCast(myTrsfSurface);
-         aBoxS = GetSurfaceBox(aSurfBspl, aPrevParU, aCurParU, aPrevParV, aCurParV, myCriteria, theSurfaceData);
-       }
-       else {
-         BndLib_AddSurface::Add(mySurface, aPrevParU, aCurParU, aPrevParV, aCurParV, myCriteria, aBoxS);
-       }
-//     Bnd_Box aMainBoxC;
-
-       if(!bMainBoxFoundC && theCurveData.FindBox(aRootRangeC, aMainBoxC)) {
-         bMainBoxFoundC = Standard_True;
-       }
-
-         if(aBoxS.IsOut(aMainBoxC)) {
-           theSurfaceData.AddOutRange(aNewRangeS);
-           bHasOutV = Standard_True;
-           continue;
-         }
-//     }
-       theSurfaceData.AddBox(aNewRangeS, aBoxS);
+        
+        if(mySurface.GetType() == GeomAbs_BSplineSurface) {
+          //   if(Standard_False ) {
+          Handle(Geom_BSplineSurface) aSurfBspl = Handle(Geom_BSplineSurface)::DownCast(myTrsfSurface);
+          aBoxS = GetSurfaceBox(aSurfBspl, aPrevParU, aCurParU, aPrevParV, aCurParV, myCriteria, theSurfaceData);
+        }
+        else {
+          BndLib_AddSurface::Add(mySurface, aPrevParU, aCurParU, aPrevParV, aCurParV, myCriteria, aBoxS);
+          }
+        //     Bnd_Box aMainBoxC;
+        
+        if(!bMainBoxFoundC && theCurveData.FindBox(aRootRangeC, aMainBoxC)) {
+          bMainBoxFoundC = Standard_True;
+        }
+        
+        if(aBoxS.IsOut(aMainBoxC)) {
+          theSurfaceData.AddOutRange(aNewRangeS);
+          bHasOutV = Standard_True;
+          continue;
+        }
+        //     }
+        theSurfaceData.AddBox(aNewRangeS, aBoxS);
       }
-       
+      
       if(aBoxS.IsOut(theBoxCurve)) {
-       bHasOutV = Standard_True;
-       continue;
+        bHasOutV = Standard_True;
+        continue;
       }
-
+      
       IntTools_ListOfBox aListOfBox;
       TColStd_ListOfInteger aListOfIndex;
-
+      
       Standard_Boolean bHasOutC = Standard_False;
       Standard_Integer aCurIndex = aCurIndexInit;
-
+      
       // ////////////////////////////
       aCurPar = aRangeC.First();
       aPrevPar = aRangeC.First();
       IntTools_CurveRangeSample aCurRangeC = aNewRangeCTemplate;
-
+      
       for (tIt = 1; tIt <= nbC; tIt++, aCurIndex++, aPrevPar = aCurPar) {
+        
+        aCurPar += localdiffC;
+        
+        // ignore already computed. begin
+        Standard_Boolean bFound = Standard_False;
+        TColStd_ListIteratorOfListOfInteger anItToAvoid(aListCToAvoid);
 
-       aCurPar += localdiffC;
-
-       // ignore already computed. begin
-       Standard_Boolean bFound = Standard_False;
-       TColStd_ListIteratorOfListOfInteger anItToAvoid(aListCToAvoid);
-
-       for(; anItToAvoid.More(); anItToAvoid.Next()) {
-         if(tIt == anItToAvoid.Value()) {
-           bFound = Standard_True;
-           break;
-         }
-       }
-
-       if(!bFound) {
-         if(bAllowSamplingC) {
-           aCurRangeC.SetRangeIndex(aCurIndex);
-         }
-         bFound = theCurveData.IsRangeOut(aCurRangeC);
-       }
-
-       if(bFound) {
-         bHasOutC = Standard_True;
-         continue;
-       }
-       // ignore already computed. end
-
-       // compute Box
-       Bnd_Box aBoxC;
-
-       if(!theCurveData.FindBox(aCurRangeC, aBoxC)) {
-         BndLib_Add3dCurve::Add(myCurve, aPrevPar, aCurPar, myCriteria, aBoxC);
-
-//       Bnd_Box aMainBoxS;
-
-         if(!bMainBoxFoundS && theSurfaceData.FindBox(aRootRangeS, aMainBoxS)) {
-           bMainBoxFoundS = Standard_True;
-         }
-           if(aBoxC.IsOut(aMainBoxS)) {
-             theCurveData.AddOutRange(aCurRangeC);
-             bHasOutC = Standard_True;
-             continue;
-           }
-//       }
-         theCurveData.AddBox(aCurRangeC, aBoxC);
-       }
-
-       if(!bGlobalCheckDone && aBoxC.IsOut(theBoxSurface)) {
-         aListCToAvoid.Append(tIt);
-         bHasOutC = Standard_True;
-         continue;
-       }
-
-       if(aBoxC.IsOut(aBoxS)) {
-         bHasOutV = Standard_True;
-         bHasOutC = Standard_True;
-         continue;
-       }
-       //
-
-       aListOfIndex.Append(tIt);
-       aListOfBox.Append(aBoxC);
+        for(; anItToAvoid.More(); anItToAvoid.Next()) {
+          if(tIt == anItToAvoid.Value()) {
+            bFound = Standard_True;
+            break;
+          }
+        }
+        
+        if(!bFound) {
+          if(bAllowSamplingC) {
+            aCurRangeC.SetRangeIndex(aCurIndex);
+          }
+          bFound = theCurveData.IsRangeOut(aCurRangeC);
+        }
+        
+        if(bFound) {
+          bHasOutC = Standard_True;
+          continue;
+        }
+        // ignore already computed. end
+        
+        // compute Box
+        Bnd_Box aBoxC;
+        
+        if(!theCurveData.FindBox(aCurRangeC, aBoxC)) {
+          BndLib_Add3dCurve::Add(myCurve, aPrevPar, aCurPar, myCriteria, aBoxC);
+            
+            //   Bnd_Box aMainBoxS;
+            
+            if(!bMainBoxFoundS && theSurfaceData.FindBox(aRootRangeS, aMainBoxS)) {
+              bMainBoxFoundS = Standard_True;
+            }
+            if(aBoxC.IsOut(aMainBoxS)) {
+              theCurveData.AddOutRange(aCurRangeC);
+              bHasOutC = Standard_True;
+              continue;
+            }
+            //   }
+            theCurveData.AddBox(aCurRangeC, aBoxC);
+          }
+        
+        if(!bGlobalCheckDone && aBoxC.IsOut(theBoxSurface)) {
+          aListCToAvoid.Append(tIt);
+          bHasOutC = Standard_True;
+          continue;
+        }
+        
+        if(aBoxC.IsOut(aBoxS)) {
+          bHasOutV = Standard_True;
+          bHasOutC = Standard_True;
+          continue;
+        }
+        //
+        
+        aListOfIndex.Append(tIt);
+        aListOfBox.Append(aBoxC);
       } // end for(tIt...)
-
+      
       bGlobalCheckDone = Standard_True;
-
+      
       if(bHasOutC) {
-       bHasOutV = Standard_True;
+        bHasOutV = Standard_True;
       }
-
+      
       // //////////////
       //
-
+      
       IntTools_CurveRangeSample aNewRangeC = aNewRangeCTemplate;
-
+      
       aCurIndex = aCurIndexInit;
       TColStd_ListIteratorOfListOfInteger anItI(aListOfIndex);
       IntTools_ListIteratorOfListOfBox anItBox(aListOfBox);
       Standard_Boolean bUseOldC = Standard_False;
       Standard_Boolean bUseOldS = Standard_False;
       Standard_Boolean bCheckSize = !bHasOutC;
-
+      
       for(; anItI.More() && anItBox.More(); anItI.Next(), anItBox.Next()) {
-       aCurIndex = aCurIndexInit + anItI.Value() - 1;
-
-       bUseOldS = Standard_False;
-
-       if(bAllowSamplingC) {
-         aNewRangeC.SetRangeIndex(aCurIndex);
-       }
-
-
-       if(bCheckSize) {
-
-         if((theCurveRange.GetDepth() == 0) ||
-            (theSurfaceRange.GetDepthU() == 0) ||
-            (theSurfaceRange.GetDepthV() == 0)) {
-           bHasOutC = Standard_True;
-           bHasOutV = Standard_True;
-         }
-         else if((theCurveRange.GetDepth() < 4) &&
-                 (theSurfaceRange.GetDepthU() < 4) &&
-                 (theSurfaceRange.GetDepthV() < 4)) {
-           Bnd_Box aBoxC = anItBox.Value();
-
-           if(!aBoxC.IsWhole() && !aBoxS.IsWhole()) {
-             Standard_Real aDiagC = aBoxC.SquareExtent();
-             Standard_Real aDiagS = aBoxS.SquareExtent();
-
-             if(aDiagC < aDiagS) {
-               if((aDiagC * 10.) < aDiagS) {
-                 bUseOldC = Standard_True;
-                 bHasOutC = Standard_True;
-                 bHasOutV = Standard_True;
-                 break;
-               }
-             }
-             else {
-               if((aDiagS * 10.) < aDiagC) {
-                 bUseOldS = Standard_True;
-                 bHasOutC = Standard_True;
-                 bHasOutV = Standard_True;
-               }
-             }
-           }
-         }
-       }
-
-
-       if(!bHasOutC) {
-         aListCurveRangeFound.Append(aNewRangeC);
-         aListSurfaceRangeFound.Append(aNewRangeS);
-       }
-       else {
-
-//       if(bUseOldS || bAllowSamplingU || bAllowSamplingV) {
-//         theSurfaceData.AddBox(aNewRangeS, aBoxS);
-//       }
-
-         if(bUseOldS && aNewRangeC.IsEqual(theCurveRange)) {
-           return Standard_False;
-         }
-  
-         if(!LocalizeSolutions(aNewRangeC, anItBox.Value(), 
-                               ((bUseOldS) ? theSurfaceRange : aNewRangeS), 
-                               ((bUseOldS) ? theBoxSurface : aBoxS),
-                               theCurveData, theSurfaceData,
-                               theListCurveRange, theListSurfaceRange))
-           return Standard_False;
-       }
+        aCurIndex = aCurIndexInit + anItI.Value() - 1;
+
+        bUseOldS = Standard_False;
+        
+        if(bAllowSamplingC) {
+          aNewRangeC.SetRangeIndex(aCurIndex);
+        }
+        
+        
+        if(bCheckSize) {
+          
+          if((theCurveRange.GetDepth() == 0) ||
+             (theSurfaceRange.GetDepthU() == 0) ||
+             (theSurfaceRange.GetDepthV() == 0)) {
+            bHasOutC = Standard_True;
+            bHasOutV = Standard_True;
+          }
+          else if((theCurveRange.GetDepth() < 4) &&
+                  (theSurfaceRange.GetDepthU() < 4) &&
+                  (theSurfaceRange.GetDepthV() < 4)) {
+            Bnd_Box aBoxC = anItBox.Value();
+            
+            if(!aBoxC.IsWhole() && !aBoxS.IsWhole()) {
+              Standard_Real aDiagC = aBoxC.SquareExtent();
+              Standard_Real aDiagS = aBoxS.SquareExtent();
+              
+              if(aDiagC < aDiagS) {
+                if((aDiagC * 10.) < aDiagS) {
+                  bUseOldC = Standard_True;
+                  bHasOutC = Standard_True;
+                  bHasOutV = Standard_True;
+                  break;
+                }
+              }
+              else {
+                if((aDiagS * 10.) < aDiagC) {
+                  bUseOldS = Standard_True;
+                  bHasOutC = Standard_True;
+                  bHasOutV = Standard_True;
+                }
+              }
+            }
+          }
+        }
+        
+        
+        if(!bHasOutC) {
+          aListCurveRangeFound.Append(aNewRangeC);
+          aListSurfaceRangeFound.Append(aNewRangeS);
+        }
+        else {
+          
+          //   if(bUseOldS || bAllowSamplingU || bAllowSamplingV) {
+          //     theSurfaceData.AddBox(aNewRangeS, aBoxS);
+          //   }
+          
+          if(bUseOldS && aNewRangeC.IsEqual(theCurveRange)) {
+            return Standard_False;
+          }
+          
+          if(!LocalizeSolutions(aNewRangeC, anItBox.Value(), 
+                                ((bUseOldS) ? theSurfaceRange : aNewRangeS), 
+                                ((bUseOldS) ? theBoxSurface : aBoxS),
+                                theCurveData, theSurfaceData,
+                                theListCurveRange, theListSurfaceRange))
+            return Standard_False;
+        }
       }
       // end (tIt...)
       aListOfIndex.Clear();
       aListOfBox.Clear();
-
+      
       if(bHasOutV) {
-//     theSurfaceData.AddBox(aNewRangeS, aBoxS);
-
-       if(bUseOldC && bAllowSamplingC && (bAllowSamplingU || bAllowSamplingV)) {
-         if(!LocalizeSolutions(theCurveRange, theBoxCurve,
-                               aNewRangeS, aBoxS, 
-                               theCurveData, theSurfaceData,
-                               theListCurveRange, theListSurfaceRange))
-           return Standard_False;
-       }
+        //     theSurfaceData.AddBox(aNewRangeS, aBoxS);
+        
+        if(bUseOldC && bAllowSamplingC && (bAllowSamplingU || bAllowSamplingV)) {
+          if(!LocalizeSolutions(theCurveRange, theBoxCurve,
+                                aNewRangeS, aBoxS, 
+                                theCurveData, theSurfaceData,
+                                theListCurveRange, theListSurfaceRange))
+            return Standard_False;
+        }
       }
     } // end for (vIt...)
-
+    
     if(bHasOutV) {
       bHasOut = Standard_True;
     }
@@ -1882,7 +1880,7 @@ Standard_Boolean IntTools_BeanFaceIntersector::LocalizeSolutions(const IntTools_
 // ======================================================================================================================
 Standard_Boolean IntTools_BeanFaceIntersector::ComputeLocalized() {
   Standard_Real Tol = Precision::PConfusion();
-
+  
   IntTools_SurfaceRangeSample aSurfaceRange(0, 0, 0, 0);
   Standard_Real dMinU = 10. * Precision::PConfusion();
   Standard_Real dMinV = dMinU;
@@ -1890,34 +1888,34 @@ Standard_Boolean IntTools_BeanFaceIntersector::ComputeLocalized() {
   IntTools_SurfaceRangeLocalizeData& aSurfaceData = myContext->SurfaceData(mySurface.Face());
   aSurfaceData.RemoveRangeOutAll();
   aSurfaceData.ClearGrid();
-
+  
   Bnd_Box FBox;
   Standard_Boolean bFBoxFound = aSurfaceData.FindBox(aSurfaceRange, FBox);
-
+  
   if(mySurface.GetType() == GeomAbs_BSplineSurface) {
     Handle(Geom_BSplineSurface) aSurfBspl = Handle(Geom_BSplineSurface)::DownCast(myTrsfSurface);
-
+    
     ComputeGridPoints(aSurfBspl, myUMinParameter, myUMaxParameter,
-                     myVMinParameter, myVMaxParameter, myFaceTolerance,
-                     aSurfaceData);
-
+                      myVMinParameter, myVMaxParameter, myFaceTolerance,
+                      aSurfaceData);
+    
     if(!bFBoxFound) {
       FBox = GetSurfaceBox(aSurfBspl, myUMinParameter, myUMaxParameter,
-                          myVMinParameter, myVMaxParameter, myCriteria,
-                          aSurfaceData);
+                           myVMinParameter, myVMaxParameter, myCriteria,
+                           aSurfaceData);
       aSurfaceData.AddBox(aSurfaceRange, FBox);
     }
-
+    
   } else if(!bFBoxFound) {
     
     BndLib_AddSurface::Add(mySurface, myUMinParameter, myUMaxParameter, myVMinParameter, myVMaxParameter, myFaceTolerance, FBox);
-    aSurfaceData.AddBox(aSurfaceRange, FBox);
-  }
-
+      aSurfaceData.AddBox(aSurfaceRange, FBox);
+    }
+  
   Bnd_Box EBox;
-
+  
   BndLib_Add3dCurve::Add(myCurve.Trim(myFirstParameter, myLastParameter, Precision::PConfusion())->Curve(), myBeanTolerance, EBox);
-
+  
   if(EBox.IsOut(FBox)) {
     for(Standard_Integer i = 1; i <= myRangeManager.Length(); i++) {
       myRangeManager.SetFlag(i, 1);
@@ -1937,7 +1935,7 @@ Standard_Boolean IntTools_BeanFaceIntersector::ComputeLocalized() {
   Standard_Integer nbSampleV = aSurfaceData.GetNbSampleV();
   Standard_Real dMinC = 10. * myCurveResolution;
   IntTools_ListOfCurveRangeSample aListOut;
-
+  
   // check
   Standard_Boolean bAllowSamplingC = Standard_True;
   Standard_Boolean bAllowSamplingU = Standard_True;
@@ -1946,167 +1944,167 @@ Standard_Boolean IntTools_BeanFaceIntersector::ComputeLocalized() {
   IntTools_SurfaceRangeLocalizeData aSurfaceDataTmp(nbSampleU, nbSampleV, dMinU, dMinV);
   
   CheckSampling(aCurveRange, aSurfaceRange, aCurveDataTmp, aSurfaceDataTmp,
-               myLastParameter - myFirstParameter,
-               myUMaxParameter - myUMinParameter,
-               myVMaxParameter - myVMinParameter,
-               bAllowSamplingC, bAllowSamplingU, bAllowSamplingV);
-
-
+                myLastParameter - myFirstParameter,
+                myUMaxParameter - myUMinParameter,
+                myVMaxParameter - myVMinParameter,
+                bAllowSamplingC, bAllowSamplingU, bAllowSamplingV);
+  
+  
   {
     IntTools_CurveRangeLocalizeData aCurveData(nbSampleC, dMinC);
-
+    
     aCurveData.AddBox(aCurveRange, EBox);
     
     if(!LocalizeSolutions(aCurveRange, EBox, aSurfaceRange, FBox, 
-                         aCurveData, aSurfaceData,
-                         aListCurveRange, aListSurfaceRange)) {
+                          aCurveData, aSurfaceData,
+                          aListCurveRange, aListSurfaceRange)) {
       aSurfaceData.ClearGrid();
-
+      
       return Standard_False;
     }
-
+    
     IntTools_ListOfCurveRangeSample aListCurveRangeSort;
     IntTools_ListOfSurfaceRangeSample aListSurfaceRangeSort;
-
+    
     MergeSolutions(aListCurveRange, aListSurfaceRange, aListCurveRangeSort, aListSurfaceRangeSort);
-
+    
     IntTools_ListIteratorOfListOfCurveRangeSample anItC(aListCurveRangeSort);
     IntTools_ListIteratorOfListOfSurfaceRangeSample anItS(aListSurfaceRangeSort);
     IntTools_SurfaceRangeSample aRangeSPrev;
-
+    
     Extrema_GenExtCS anExtremaGen;
-
+    
     for(; anItC.More() && anItS.More(); anItC.Next(), anItS.Next()) {
-
+      
       IntTools_Range aRangeC(myFirstParameter, myLastParameter);
 
       if(bAllowSamplingC) 
-       aRangeC = anItC.Value().GetRange(myFirstParameter, myLastParameter, nbSampleC);
-
+        aRangeC = anItC.Value().GetRange(myFirstParameter, myLastParameter, nbSampleC);
+      
       IntTools_Range aRangeU(myUMinParameter, myUMaxParameter);
 
       if(bAllowSamplingU) 
-       aRangeU = anItS.Value().GetRangeU(myUMinParameter, myUMaxParameter, nbSampleU);
-
+        aRangeU = anItS.Value().GetRangeU(myUMinParameter, myUMaxParameter, nbSampleU);
+      
       IntTools_Range aRangeV(myVMinParameter, myVMaxParameter);
-
+      
       if(bAllowSamplingV) 
-       aRangeV = anItS.Value().GetRangeV(myVMinParameter, myVMaxParameter, nbSampleV);
-
+        aRangeV = anItS.Value().GetRangeV(myVMinParameter, myVMaxParameter, nbSampleV);
+      
       Standard_Real anarg1 = aRangeC.First(), anarg2 = aRangeC.Last();
-
+      
       Standard_Boolean bFound = Standard_False;
-
+      
       Standard_Integer nMinIndex = myRangeManager.Length();
       Standard_Integer nMaxIndex = -1;
       const TColStd_SequenceOfInteger& anInds1 = myRangeManager.GetIndices(anarg1);
       Standard_Integer indIt = 1;
 
       for(indIt = 1 ; indIt <= anInds1.Length(); indIt++) {
-       Standard_Integer nIndex = anInds1.Value(indIt);
-       nMinIndex = (nMinIndex > nIndex) ? nIndex : nMinIndex;
-       nMaxIndex = (nMaxIndex < nIndex) ? nIndex : nMaxIndex;
+        Standard_Integer nIndex = anInds1.Value(indIt);
+        nMinIndex = (nMinIndex > nIndex) ? nIndex : nMinIndex;
+        nMaxIndex = (nMaxIndex < nIndex) ? nIndex : nMaxIndex;
       }
-
+      
       for(indIt = nMinIndex ; indIt <= nMaxIndex; indIt++) {
-       if(myRangeManager.Flag(indIt) == 2) {
-         bFound = Standard_True;
-         break;
-       }
+        if(myRangeManager.Flag(indIt) == 2) {
+          bFound = Standard_True;
+  break;
+        }
       }
-
+      
       if(bFound)
-       continue;
+        continue;
       nMinIndex = (nMaxIndex >= 0) ? nMaxIndex : nMinIndex;
       const TColStd_SequenceOfInteger& anInds2 = myRangeManager.GetIndices(anarg2);
-    
+      
       for(indIt = 1 ; indIt <= anInds2.Length(); indIt++) {
-       Standard_Integer nIndex = anInds2.Value(indIt);
-       nMinIndex = (nMinIndex > nIndex) ? nIndex : nMinIndex;
-       nMaxIndex = (nMaxIndex < nIndex) ? nIndex : nMaxIndex;
+        Standard_Integer nIndex = anInds2.Value(indIt);
+        nMinIndex = (nMinIndex > nIndex) ? nIndex : nMinIndex;
+        nMaxIndex = (nMaxIndex < nIndex) ? nIndex : nMaxIndex;
       }
 
       for(indIt = nMinIndex ; indIt <= nMaxIndex; indIt++) {
-       if(myRangeManager.Flag(indIt) == 2) {
-         bFound = Standard_True;
-         break;
-       }
+        if(myRangeManager.Flag(indIt) == 2) {
+          bFound = Standard_True;
+          break;
+        }
       }
-
+      
       if(bFound)
-       continue;
-         
+        continue;
+      
       Standard_Real parUF = aRangeU.First(), parUL = aRangeU.Last();
       Standard_Real parVF = aRangeV.First(), parVL = aRangeV.Last();
-
+      
       if(aRangeSPrev.IsEqual(anItS.Value())) {
-       anExtremaGen.Perform(myCurve, 10, anarg1, anarg2, Tol);
+        anExtremaGen.Perform(myCurve, 10, anarg1, anarg2, Tol);
       }
       else {
-       anExtremaGen.Initialize(mySurface, 10, 10, parUF, parUL, parVF, parVL, Tol);
-       anExtremaGen.Perform(myCurve, 10, anarg1, anarg2, Tol);
+        anExtremaGen.Initialize(mySurface, 10, 10, parUF, parUL, parVF, parVL, Tol);
+        anExtremaGen.Perform(myCurve, 10, anarg1, anarg2, Tol);
       }
-
+      
       if(anExtremaGen.IsDone() && (anExtremaGen.NbExt() > 0)) {
+        
+        for(Standard_Integer j = 1 ; j <= anExtremaGen.NbExt(); j++) {
 
-       for(Standard_Integer j = 1 ; j <= anExtremaGen.NbExt(); j++) {
-
-         if(anExtremaGen.SquareDistance(j) < myCriteria * myCriteria) {
-
-           Extrema_POnCurv p1;
-           Extrema_POnSurf p2;
-           p1 = anExtremaGen.PointOnCurve(j);
-           p2 = anExtremaGen.PointOnSurface(j);
-           Standard_Real U, V, T;
-           T = p1.Parameter();
-           p2.Parameter(U, V);
-         
-           if (myCurve.IsPeriodic())
-             T = ElCLib::InPeriod(T, anarg1, anarg1 + myCurve.Period());
-           if (mySurface.IsUPeriodic())
-             U = ElCLib::InPeriod(U, parUF, parUF + mySurface.UPeriod());
-           if (mySurface.IsVPeriodic())
-             V = ElCLib::InPeriod(V, parVF, parVF + mySurface.VPeriod());
-
-           //To avoid occasional going out of boundaries because of numerical
-           //problem
-           if(U < myUMinParameter) U = myUMinParameter;
-           if(U > myUMaxParameter) U = myUMaxParameter;
-           if(V < myVMinParameter) V = myVMinParameter;
-           if(V > myVMaxParameter) V = myVMaxParameter;
-
-           Standard_Integer aNbRanges = myRangeManager.Length();
-           ComputeRangeFromStartPoint(Standard_False, T, U, V);
-           ComputeRangeFromStartPoint(Standard_True, T, U, V);
-
-           if(aNbRanges == myRangeManager.Length()) {
-             SetEmptyResultRange(T, myRangeManager);
-           }
-         }
-       } //end for
+          if(anExtremaGen.SquareDistance(j) < myCriteria * myCriteria) {
+            
+            Extrema_POnCurv p1;
+            Extrema_POnSurf p2;
+            p1 = anExtremaGen.PointOnCurve(j);
+            p2 = anExtremaGen.PointOnSurface(j);
+            Standard_Real U, V, T;
+            T = p1.Parameter();
+            p2.Parameter(U, V);
+            
+            if (myCurve.IsPeriodic())
+              T = ElCLib::InPeriod(T, anarg1, anarg1 + myCurve.Period());
+            if (mySurface.IsUPeriodic())
+              U = ElCLib::InPeriod(U, parUF, parUF + mySurface.UPeriod());
+            if (mySurface.IsVPeriodic())
+              V = ElCLib::InPeriod(V, parVF, parVF + mySurface.VPeriod());
+            
+            //To avoid occasional going out of boundaries because of numerical
+            //problem
+            if(U < myUMinParameter) U = myUMinParameter;
+            if(U > myUMaxParameter) U = myUMaxParameter;
+            if(V < myVMinParameter) V = myVMinParameter;
+            if(V > myVMaxParameter) V = myVMaxParameter;
+            
+            Standard_Integer aNbRanges = myRangeManager.Length();
+            ComputeRangeFromStartPoint(Standard_False, T, U, V);
+            ComputeRangeFromStartPoint(Standard_True, T, U, V);
+            
+            if(aNbRanges == myRangeManager.Length()) {
+              SetEmptyResultRange(T, myRangeManager);
+            }
+          }
+        } //end for
       }
       else {
-       myRangeManager.InsertRange(anarg1, anarg2, 0);
+        myRangeManager.InsertRange(anarg1, anarg2, 0);
       }
-    
+      
       aRangeSPrev = anItS.Value();
     }
-
+    
     //
     aCurveData.ListRangeOut(aListOut);
   }
-
+  
   //
   if(bAllowSamplingC) {
     IntTools_ListIteratorOfListOfCurveRangeSample anItC(aListOut);
-
+    
     for(; anItC.More(); anItC.Next()) {
       IntTools_Range aRangeC =anItC.Value().GetRange(myFirstParameter, myLastParameter, nbSampleC);
       myRangeManager.InsertRange(aRangeC.First(), aRangeC.Last(), 1);
     }
   }
   ComputeNearRangeBoundaries();
-
+  
   aSurfaceData.ClearGrid();
 
   return Standard_True;
@@ -2171,17 +2169,17 @@ Standard_Boolean IntTools_BeanFaceIntersector::TestComputeCoinside()
 // purpose:  
 // ---------------------------------------------------------------------------------
 Bnd_Box GetSurfaceBox(const Handle(Geom_BSplineSurface)        &theSurf,
-                     const Standard_Real                       theFirstU,
-                     const Standard_Real                       theLastU,
-                     const Standard_Real                       theFirstV,
-                     const Standard_Real                       theLastV,
-                     const Standard_Real                       theTolerance,
-                           IntTools_SurfaceRangeLocalizeData  &theSurfaceData)
+                      const Standard_Real                       theFirstU,
+                      const Standard_Real                       theLastU,
+                      const Standard_Real                       theFirstV,
+                      const Standard_Real                       theLastV,
+                      const Standard_Real                       theTolerance,
+                      IntTools_SurfaceRangeLocalizeData  &theSurfaceData)
 {
   Bnd_Box              aTotalBox;
-
+  
   BuildBox(theSurf, theFirstU, theLastU, theFirstV, theLastV,
-          theSurfaceData, aTotalBox);
+           theSurfaceData, aTotalBox);
 
   aTotalBox.Enlarge(theTolerance);
   return aTotalBox;
@@ -2193,13 +2191,13 @@ Bnd_Box GetSurfaceBox(const Handle(Geom_BSplineSurface)        &theSurf,
 // purpose:  
 // ---------------------------------------------------------------------------------
 void ComputeGridPoints
-               (const Handle(Geom_BSplineSurface)       &theSurf,
-               const Standard_Real                      theFirstU,
-               const Standard_Real                      theLastU,
-               const Standard_Real                      theFirstV,
-               const Standard_Real                      theLastV,
-               const Standard_Real                      theTolerance,
-                     IntTools_SurfaceRangeLocalizeData &theSurfaceData)
+  (const Handle(Geom_BSplineSurface)       &theSurf,
+   const Standard_Real                      theFirstU,
+   const Standard_Real                      theLastU,
+   const Standard_Real                      theFirstV,
+   const Standard_Real                      theLastV,
+   const Standard_Real                      theTolerance,
+   IntTools_SurfaceRangeLocalizeData &theSurfaceData)
 {
   Standard_Integer     i;
   Standard_Integer     j;
@@ -2228,22 +2226,22 @@ void ComputeGridPoints
                                  aLPar[1] + theTolerance };
   Standard_Real    aLmTol[2] = { aLPar[0] - theTolerance,
                                  aLPar[1] - theTolerance };
-
+  
 
   // Compute number of U and V grid points.
   for (j = 0; j < 2; j++) {
     const TColStd_Array1OfReal &aKnots = (j == 0) ? aKnotsU : aKnotsV;
-
+    
     for (i = 1; i <= aNbKnots[j] && (iMin[j] == -1 || iMax[j] == -1); i++) {
       if (iMin[j] == -1 && aFpTol[j] < aKnots.Value(i))
-       iMin[j] = i - 1;
-
+        iMin[j] = i - 1;
+      
       iLmI = aNbKnots[j] - i + 1;
-
+      
       if (iMax[j] == -1 && aLmTol[j] > aKnots.Value(iLmI))
-       iMax[j] = iLmI + 1;
+        iMax[j] = iLmI + 1;
     }
-
+    
     // If indices are not found, return.
     //if (iMin[j] == -1 || iMax[j] == -1)
       //return;
@@ -2279,64 +2277,64 @@ void ComputeGridPoints
       theSurfaceData.SetRangeUGrid(aNbGridPnts[j]);
     else // j == 1
       theSurfaceData.SetRangeVGrid(aNbGridPnts[j]);
-
+    
     // Setting the first and last parameters.
     Standard_Integer iAbs    = 1;
     Standard_Real    aMinPar;
     Standard_Real    aMaxPar = (j == 0) ? theLastU : theLastV;
-
+    
     for (i = iMin[j]; i < iMax[j]; i++) {
       // Get the first parameter.
       if (i == iMin[j]) {
-       // The first knot.
-       if (aFmTol[j] > aKnots.Value(iMin[j]))
-         aMinPar = aFPar[j];
-       else
-         aMinPar = aKnots.Value(iMin[j]);
+        // The first knot.
+        if (aFmTol[j] > aKnots.Value(iMin[j]))
+          aMinPar = aFPar[j];
+        else
+          aMinPar = aKnots.Value(iMin[j]);
       } else {
-       aMinPar = aKnots.Value(i);
+        aMinPar = aKnots.Value(i);
       }
-
+      
       // Get the last parameter.
       if (i == iMax[j] - 1) {
-       // The last knot.
-       if (aLpTol[j] < aKnots.Value(iMax[j]))
-         aMaxPar = aLPar[j];
-       else
-         aMaxPar = aKnots.Value(iMax[j]);
+        // The last knot.
+        if (aLpTol[j] < aKnots.Value(iMax[j]))
+          aMaxPar = aLPar[j];
+        else
+          aMaxPar = aKnots.Value(iMax[j]);
       } else {
-       aMaxPar = aKnots.Value(i + 1);
+        aMaxPar = aKnots.Value(i + 1);
       }
-
+      
       // Compute grid parameters.
       Standard_Real aDelta = (aMaxPar - aMinPar)/aNbSamples[j];
-
+      
       for (k = 0; k < aNbSamples[j]; k++, aMinPar += aDelta) {
-       if (j == 0)
-         theSurfaceData.SetUParam(iAbs++, aMinPar);
-       else
-         theSurfaceData.SetVParam(iAbs++, aMinPar);
+        if (j == 0)
+          theSurfaceData.SetUParam(iAbs++, aMinPar);
+        else
+          theSurfaceData.SetVParam(iAbs++, aMinPar);
       }
     }
-
+    
     // Add the last parameter
     if (j == 0)
       theSurfaceData.SetUParam(iAbs++, aMaxPar);
     else
       theSurfaceData.SetVParam(iAbs++, aMaxPar);
   }
-
+  
   // Compute of grid points.
   gp_Pnt        aPnt;
   Standard_Real aParU;
   Standard_Real aParV;
-
+  
   for (i = 1; i <= aNbGridPnts[0]; i++) {
     aParU = theSurfaceData.GetUParam(i);
-
+    
     for (j = 1; j <= aNbGridPnts[1]; j++) {
       aParV = theSurfaceData.GetVParam(j);
-
+      
       theSurf->D0(aParU, aParV, aPnt);
       theSurfaceData.SetGridPoint(i, j, aPnt);
     }
@@ -2355,7 +2353,7 @@ void ComputeGridPoints
 //   // Compute DU deflection.
 //   for (i = 1; i < aNbGridPnts[0]; i++) {
 //     aParMid = 0.5*(theSurfaceData.GetUParam(i + 1) +
-//                theSurfaceData.GetUParam(i));
+//        theSurfaceData.GetUParam(i));
 
 //     for (j = 1; j <= aNbGridPnts[1]; j++) {
 //       const gp_Pnt &thePnt1 = theSurfaceData.GetGridPoint(i,     j);
@@ -2375,7 +2373,7 @@ void ComputeGridPoints
 //     aDefLin = aCoord.Modulus();
 
 //     if (aDefLin > aDef)
-//       aDef = aDefLin;
+//   aDef = aDefLin;
 //       }
 //     }
 //   }
@@ -2383,7 +2381,7 @@ void ComputeGridPoints
 //   // Compute DV deflection.
 //   for (j = 1; j < aNbGridPnts[1]; j++) {
 //     aParMid = 0.5*(theSurfaceData.GetVParam(j + 1) +
-//                theSurfaceData.GetVParam(j));
+//        theSurfaceData.GetVParam(j));
 
 //     for (i = 1; i <= aNbGridPnts[0]; i++) {
 //       const gp_Pnt &thePnt1 = theSurfaceData.GetGridPoint(i, j);
@@ -2403,7 +2401,7 @@ void ComputeGridPoints
 //     aDefLin = aCoord.Modulus();
 
 //     if (aDefLin > aDef)
-//       aDef = aDefLin;
+//   aDef = aDefLin;
 //       }
 //     }
 //   }
@@ -2420,12 +2418,12 @@ void ComputeGridPoints
 // purpose:  Compute bounding box.
 // ---------------------------------------------------------------------------------
 void BuildBox(const Handle(Geom_BSplineSurface)       &theSurf,
-             const Standard_Real                      theFirstU,
-             const Standard_Real                      theLastU,
-             const Standard_Real                      theFirstV,
-             const Standard_Real                      theLastV,
-                   IntTools_SurfaceRangeLocalizeData &theSurfaceData,
-                   Bnd_Box                           &theBox)
+      const Standard_Real                      theFirstU,
+      const Standard_Real                      theLastU,
+      const Standard_Real                      theFirstV,
+      const Standard_Real                      theLastV,
+            IntTools_SurfaceRangeLocalizeData &theSurfaceData,
+              Bnd_Box                           &theBox)
 {
   Standard_Integer i;
   Standard_Integer j;
@@ -2483,10 +2481,10 @@ void BuildBox(const Handle(Geom_BSplineSurface)       &theSurf,
 // purpose:  
 // ---------------------------------------------------------------------------------
 static void MergeSolutions(const IntTools_ListOfCurveRangeSample& theListCurveRange,
-                          const IntTools_ListOfSurfaceRangeSample& theListSurfaceRange,
-                          IntTools_ListOfCurveRangeSample& theListCurveRangeSort,
-                          IntTools_ListOfSurfaceRangeSample& theListSurfaceRangeSort) {
-
+                           const IntTools_ListOfSurfaceRangeSample& theListSurfaceRange,
+                           IntTools_ListOfCurveRangeSample& theListCurveRangeSort,
+                           IntTools_ListOfSurfaceRangeSample& theListSurfaceRangeSort) {
+  
   IntTools_ListIteratorOfListOfCurveRangeSample anItC2;
   IntTools_ListIteratorOfListOfSurfaceRangeSample anItS1(theListSurfaceRange), anItS2;
   IntTools_MapOfSurfaceSample aMapToAvoid;
@@ -2503,8 +2501,8 @@ static void MergeSolutions(const IntTools_ListOfCurveRangeSample& theListCurveRa
 
     for(; anItS2.More() && anItC2.More(); anItS2.Next(), anItC2.Next()) {
       if(aRangeS.IsEqual(anItS2.Value())) {
-       theListCurveRangeSort.Append(anItC2.Value());
-       theListSurfaceRangeSort.Append(anItS2.Value());
+        theListCurveRangeSort.Append(anItC2.Value());
+        theListSurfaceRangeSort.Append(anItS2.Value());
       }
     }
   }
@@ -2515,16 +2513,16 @@ static void MergeSolutions(const IntTools_ListOfCurveRangeSample& theListCurveRa
 // purpose:  
 // ---------------------------------------------------------------------------------
 static void CheckSampling(const IntTools_CurveRangeSample& theCurveRange,
-                         const IntTools_SurfaceRangeSample& theSurfaceRange,
-                         const IntTools_CurveRangeLocalizeData& theCurveData,
-                         const IntTools_SurfaceRangeLocalizeData& theSurfaceData,
-                         const Standard_Real DiffC,
-                         const Standard_Real DiffU,
-                         const Standard_Real DiffV,
-                         Standard_Boolean& bAllowSamplingC,
-                         Standard_Boolean& bAllowSamplingU,
-                         Standard_Boolean& bAllowSamplingV) {
-
+                          const IntTools_SurfaceRangeSample& theSurfaceRange,
+                          const IntTools_CurveRangeLocalizeData& theCurveData,
+                          const IntTools_SurfaceRangeLocalizeData& theSurfaceData,
+                          const Standard_Real DiffC,
+                          const Standard_Real DiffU,
+                          const Standard_Real DiffV,
+                          Standard_Boolean& bAllowSamplingC,
+                          Standard_Boolean& bAllowSamplingU,
+                          Standard_Boolean& bAllowSamplingV) {
+  
   const Standard_Real dLimit = 1000;
   bAllowSamplingC = Standard_True;
   bAllowSamplingU = Standard_True;
similarity index 89%
rename from src/BOPInt/BOPInt_Context.cdl
rename to src/IntTools/IntTools_Context.cdl
index a26e7bf..48d4ca0 100644 (file)
@@ -12,7 +12,8 @@
 -- Alternatively, this file may be used under the terms of Open CASCADE
 -- commercial license or contractual agreement.
 
-class Context from BOPInt  
+
+class Context from IntTools  
     inherits TShared from MMgt
 
 
@@ -48,11 +49,12 @@ uses
 
 is 
     Create   
-    returns Context from BOPInt;
-    ---C++: alias "Standard_EXPORT virtual  ~BOPInt_Context();"   
-      
+
+    returns Context from IntTools;
+    ---C++: alias "Standard_EXPORT virtual  ~IntTools_Context();"         
     Create (theAllocator: BaseAllocator from BOPCol) 
-    returns Context from BOPInt;
+
+    returns Context from IntTools;
      
     FClass2d(me:mutable; 
         aF: Face from TopoDS) 
@@ -150,32 +152,6 @@ is
     --- 2. the edge does not contain 3d curve and pcurves (-2)
     --- 3. projection algorithm failed (-3)
     ---
-    --ComputeVE  (me:mutable;  
-    --aV   : Vertex from  TopoDS; 
-    --aE   : Edge   from  TopoDS; 
-    --aT   :out Real from Standard; 
-    --bToUpdateVertex:out Boolean from Standard; 
-    --aDist          :out Real from Standard)  
-    --returns Integer from Standard;
-    ---Purpose:
-    --- Computes parameter aT of the vertex aV on
-    --- the edge aE.
-    --- Returns zero if the distance between vertex
-    --- and edge is less than sum of tolerances,
-    --- otherwise and for following conditions returns
-    --- negative value
-    --- 1. the edge is degenerated (-1)
-    --- 2. the edge does not contain 3d curve and pcurves (-2)
-    --- 3. projection algorithm failed (-3)
-    ---  
-    --- Output parameters 
-    --- bToUpdateVertex - the flag that indicates whether the  
-    --- vertex tolerance should be modified or not 
-    --- aDist - the value of the distance between the vertex  
-    --- and the edge  
-        
-        
          
     ComputeVF  (me:mutable;  
        aV  :     Vertex from  TopoDS; 
similarity index 82%
rename from src/BOPInt/BOPInt_Context.cxx
rename to src/IntTools/IntTools_Context.cxx
index 8470486..d83b49c 100644 (file)
@@ -12,7 +12,7 @@
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-#include <BOPInt_Context.ixx>
+#include <IntTools_Context.ixx>
 
 #include <Precision.hxx>
 
@@ -46,7 +46,7 @@
 //function : 
 //purpose  : 
 //=======================================================================
-  BOPInt_Context::BOPInt_Context()
+IntTools_Context::IntTools_Context()
 :
   myAllocator(new NCollection_IncAllocator()),
   myFClass2dMap(100, myAllocator),
@@ -63,7 +63,8 @@
 //function : 
 //purpose  : 
 //=======================================================================
-  BOPInt_Context::BOPInt_Context(const Handle(NCollection_BaseAllocator)& theAllocator)
+IntTools_Context::IntTools_Context
+  (const Handle(NCollection_BaseAllocator)& theAllocator)
 :
   myAllocator(theAllocator),
   myFClass2dMap(100, myAllocator),
@@ -80,7 +81,7 @@
 //function : ~
 //purpose  : 
 //=======================================================================
-  BOPInt_Context::~BOPInt_Context()
+IntTools_Context::~IntTools_Context()
 {
   Standard_Address anAdr;
   BOPCol_DataMapIteratorOfDataMapOfShapeAddress aIt;
 //function : FClass2d
 //purpose  : 
 //=======================================================================
-  IntTools_FClass2d& BOPInt_Context::FClass2d(const TopoDS_Face& aF)
+IntTools_FClass2d& IntTools_Context::FClass2d(const TopoDS_Face& aF)
 {
   Standard_Address anAdr;
   IntTools_FClass2d* pFClass2d;
 //function : ProjPS
 //purpose  : 
 //=======================================================================
-  GeomAPI_ProjectPointOnSurf& BOPInt_Context::ProjPS(const TopoDS_Face& aF)
+GeomAPI_ProjectPointOnSurf& IntTools_Context::ProjPS(const TopoDS_Face& aF)
 {
   Standard_Address anAdr;
   GeomAPI_ProjectPointOnSurf* pProjPS;
 //function : ProjPC
 //purpose  : 
 //=======================================================================
-  GeomAPI_ProjectPointOnCurve& BOPInt_Context::ProjPC(const TopoDS_Edge& aE)
+GeomAPI_ProjectPointOnCurve& IntTools_Context::ProjPC(const TopoDS_Edge& aE)
 {
   Standard_Address anAdr;
   GeomAPI_ProjectPointOnCurve* pProjPC;
 //function : ProjPT
 //purpose  : 
 //=======================================================================
-  GeomAPI_ProjectPointOnCurve& BOPInt_Context::ProjPT(const Handle(Geom_Curve)& aC3D)
+GeomAPI_ProjectPointOnCurve& IntTools_Context::ProjPT
+  (const Handle(Geom_Curve)& aC3D)
 
 {
   Standard_Address anAdr;
 //function : SolidClassifier
 //purpose  : 
 //=======================================================================
-  BRepClass3d_SolidClassifier& BOPInt_Context::SolidClassifier(const TopoDS_Solid& aSolid)
+BRepClass3d_SolidClassifier& IntTools_Context::SolidClassifier
+  (const TopoDS_Solid& aSolid)
 {
   Standard_Address anAdr;
   BRepClass3d_SolidClassifier* pSC;
 //function : Hatcher
 //purpose  : 
 //=======================================================================
-  Geom2dHatch_Hatcher& BOPInt_Context::Hatcher(const TopoDS_Face& aF)
+Geom2dHatch_Hatcher& IntTools_Context::Hatcher(const TopoDS_Face& aF)
 {
   Standard_Address anAdr;
   Geom2dHatch_Hatcher* pHatcher;
 //function : SurfaceData
 //purpose  : 
 //=======================================================================
-  IntTools_SurfaceRangeLocalizeData& BOPInt_Context::SurfaceData(const TopoDS_Face& aF) 
+IntTools_SurfaceRangeLocalizeData& IntTools_Context::SurfaceData
+  (const TopoDS_Face& aF) 
 {
   Standard_Address anAdr;
   IntTools_SurfaceRangeLocalizeData* pSData;
   //
   if (!myProjSDataMap.IsBound(aF)) {
-    pSData=new IntTools_SurfaceRangeLocalizeData(3, 
-                                                 3, 
-                                                 10. * Precision::PConfusion(), 
-                                                 10. * Precision::PConfusion());
+    pSData=new IntTools_SurfaceRangeLocalizeData
+      (3, 
+       3, 
+       10. * Precision::PConfusion(), 
+       10. * Precision::PConfusion());
     //
     anAdr=(Standard_Address)pSData;
     myProjSDataMap.Bind(aF, anAdr);
 //function : ComputePE
 //purpose  : 
 //=======================================================================
-  Standard_Integer BOPInt_Context::ComputePE(const gp_Pnt& aP1,
-                                             const Standard_Real aTolP1,
-                                             const TopoDS_Edge& aE2,
-                                             Standard_Real& aT)
+Standard_Integer IntTools_Context::ComputePE
+  (const gp_Pnt& aP1,
+   const Standard_Real aTolP1,
+   const TopoDS_Edge& aE2,
+   Standard_Real& aT)
 {
   if (!BRep_Tool::IsGeometric(aE2)) { 
     return -2;
 //function : ComputeVE
 //purpose  : 
 //=======================================================================
-  Standard_Integer BOPInt_Context::ComputeVE(const TopoDS_Vertex& aV1, 
-                                             const TopoDS_Edge&   aE2,
-                                             Standard_Real& aT)
+Standard_Integer IntTools_Context::ComputeVE
+  (const TopoDS_Vertex& aV1, 
+   const TopoDS_Edge&   aE2,
+   Standard_Real& aT)
 {
   if (BRep_Tool::Degenerated(aE2)) {
     return -1;
 //function : ComputeVS
 //purpose  : 
 //=======================================================================
-  Standard_Integer BOPInt_Context::ComputeVF(const TopoDS_Vertex& aV1, 
-                                             const TopoDS_Face&   aF2,
-                                             Standard_Real& U,
-                                             Standard_Real& V)
+Standard_Integer IntTools_Context::ComputeVF
+  (const TopoDS_Vertex& aV1, 
+   const TopoDS_Face&   aF2,
+   Standard_Real& U,
+   Standard_Real& V)
 {
   Standard_Real aTolV1, aTolF2, aTolSum, aDist;
   gp_Pnt aP;
 //function : StatePointFace
 //purpose  : 
 //=======================================================================
-  TopAbs_State BOPInt_Context::StatePointFace(const TopoDS_Face& aF,
-                                              const gp_Pnt2d& aP2d)
+TopAbs_State IntTools_Context::StatePointFace
+  (const TopoDS_Face& aF,
+   const gp_Pnt2d& aP2d)
 {
   TopAbs_State aState;
   IntTools_FClass2d& aClass2d=FClass2d(aF);
 //function : IsPointInFace
 //purpose  : 
 //=======================================================================
-  Standard_Boolean BOPInt_Context::IsPointInFace(const TopoDS_Face& aF,
-                                                 const gp_Pnt2d& aP2d)
+Standard_Boolean IntTools_Context::IsPointInFace
+  (const TopoDS_Face& aF,
+   const gp_Pnt2d& aP2d)
 {
   TopAbs_State aState=StatePointFace(aF, aP2d);
   if (aState==TopAbs_OUT || aState==TopAbs_ON) {
 //function : IsPointInOnFace
 //purpose  : 
 //=======================================================================
-  Standard_Boolean BOPInt_Context::IsPointInOnFace(const TopoDS_Face& aF,
+  Standard_Boolean IntTools_Context::IsPointInOnFace(const TopoDS_Face& aF,
                                                    const gp_Pnt2d& aP2d)
 { 
   TopAbs_State aState=StatePointFace(aF, aP2d);
 //function : IsValidPointForFace
 //purpose  : 
 //=======================================================================
-  Standard_Boolean BOPInt_Context::IsValidPointForFace(const gp_Pnt& aP,
-                                                       const TopoDS_Face& aF,
-                                                       const Standard_Real aTol) 
+Standard_Boolean IntTools_Context::IsValidPointForFace
+  (const gp_Pnt& aP,
+   const TopoDS_Face& aF,
+   const Standard_Real aTol) 
 {
   Standard_Boolean bFlag;
   Standard_Real Umin, U, V;
 //function : IsValidPointForFaces
 //purpose  : 
 //=======================================================================
-  Standard_Boolean BOPInt_Context::IsValidPointForFaces (const gp_Pnt& aP,
-                                                         const TopoDS_Face& aF1,
-                                                         const TopoDS_Face& aF2,
-                                                         const Standard_Real aTol) 
+Standard_Boolean IntTools_Context::IsValidPointForFaces 
+  (const gp_Pnt& aP,
+   const TopoDS_Face& aF1,
+   const TopoDS_Face& aF2,
+   const Standard_Real aTol) 
 {
   Standard_Boolean bFlag1, bFlag2;
 
 //function : IsValidBlockForFace
 //purpose  : 
 //=======================================================================
-  Standard_Boolean BOPInt_Context::IsValidBlockForFace (const Standard_Real aT1,
-                                                        const Standard_Real aT2,
-                                                        const IntTools_Curve& aC, 
-                                                        const TopoDS_Face& aF,
-                                                        const Standard_Real aTol) 
+Standard_Boolean IntTools_Context::IsValidBlockForFace 
+  (const Standard_Real aT1,
+   const Standard_Real aT2,
+   const IntTools_Curve& aC, 
+   const TopoDS_Face& aF,
+   const Standard_Real aTol) 
 {
   Standard_Boolean bFlag;
   Standard_Real aTInterm;
 //function : IsValidBlockForFaces
 //purpose  : 
 //=======================================================================
-  Standard_Boolean BOPInt_Context::IsValidBlockForFaces (const Standard_Real aT1,
-                                                         const Standard_Real aT2,
-                                                         const IntTools_Curve& aC, 
-                                                         const TopoDS_Face& aF1,
-                                                         const TopoDS_Face& aF2,
-                                                         const Standard_Real aTol) 
+Standard_Boolean IntTools_Context::IsValidBlockForFaces 
+  (const Standard_Real aT1,
+   const Standard_Real aT2,
+   const IntTools_Curve& aC, 
+   const TopoDS_Face& aF1,
+   const TopoDS_Face& aF2,
+   const Standard_Real aTol) 
 {
   Standard_Boolean bFlag1, bFlag2;
   //
 //function : IsVertexOnLine
 //purpose  : 
 //=======================================================================
-  Standard_Boolean BOPInt_Context::IsVertexOnLine (const TopoDS_Vertex& aV,
-                                                   const IntTools_Curve& aC, 
-                                                   const Standard_Real aTolC,
-                                                   Standard_Real& aT)
+Standard_Boolean IntTools_Context::IsVertexOnLine 
+  (const TopoDS_Vertex& aV,
+   const IntTools_Curve& aC, 
+   const Standard_Real aTolC,
+   Standard_Real& aT)
 {
   Standard_Boolean bRet;
   Standard_Real aTolV;
   //
   aTolV=BRep_Tool::Tolerance(aV);
-  bRet=BOPInt_Context::IsVertexOnLine(aV, aTolV, aC, aTolC , aT);
+  bRet=IntTools_Context::IsVertexOnLine(aV, aTolV, aC, aTolC , aT);
   //
   return bRet;
 }
 //function : IsVertexOnLine
 //purpose  : 
 //=======================================================================
-  Standard_Boolean BOPInt_Context::IsVertexOnLine (const TopoDS_Vertex& aV,
-                                                   const Standard_Real aTolV,
-                                                   const IntTools_Curve& aC, 
-                                                   const Standard_Real aTolC,
-                                                   Standard_Real& aT)
+Standard_Boolean IntTools_Context::IsVertexOnLine 
+  (const TopoDS_Vertex& aV,
+   const Standard_Real aTolV,
+   const IntTools_Curve& aC, 
+   const Standard_Real aTolC,
+   Standard_Real& aT)
 {
   Standard_Real aFirst, aLast, aDist, aTolSum;
   Standard_Integer aNbProj;
 //function : ProjectPointOnEdge
 //purpose  : 
 //=======================================================================
-  Standard_Boolean BOPInt_Context::ProjectPointOnEdge(const gp_Pnt& aP,
-                                                      const TopoDS_Edge& anEdge,
-                                                      Standard_Real& aT)
+Standard_Boolean IntTools_Context::ProjectPointOnEdge
+  (const gp_Pnt& aP,
+   const TopoDS_Edge& anEdge,
+   Standard_Real& aT)
 {
   Standard_Integer aNbPoints;
 
index 52757c2..73303e9 100644 (file)
@@ -31,7 +31,7 @@ uses
     FClass2d             from IntTools, 
     SequenceOfRoots      from IntTools,
     SequenceOfCommonPrts from IntTools, 
-    Context              from BOPInt,
+    Context              from IntTools,
     Range                from IntTools 
     
 --raises
@@ -118,12 +118,12 @@ is
     --- The algorithm processes edge inside these boundaries.
      
     SetContext (me: in out;  
-            theContext: Context from BOPInt);
+            theContext: Context from IntTools);
     ---Purpose:
     --- Sets the intersecton context 
    
     Context (me) 
-        returns  Context from BOPInt; 
+        returns  Context from IntTools; 
     ---C++:return const &  
     ---Purpose:
     --- Gets the intersecton context 
@@ -234,7 +234,7 @@ is
             t,f:CArray1OfReal from IntTools)   
         is  protected;  
 
-   RemoveIdenticalRoots(me:out) 
+    RemoveIdenticalRoots(me:out) 
         is protected;   
   
     CheckTouch (me: out;   
@@ -276,7 +276,7 @@ fields
     myErrorStatus     :  Integer from Standard;    
     
 ---  internal  members     
-    myContext         :  Context from BOPInt;
+    myContext         :  Context from IntTools;
     myProjectableRanges: SequenceOfRanges from IntTools;    
     myFClass2d         : FClass2d from IntTools; 
     myFuncArray       :  CArray1OfReal from IntTools; 
index 9ac4a71..aa5352f 100644 (file)
@@ -28,7 +28,7 @@
 #include <IntTools_CommonPrt.hxx>
 #include <IntTools_Root.hxx>
 #include <IntTools_BeanFaceIntersector.hxx>
-#include <BOPInt_Context.hxx>
+#include <IntTools_Context.hxx>
 
 #include <BRep_Tool.hxx>
 
@@ -100,7 +100,7 @@ static
 //function : SetContext
 //purpose  : 
 //=======================================================================
-void IntTools_EdgeFace::SetContext(const Handle(BOPInt_Context)& theContext) 
+void IntTools_EdgeFace::SetContext(const Handle(IntTools_Context)& theContext) 
 {
   myContext = theContext;
 }
@@ -109,7 +109,7 @@ void IntTools_EdgeFace::SetContext(const Handle(BOPInt_Context)& theContext)
 //function : Context
 //purpose  : 
 //=======================================================================
-const Handle(BOPInt_Context)& IntTools_EdgeFace::Context()const 
+const Handle(IntTools_Context)& IntTools_EdgeFace::Context()const 
 {
   return myContext;
 }
@@ -1221,7 +1221,7 @@ void IntTools_EdgeFace::Perform()
   }
   //
   if (myContext.IsNull()) {
-    myContext=new BOPInt_Context;
+    myContext=new IntTools_Context;
   }
   //
   myIsDone = Standard_False;
index 11bcd16..129b587 100644 (file)
@@ -15,8 +15,8 @@
 
 class FaceFace from IntTools
 
-       ---Purpose: This class provides the intersection of 
-       ---         face's underlying surfaces.
+     ---Purpose: This class provides the intersection of 
+     ---     face's underlying surfaces.
 
 uses 
 
@@ -28,7 +28,7 @@ uses
     SequenceOfCurves      from IntTools,
     LineConstructor       from IntTools,
     SequenceOfPntOn2Faces from IntTools, 
-    Context from BOPInt
+    Context from IntTools
     
     
 
@@ -36,117 +36,114 @@ raises NotDone from StdFail
 is
 
     Create 
-       returns FaceFace from IntTools; 
-       ---Purpose: 
-       --- Empty constructor.
-       ---
-
+     returns FaceFace from IntTools; 
+     ---Purpose: 
+     --- Empty constructor.
 
     SetParameters(me: in out;  
-                   ApproxCurves    : Boolean from Standard;
-                   ComputeCurveOnS1: Boolean from Standard;
-                   ComputeCurveOnS2: Boolean from Standard;
-                   ApproximationTolerance: Real from Standard);
-       ---Purpose:
-       --- Modifier
-       ---
+              ApproxCurves    : Boolean from Standard;
+              ComputeCurveOnS1: Boolean from Standard;
+              ComputeCurveOnS2: Boolean from Standard;
+              ApproximationTolerance: Real from Standard);
+    ---Purpose:
+    --- Modifier
+    ---
 
     Perform(me: in out;  
-                   F1: Face from TopoDS;
-                   F2: Face from TopoDS);
-       ---Purpose: 
-       --- Intersects underliing surfaces of F1 and F2
-       --- Use sum of tolerance of F1 and F2 as intersection
-       --- criteria
-       ---
-       
+              F1: Face from TopoDS;
+              F2: Face from TopoDS);
+    ---Purpose: 
+    --- Intersects underliing surfaces of F1 and F2
+    --- Use sum of tolerance of F1 and F2 as intersection
+    --- criteria
     IsDone(me)
-       returns Boolean from Standard;
-       ---Purpose: 
-       --- Returns True if the intersection was successful
-       ---
+     returns Boolean from Standard;
+    ---Purpose: 
+    --- Returns True if the intersection was successful
+    ---
 
     Lines(me)
-       returns SequenceOfCurves from IntTools;
-       ---C++: return const&   
-       ---Purpose: 
-       --- Returns sequence of 3d curves as result of intersection
-       ---
-        
+     returns SequenceOfCurves from IntTools;
+    ---C++: return const& 
+    ---Purpose: 
+    --- Returns sequence of 3d curves as result of intersection
+    ---
+  
     Points(me)
-       returns  SequenceOfPntOn2Faces from IntTools;
-       ---C++: return const&    
-       ---Purpose: 
-       --- Returns sequence of 3d curves as result of intersection
-       ---
+     returns  SequenceOfPntOn2Faces from IntTools;
+    ---C++: return const&  
+    ---Purpose: 
+    --- Returns sequence of 3d curves as result of intersection
+    ---
 
     TolReached3d(me)  
-       returns Real from Standard;
-       ---Purpose:
-       --- Returns tolerance reached during approximation.
-       --- If approximation was not done, returns zero.
-       ---
+     returns Real from Standard;
+    ---Purpose:
+    --- Returns tolerance reached during approximation.
+    --- If approximation was not done, returns zero.
 
     TolReached2d(me)  
-       returns Real from Standard;
-       ---Purpose:
-       --- Returns tolerance reached during approximation.
-       --- If approximation was not done, returns zero.
-       ---
-            
+     returns Real from Standard;
+     ---Purpose:
+     --- Returns tolerance reached during approximation.
+    --- If approximation was not done, returns zero.
+    ---
+      
     Face1  (me) 
-       returns  Face  from  TopoDS; 
-       ---C++: return const& 
-       ---Purpose:
-       --- Returns first of processed faces
-       ---
-        
+     returns  Face  from  TopoDS; 
+    ---C++: return const& 
+    ---Purpose:
+    --- Returns first of processed faces
+    ---
+  
     Face2  (me) 
-       returns  Face  from  TopoDS; 
-       ---C++: return const& 
-       ---Purpose:
-       --- Returns second of processed faces
-       ---
+     returns  Face  from  TopoDS; 
+    ---C++: return const& 
+    ---Purpose:
+    --- Returns second of processed faces
+    ---
      
     TangentFaces  (me)
-       returns Boolean from Standard; 
-       ---Purpose:
-       --- Returns True if faces are tangent
-       --- 
+     returns Boolean from Standard; 
+    ---Purpose:
+    --- Returns True if faces are tangent
+    --- 
     PrepareLines3D (me:out; 
-           bToSplit: Boolean from Standard=Standard_True);
-       ---Purpose: 
-       --- Provides post-processing the result lines. 
-        --- <bToSplit> - the flag.                  
-       --  In case of <bToSplit> is true the closed 3D-curves will be splitted  
-        --  on parts. 
-        --  In case of <bToSplit> is false the closed 3D-curves remain untouched.  
+         bToSplit: Boolean from Standard=Standard_True);
+    ---Purpose: 
+    --- Provides post-processing the result lines. 
+    --- <bToSplit> - the flag.           
+    --  In case of <bToSplit> is true the closed 3D-curves will be splitted  
+    --  on parts. 
+    --  In case of <bToSplit> is false the closed 3D-curves remain untouched.  
     
     SetList (me: in out;  
-           ListOfPnts: in out ListOfPntOn2S from IntSurf);
+         ListOfPnts: in out ListOfPntOn2S from IntSurf);
     
     ----------------------------------------------------------
     --                  private  block
     ----------------------------------------------------------
     MakeCurve(me: in out; Index   : Integer from Standard;
-                         D1      : TopolTool from Adaptor3d;
-                         D2      : TopolTool from Adaptor3d)
-       is protected; 
-       
+                       D1      : TopolTool from Adaptor3d;
+                       D2      : TopolTool from Adaptor3d)
+        is protected; 
     ComputeTolReached3d(me:out) 
-       is  protected; 
+     is  protected; 
  
     SetContext(me:out; 
-         aContext : Context from BOPInt); 
-       ---Purpose:
-       --- Sets the intersecton context 
-       
+       aContext : Context from IntTools); 
+    ---Purpose:
+    --- Sets the intersecton context 
     Context(me) 
-       returns Context from BOPInt; 
-    ---C++:  return const &    
-       ---Purpose:
-       --- Gets the intersecton context        
-       ---       
+     returns Context from IntTools; 
+    ---C++:  return const &  
+    ---Purpose:
+    --- Gets the intersecton context 
+      
 fields 
  
     myIsDone       : Boolean         from Standard;
@@ -173,7 +170,7 @@ fields
     
     myListOfPnts  : ListOfPntOn2S from IntSurf;   
     
-    myContext     : Context from  BOPInt;       
+    myContext     : Context from  IntTools;  
 
 end FaceFace from IntTools;
 
index eb8ba6f..bcba29a 100644 (file)
 #include <IntTools_TopolTool.hxx>
 #include <IntTools_PntOnFace.hxx>
 #include <IntTools_PntOn2Faces.hxx>
-#include <BOPInt_Context.hxx>
+#include <IntTools_Context.hxx>
 #include <IntSurf_ListIteratorOfListOfPntOn2S.hxx>
 
 static
@@ -186,7 +186,7 @@ static
                                        const Standard_Boolean                         theAvoidLConstructor,
                                        IntPatch_SequenceOfLine&                       theNewLines,
                                        Standard_Real&                                 theReachedTol3d,
-                                        const Handle(BOPInt_Context)& );
+                                        const Handle(IntTools_Context)& );
 
 static 
   Standard_Boolean ParameterOutOfBoundary(const Standard_Real       theParameter, 
@@ -196,7 +196,7 @@ static
                                          const Standard_Real       theOtherParameter,
                                          const Standard_Boolean    bIncreasePar,
                                          Standard_Real&            theNewParameter,
-                                          const Handle(BOPInt_Context)& );
+                                          const Handle(IntTools_Context)& );
 
 static 
   Standard_Boolean IsCurveValid(Handle(Geom2d_Curve)& thePCurve);
@@ -225,7 +225,7 @@ static
                                       Handle(TColgp_HArray1OfPnt2d)&       theResultOnS1,
                                       Handle(TColgp_HArray1OfPnt2d)&       theResultOnS2,
                                       Handle(TColStd_HArray1OfReal)&       theResultRadius,
-                                       const Handle(BOPInt_Context)& );
+                                       const Handle(IntTools_Context)& );
 
 static
   Standard_Boolean FindPoint(const gp_Pnt2d&     theFirstPoint,
@@ -296,7 +296,7 @@ static
                                   const Handle(GeomAdaptor_HSurface) myHS2,
                                   const TopoDS_Face& aF1,
                                   const TopoDS_Face& aF2,
-                                   const Handle(BOPInt_Context)& aCtx);
+                                   const Handle(IntTools_Context)& aCtx);
 
 static
   Standard_Boolean CheckPCurve(const Handle(Geom2d_Curve)& aPC, 
@@ -314,7 +314,7 @@ static
                                       const Handle(GeomAdaptor_HSurface)& myHS2,
                                       const TopoDS_Face& aF1,
                                       const TopoDS_Face& aF2,
-                                       const Handle(BOPInt_Context)& aCtx);
+                                       const Handle(IntTools_Context)& aCtx);
 
 //=======================================================================
 //function : 
@@ -336,7 +336,7 @@ IntTools_FaceFace::IntTools_FaceFace()
 //function : SetContext
 //purpose  : 
 //======================================================================= 
-void IntTools_FaceFace::SetContext(const Handle(BOPInt_Context)& aContext)
+void IntTools_FaceFace::SetContext(const Handle(IntTools_Context)& aContext)
 {
   myContext=aContext;
 }
@@ -344,7 +344,7 @@ void IntTools_FaceFace::SetContext(const Handle(BOPInt_Context)& aContext)
 //function : Context
 //purpose  : 
 //======================================================================= 
-const Handle(BOPInt_Context)& IntTools_FaceFace::Context()const
+const Handle(IntTools_Context)& IntTools_FaceFace::Context()const
 {
   return myContext;
 }
@@ -522,7 +522,7 @@ static Standard_Boolean isTreatAnalityc(const TopoDS_Face& theF1,
   Standard_Boolean RestrictLine = Standard_False, hasCone = Standard_False;
   
   if (myContext.IsNull()) {
-    myContext=new BOPInt_Context;
+    myContext=new IntTools_Context;
   }
 
   mySeqOfCurve.Clear();
@@ -3396,7 +3396,7 @@ Standard_Integer ComputeTangentZones( const Handle(GeomAdaptor_HSurface)& theSur
                                     Handle(TColgp_HArray1OfPnt2d)&       theResultOnS1,
                                     Handle(TColgp_HArray1OfPnt2d)&       theResultOnS2,
                                     Handle(TColStd_HArray1OfReal)&       theResultRadius,
-                                     const Handle(BOPInt_Context)& aContext)
+                                     const Handle(IntTools_Context)& aContext)
 {
   Standard_Integer aResult = 0;
   if ( !CheckTangentZonesExist( theSurface1, theSurface2 ) )
@@ -3608,7 +3608,7 @@ Standard_Boolean DecompositionOfWLine(const Handle(IntPatch_WLine)& theWLine,
                                      const Standard_Boolean                         theAvoidLConstructor,
                                      IntPatch_SequenceOfLine&                       theNewLines,
                                      Standard_Real&                                 theReachedTol3d,
-                                      const Handle(BOPInt_Context)& aContext) 
+                                      const Handle(IntTools_Context)& aContext) 
 {
 
   Standard_Boolean bRet, bAvoidLineConstructor;
@@ -4333,7 +4333,7 @@ Standard_Boolean ParameterOutOfBoundary(const Standard_Real       theParameter,
                                        const Standard_Real       theOtherParameter,
                                        const Standard_Boolean    bIncreasePar,
                                        Standard_Real&            theNewParameter,
-                                        const Handle(BOPInt_Context)& aContext)
+                                        const Handle(IntTools_Context)& aContext)
 {
   Standard_Boolean bIsComputed = Standard_False;
   theNewParameter = theParameter;
@@ -4965,7 +4965,7 @@ Standard_Real FindMaxSquareDistance (const Standard_Real aT1,
                                     const Handle(GeomAdaptor_HSurface)& myHS2,
                                     const TopoDS_Face& myFace1,
                                     const TopoDS_Face& myFace2,
-                                     const Handle(BOPInt_Context)& myContext)
+                                     const Handle(IntTools_Context)& myContext)
 {
   Standard_Real aA, aB, aCf, aX1, aX2, aF1, aF2, aX, aF;
   //
@@ -5019,7 +5019,7 @@ Standard_Real MaxSquareDistance (const Standard_Real aT,
                                 const Handle(GeomAdaptor_HSurface) myHS2,
                                 const TopoDS_Face& aF1,
                                 const TopoDS_Face& aF2,
-                                 const Handle(BOPInt_Context)& aCtx)
+                                 const Handle(IntTools_Context)& aCtx)
 {
   Standard_Boolean bIsDone;
   Standard_Integer i;
similarity index 89%
rename from src/BOPInt/BOPInt_ShrunkRange.cdl
rename to src/IntTools/IntTools_ShrunkRange.cdl
index 717a630..e3a7ba9 100644 (file)
@@ -12,7 +12,7 @@
 -- Alternatively, this file may be used under the terms of Open CASCADE
 -- commercial license or contractual agreement.
 
-class ShrunkRange from BOPInt 
+class ShrunkRange from IntTools 
 
  ---Purpose:  
  ---  The class provides the computation of 
@@ -23,14 +23,14 @@ uses
     Box from Bnd, 
     Edge from TopoDS, 
     Vertex from TopoDS, 
-    Context  from BOPInt
+    Context  from IntTools
 
 --raises
 
 is 
     Create 
-        returns ShrunkRange from BOPInt;
-    ---C++: alias "Standard_EXPORT virtual ~BOPInt_ShrunkRange();"  
+        returns ShrunkRange from IntTools;
+    ---C++: alias "Standard_EXPORT virtual ~IntTools_ShrunkRange();"  
     
     SetData (me:out; 
             aE  : Edge from TopoDS;  
@@ -40,10 +40,10 @@ is
             aV2 : Vertex from TopoDS); 
      
     SetContext(me:out; 
-            aCtx: Context from BOPInt);  
+            aCtx: Context from IntTools);  
              
     Context(me) 
-        returns Context from BOPInt;       
+        returns Context from IntTools;       
     ---C++: return const &  
     
     SetShrunkRange(me:out; 
@@ -89,7 +89,7 @@ fields
     myTS1         : Real from Standard is protected;     
     myTS2         : Real from Standard is protected;     
     myBndBox      : Box from Bnd is protected;  
-    myCtx         : Context from BOPInt is protected;
+    myCtx         : Context from IntTools is protected;
     myErrorStatus : Integer from Standard is protected;   
      
 end ShrunkRange;
similarity index 91%
rename from src/BOPInt/BOPInt_ShrunkRange.cxx
rename to src/IntTools/IntTools_ShrunkRange.cxx
index ad2584c..00a6277 100644 (file)
@@ -12,7 +12,7 @@
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-#include <BOPInt_ShrunkRange.ixx>
+#include <IntTools_ShrunkRange.ixx>
 
 #include <Precision.hxx>
 
@@ -25,7 +25,7 @@
 #include <BRepBuilderAPI_MakeVertex.hxx>
 #include <BRepAdaptor_Curve.hxx>
 #include <BndLib_Add3dCurve.hxx>
-#include <BOPInt_Context.hxx>
+#include <IntTools_Context.hxx>
 #include <gp_Lin.hxx>
 #include <ElCLib.hxx>
 
@@ -33,7 +33,7 @@
 //function : 
 //purpose  : 
 //=======================================================================
-  BOPInt_ShrunkRange::BOPInt_ShrunkRange ()
+  IntTools_ShrunkRange::IntTools_ShrunkRange ()
 {
   myT1=-99;
   myT2=myT1;
 //function : ~
 //purpose  : 
 //=======================================================================
-BOPInt_ShrunkRange::~BOPInt_ShrunkRange () 
+IntTools_ShrunkRange::~IntTools_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)
+void IntTools_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;
@@ -69,7 +69,7 @@ void BOPInt_ShrunkRange::SetData(const TopoDS_Edge& aE,
 //function : SetContext
 //purpose  : 
 //=======================================================================
-void BOPInt_ShrunkRange::SetContext(const Handle(BOPInt_Context)& aCtx)
+void IntTools_ShrunkRange::SetContext(const Handle(IntTools_Context)& aCtx)
 {
   myCtx=aCtx;
 }
@@ -77,7 +77,7 @@ void BOPInt_ShrunkRange::SetContext(const Handle(BOPInt_Context)& aCtx)
 //function : Context
 //purpose  : 
 //=======================================================================
-const Handle(BOPInt_Context)& BOPInt_ShrunkRange::Context()const
+const Handle(IntTools_Context)& IntTools_ShrunkRange::Context()const
 {
   return myCtx;
 }
@@ -85,7 +85,7 @@ const Handle(BOPInt_Context)& BOPInt_ShrunkRange::Context()const
 //function : Edge
 //purpose  : 
 //=======================================================================
-const TopoDS_Edge& BOPInt_ShrunkRange::Edge() const
+const TopoDS_Edge& IntTools_ShrunkRange::Edge() const
 {
   return myEdge;
 }
@@ -93,8 +93,8 @@ const TopoDS_Edge& BOPInt_ShrunkRange::Edge() const
 //function : ShrunkRange
 //purpose  : 
 //=======================================================================
-void BOPInt_ShrunkRange::ShrunkRange(Standard_Real& aT1,
-                                     Standard_Real& aT2) const
+void IntTools_ShrunkRange::ShrunkRange(Standard_Real& aT1,
+                                       Standard_Real& aT2) const
 {
   aT1=myTS1;
   aT2=myTS2;
@@ -103,7 +103,7 @@ void BOPInt_ShrunkRange::ShrunkRange(Standard_Real& aT1,
 //function : BndBox
 //purpose  : 
 //=======================================================================
-const Bnd_Box& BOPInt_ShrunkRange::BndBox() const
+const Bnd_Box& IntTools_ShrunkRange::BndBox() const
 {
   return myBndBox;
 }
@@ -111,7 +111,7 @@ const Bnd_Box& BOPInt_ShrunkRange::BndBox() const
 //function : ErrorStatus
 //purpose  : 
 //=======================================================================
-Standard_Integer BOPInt_ShrunkRange::ErrorStatus() const
+Standard_Integer IntTools_ShrunkRange::ErrorStatus() const
 {
   return myErrorStatus;
 }
@@ -120,8 +120,8 @@ Standard_Integer BOPInt_ShrunkRange::ErrorStatus() const
 //function : SetShrunkRange
 //purpose  : 
 //=======================================================================
-void BOPInt_ShrunkRange::SetShrunkRange(const Standard_Real aT1,
-                                        const Standard_Real aT2) 
+void IntTools_ShrunkRange::SetShrunkRange(const Standard_Real aT1,
+                                          const Standard_Real aT2) 
 {
   myTS1=aT1;
   myTS2=aT2;
@@ -134,7 +134,7 @@ void BOPInt_ShrunkRange::SetShrunkRange(const Standard_Real aT1,
 //function : Perform
 //purpose  : 
 //=======================================================================
-void BOPInt_ShrunkRange::Perform()
+void IntTools_ShrunkRange::Perform()
 {
   Standard_Real aCF, aCL, aTolE, aTolV1;
   Standard_Real aTolV2, t1, t11, t1C, t2, t12, t2C;
index d6fa700..7565585 100644 (file)
@@ -15,9 +15,9 @@
 
 class Tools from IntTools 
 
-       ---Purpose:  
-       ---  The class contains handy static functions 
-       ---  dealing with the geometry and topology. 
+ ---Purpose:  
+ ---  The class contains handy static functions 
+ ---  dealing with the geometry and topology. 
         
 uses
     Shape   from  TopoDS, 
@@ -28,160 +28,214 @@ uses
     Pnt2d   from  gp,   
     Pnt     from  gp, 
     Dir     from  gp,
+    Lin     from  gp,
+    Pln     from  gp,
     CommonPrt         from IntTools, 
     Curve             from IntTools, 
+    Range             from IntTools, 
     SequenceOfCurves  from IntTools,
     Curve   from  Geom,
-    State   from  TopAbs
-
+    State   from  TopAbs,
+    Box from Bnd 
+    
 is 
     ComputeVV  (myclass;V1,V2:Vertex  from  TopoDS) 
-       returns Integer from Standard; 
-       ---Purpose:
-       --- Computes distance between vertex V1 and vertex V2,
-       --- if the distance is less than sum of vertex tolerances
-       --- returns zero,
-       --- otherwise returns negative value
-       ---
+        returns Integer from Standard; 
+    ---Purpose:
+    --- Computes distance between vertex V1 and vertex V2,
+    --- if the distance is less than sum of vertex tolerances
+    --- returns zero,
+    --- otherwise returns negative value
+    ---
 
     HasInternalEdge  (myclass;  
-                     aW: Wire  from  TopoDS) 
-       returns  Boolean from Standard;
-       ---Purpose:
-       --- Returns True if wire aW contains edges
-       --- with INTERNAL orientation
-       ---
+                aW: Wire  from  TopoDS) 
+        returns  Boolean from Standard;
+    ---Purpose:
+    --- Returns True if wire aW contains edges
+    --- with INTERNAL orientation
+    ---
  
     MakeFaceFromWireAndFace  (myclass; 
-                             aW: Wire from TopoDS;
-                             aF: Face from TopoDS;
-                             aFNew:out Face from TopoDS); 
-       ---Purpose:
-       --- Build a face based on surface of given face aF
-       --- and bounded by wire aW
-       ---
-                  
-    ClassifyPointByFace          (myclass;  
-                          aF: Face from TopoDS; 
-                          P:  Pnt2d  from  gp) 
-       returns State from TopAbs;
-       ---Purpose:
-       --- 
-       ---
-       
+                     aW: Wire from TopoDS;
+                     aF: Face from TopoDS;
+                     aFNew:out Face from TopoDS); 
+     ---Purpose:
+    --- Build a face based on surface of given face aF
+    --- and bounded by wire aW
+    ---
+     
+    ClassifyPointByFace   (myclass;  
+            aF: Face from TopoDS; 
+            P:  Pnt2d  from  gp) 
+        returns State from TopAbs;
+    ---Purpose:
+    --- 
+    ---
     IsVertex  (myclass; E: Edge    from  TopoDS; 
-                       t: Real from Standard) 
-       returns Boolean from Standard;
-       ---Purpose:
-       --- Computes square distance between a point on the edge E
-       --- corresponded to parameter t and vertices of edge E.
-       --- Returns True if this distance is less than square 
-       --- tolerance of vertex, otherwise returns false.
-       ---
-                
+               t: Real from Standard) 
+        returns Boolean from Standard;
+    ---Purpose:
+    --- Computes square distance between a point on the edge E
+    --- corresponded to parameter t and vertices of edge E.
+    --- Returns True if this distance is less than square 
+    --- tolerance of vertex, otherwise returns false.
+    ---
+       
     IsVertex  (myclass; E: Edge    from  TopoDS;  
-                       V: Vertex  from  TopoDS; 
-                       t: Real from Standard) 
-       returns Boolean from Standard;
-       ---Purpose:
-       --- Returns True if square distance between vertex V
-       --- and a point on the edge E corresponded to parameter t
-       --- is less than square tolerance of V
-       ---
-        
+                  V: Vertex  from  TopoDS; 
+                  t: Real from Standard) 
+        returns Boolean from Standard;
+    ---Purpose:
+    --- Returns True if square distance between vertex V
+    --- and a point on the edge E corresponded to parameter t
+    --- is less than square tolerance of V
+    ---
+  
     IsVertex  (myclass;  aCmnPrt: CommonPrt from  IntTools) 
-       returns Boolean from Standard;
-       ---Purpose:
-       --- Returns True if IsVertx for middle parameter of fist range 
-       --- and first edge returns True
-       --- and if IsVertex for middle parameter of second range and 
-       --- second range returns True,
-       --- otherwise returns False
-       ---
-        
+        returns Boolean from Standard;
+    ---Purpose:
+    --- Returns True if IsVertx for middle parameter of fist range 
+    --- and first edge returns True
+    --- and if IsVertex for middle parameter of second range and 
+    --- second range returns True,
+    --- otherwise returns False
+    ---
+  
     IsMiddlePointsEqual(myclass; 
-                      E1: Edge    from  TopoDS;                   
-                      E2: Edge    from  TopoDS) 
+                E1: Edge    from  TopoDS;             
+                E2: Edge    from  TopoDS) 
         returns Boolean from Standard;
-       ---Purpose:
-       --- Gets boundary of parameters of E1 and E2.
-       --- Computes 3d points on each corresponded to average parameters.
-       --- Returns True if distance between computed points is less than
-       --- sum of edge tolerance, otherwise returns False.
-       ---
+    ---Purpose:
+    --- Gets boundary of parameters of E1 and E2.
+    --- Computes 3d points on each corresponded to average parameters.
+    --- Returns True if distance between computed points is less than
+    --- sum of edge tolerance, otherwise returns False.
+    ---
 
     IsVertex        (myclass; 
-                   aP  : Pnt  from gp;  
-                   aTolPV: Real from Standard; 
-                   aV: Vertex  from TopoDS)  
-       returns Boolean from Standard;
-       ---Purpose:
-       --- Returns True if the distance between point aP and 
-       --- vertex aV is less or equal to sum of aTolPV and 
-       --- vertex tolerance, otherwise returns False
-       ---
+              aP  : Pnt  from gp;  
+      aTolPV: Real from Standard; 
+              aV: Vertex  from TopoDS)  
+        returns Boolean from Standard;
+    ---Purpose:
+    --- Returns True if the distance between point aP and 
+    --- vertex aV is less or equal to sum of aTolPV and 
+    --- vertex tolerance, otherwise returns False
+    ---
 
     IntermediatePoint (myclass; 
-                      aFirst: Real from Standard; 
-                       aLast : Real from Standard) 
-       returns  Real from Standard;
-       ---Purpose:
-       --- Returns some value between aFirst and aLast
-       ---
+                 aFirst: Real from Standard; 
+                 aLast : Real from Standard) 
+        returns  Real from Standard;
+    ---Purpose:
+    --- Returns some value between aFirst and aLast
+    ---
     
     SplitCurve  (myclass;  
-                aC : Curve from IntTools;  
-                aS :out SequenceOfCurves  from IntTools) 
-       returns Integer from Standard;
-       ---Purpose:
-       --- Split aC by average parameter if aC is closed in 3D.
-       --- Returns positive value if splitting has been done,
-       --- otherwise returns zero.
-       ---
-        
+           aC : Curve from IntTools;  
+           aS :out SequenceOfCurves  from IntTools) 
+        returns Integer from Standard;
+    ---Purpose:
+    --- Split aC by average parameter if aC is closed in 3D.
+    --- Returns positive value if splitting has been done,
+    --- otherwise returns zero.
+    ---
+  
     RejectLines(myclass; 
-               aSIn:     SequenceOfCurves  from IntTools; 
-               aSOut:out SequenceOfCurves  from IntTools);
-       ---Purpose:
-       --- Puts curves from aSIn to aSOut except those curves that
-       --- are coincide with first curve from aSIn.
-       ---
-                        
+          aSIn:     SequenceOfCurves  from IntTools; 
+          aSOut:out SequenceOfCurves  from IntTools);
+     ---Purpose:
+    --- Puts curves from aSIn to aSOut except those curves that
+    --- are coincide with first curve from aSIn.
+    ---
+    
     IsDirsCoinside (myclass;  
-                   D1:Dir from gp; 
-                   D2:Dir from gp) 
-       returns Boolean from Standard;
-       ---Purpose:
-       --- Returns True if D1 and D2 coinside
-       --- 
+              D1:Dir from gp; 
+              D2:Dir from gp) 
+        returns Boolean from Standard;
+    ---Purpose:
+    --- Returns True if D1 and D2 coinside
+    --- 
 
     IsDirsCoinside (myclass;  
-                   D1  :Dir from gp; 
-                   D2  :Dir from gp; 
-                   aTol:Real from Standard) 
-       returns Boolean from Standard;
-       ---Purpose:
-       --- Returns True if D1 and D2 coinside with given tolerance  
-       ---  
+              D1  :Dir from gp; 
+              D2  :Dir from gp; 
+              aTol:Real from Standard) 
+        returns Boolean from Standard;
+    ---Purpose:
+    --- Returns True if D1 and D2 coinside with given tolerance  
+    ---  
 
     IsClosed    (myclass;  
-                aC : Curve from Geom)  
-       returns Boolean from Standard;
-       ---Purpose:
-       --- Returns True if aC is BoundedCurve from Geom and
-       --- the distance between first point
-       --- of the curve aC and last point
-       --- is less than 1.e-12
-       ---
-       
+           aC : Curve from Geom)  
+        returns Boolean from Standard;
+    ---Purpose:
+    --- Returns True if aC is BoundedCurve from Geom and
+    --- the distance between first point
+    --- of the curve aC and last point
+    --- is less than 1.e-12
+    ---
     CurveTolerance(myclass;   
-                       aC   : Curve from Geom; 
-                       aTolBase : Real from Standard) 
-       returns Real from Standard;
-       ---Purpose:
-       --- Returns adaptive tolerance for given aTolBase
-       --- if aC is trimmed curve and basis curve is parabola,
-       --- otherwise returns value of aTolBase
-       ---
+               aC   : Curve from Geom; 
+   aTolBase : Real from Standard) 
+     returns Real from Standard;
+    ---Purpose:
+    --- Returns adaptive tolerance for given aTolBase
+    --- if aC is trimmed curve and basis curve is parabola,
+    --- otherwise returns value of aTolBase
+    ---
+--~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
+     
+    CheckCurve(myclass; 
+        theC:Curve from Geom;  
+        theTol:Real from Standard; 
+        theBox:out Box from Bnd) 
+    returns Boolean from Standard;   
+     
+    IsOnPave(myclass; 
+        theT:Real from Standard;  
+        theRange:Range from IntTools; 
+        theTol: Real from Standard) 
+    returns Boolean from Standard;  
+
+    VertexParameters(myclass; 
+        theCP:CommonPrt from IntTools; 
+        theT1:out Real from Standard;  
+        theT2:out Real from Standard);  
+
+    VertexParameter(myclass; 
+        theCP:CommonPrt from IntTools; 
+        theT:out Real from Standard); 
+    IsOnPave1(myclass; 
+        theT:Real from Standard;  
+        theRange:Range from IntTools; 
+        theTol: Real from Standard) 
+    returns Boolean from Standard;     
+      
+    IsInRange(myclass;
+        theRRef : Range from IntTools; 
+        theR    : Range from IntTools; 
+        theTol  : Real  from Standard) 
+    returns Boolean from Standard;      
+    ---Purpose:  Checks if the range <theR> interfere with the range <theRRef>
+    
+    SegPln(myclass; 
+        theLin   :  Lin from gp; 
+        theTLin1 :  Real from Standard; 
+        theTLin2 :  Real from Standard; 
+        theTolLin:  Real from Standard;   
+        thePln   :  Pln  from gp; 
+        theTolPln:  Real from Standard; 
+        theP     :out Pnt from gp;   
+        theT     :out Real from Standard;  
+        theTolP  :out Real from Standard; 
+        theTmin  :out Real from Standard; 
+        theTmax  :out Real from Standard) 
+    returns Integer from Standard;  
 
 end Tools;
index c3eea79..c7959af 100644 (file)
 
 static
   void ParabolaTolerance(const Handle(Geom_Curve)& ,
-                        const Standard_Real ,
-                        const Standard_Real ,
-                        const Standard_Real ,
-                        Standard_Real& ,
-                        Standard_Real& );
+    const Standard_Real ,
+    const Standard_Real ,
+    const Standard_Real ,
+    Standard_Real& ,
+    Standard_Real& );
 
 //=======================================================================
 //function : HasInternalEdge
@@ -110,16 +110,11 @@ static
 
   
   //
-  //modified by NIZNHY-PKV Mon Jul 04 11:58:23 2011f
   aPC=Precision::Confusion();
   aPC=aPC*aPC;
   aDist=aP1.SquareDistance(aP2);
   bRet=aDist<aPC;
   return bRet;
-  //
-  //aDist=aP1.Distance(aP2);
-  //return (aDist < Precision::Confusion()); 
-  //modified by NIZNHY-PKV Mon Jul 04 11:59:50 2011t
 }
 
 //=======================================================================
@@ -127,7 +122,7 @@ static
 //purpose  : 
 //=======================================================================
    void IntTools_Tools::RejectLines(const IntTools_SequenceOfCurves& aSIn,
-                                   IntTools_SequenceOfCurves& aSOut)
+        IntTools_SequenceOfCurves& aSOut)
 {
   Standard_Integer i, j, aNb;
   Standard_Boolean bFlag;
@@ -157,7 +152,7 @@ static
     if (aGLine.IsNull()) {
       aSOut.Clear();
       for (j=1; j<=aNb; j++) {
-       aSOut.Append(aSIn(j));
+ aSOut.Append(aSIn(j));
       }
       return;
     }
@@ -198,8 +193,8 @@ static
 //purpose  : 
 //=======================================================================
   Standard_Boolean IntTools_Tools::IsDirsCoinside  (const gp_Dir& D1, 
-                                                   const gp_Dir& D2,
-                                                   const Standard_Real dLim)
+          const gp_Dir& D2,
+          const Standard_Real dLim)
 {
   Standard_Boolean bFlag;
   Standard_Real d;
@@ -215,7 +210,7 @@ static
 //purpose  : 
 //=======================================================================
   Standard_Integer IntTools_Tools::SplitCurve(const IntTools_Curve& IC,
-                                             IntTools_SequenceOfCurves& aCvs)
+           IntTools_SequenceOfCurves& aCvs)
 {
   Handle (Geom_Curve) aC3D =IC.Curve();
   if(aC3D.IsNull())
@@ -277,7 +272,7 @@ static
 //purpose  : 
 //=======================================================================
   Standard_Real IntTools_Tools::IntermediatePoint (const Standard_Real aFirst,
-                                                  const Standard_Real aLast)
+         const Standard_Real aLast)
 {
   //define parameter division number as 10*e^(-M_PI) = 0.43213918
   const Standard_Real PAR_T = 0.43213918;
@@ -291,8 +286,8 @@ static
 //purpose  : 
 //=======================================================================
   Standard_Boolean IntTools_Tools::IsVertex (const gp_Pnt& aP,
-                                            const Standard_Real aTolPV,
-                                            const TopoDS_Vertex& aV)
+          const Standard_Real aTolPV,
+          const TopoDS_Vertex& aV)
 {
   Standard_Boolean bRet;
   Standard_Real aTolV, aD, dTol;
@@ -305,15 +300,10 @@ static
   //
   aPv=BRep_Tool::Pnt(aV);
   //
-  //modified by NIZNHY-PKV Mon Jul 04 12:00:37 2011f
   aD=aPv.SquareDistance(aP);
   aTolV=aTolV*aTolV;
   bRet=(aD<=aTolV);
   return bRet;
-  //
-  //aD=aPv.Distance(aP);
-  //return (aD<=aTolV);
-  //modified by NIZNHY-PKV Mon Jul 04 12:00:40 2011t
 }
 
 
@@ -351,8 +341,8 @@ static
 //purpose  : 
 //=======================================================================
   Standard_Boolean IntTools_Tools::IsVertex (const TopoDS_Edge& aE,
-                                            const TopoDS_Vertex& aV,
-                                            const Standard_Real t)
+          const TopoDS_Vertex& aV,
+          const Standard_Real t)
 {
   Standard_Real aTolV, aTolV2, d2;
   gp_Pnt aPv, aPt; 
@@ -374,7 +364,7 @@ static
 //purpose  : 
 //=======================================================================
   Standard_Boolean IntTools_Tools::IsVertex (const TopoDS_Edge& aE,
-                                            const Standard_Real t)
+          const Standard_Real t)
 {
   Standard_Real aTolV, aTolV2, d2;
   TopoDS_Vertex aV;
@@ -404,7 +394,7 @@ static
 //purpose  : 
 //=======================================================================
   Standard_Integer IntTools_Tools::ComputeVV(const TopoDS_Vertex& aV1, 
-                                            const TopoDS_Vertex& aV2)
+          const TopoDS_Vertex& aV2)
 {
   Standard_Real aTolV1, aTolV2, aTolSum, d;
   gp_Pnt aP1, aP2;
@@ -415,11 +405,8 @@ static
   
   aP1=BRep_Tool::Pnt(aV1);
   aP2=BRep_Tool::Pnt(aV2);
-  //modified by NIZNHY-PKV Mon Jul 04 11:55:52 2011f
   aTolSum=aTolSum*aTolSum;
   d=aP1.SquareDistance(aP2);
-  //d=aP1.Distance(aP2);
-  //modified by NIZNHY-PKV Mon Jul 04 11:55:53 2011t
   if (d<aTolSum) {
     return 0;
   }
@@ -431,8 +418,8 @@ static
 //purpose  : 
 //=======================================================================
   void IntTools_Tools::MakeFaceFromWireAndFace(const TopoDS_Wire& aW,
-                                              const TopoDS_Face& aF,
-                                              TopoDS_Face& aFNew)
+            const TopoDS_Face& aF,
+            TopoDS_Face& aFNew)
 {
   TopoDS_Face aFF;
   aFF=aF;
@@ -447,7 +434,7 @@ static
 //purpose  : 
 //=======================================================================
   TopAbs_State IntTools_Tools::ClassifyPointByFace(const TopoDS_Face& aF,
-                                                  const gp_Pnt2d& aP2d)
+         const gp_Pnt2d& aP2d)
 {
   Standard_Real aFaceTolerance;
   TopAbs_State aState;
@@ -464,8 +451,8 @@ static
 //purpose  : 
 //=======================================================================
   Standard_Boolean IntTools_Tools::IsMiddlePointsEqual(const TopoDS_Edge& aE1,
-                                                      const TopoDS_Edge& aE2)
-                                                      
+             const TopoDS_Edge& aE2)
+             
 {
   Standard_Boolean bRet;
   Standard_Real f1, l1, m1, f2, l2, m2, aTol1, aTol2, aSumTol, aD2;
@@ -482,17 +469,10 @@ static
   C2->D0(m2, aP2);
 
   aSumTol=aTol1+aTol2;
-  //modified by NIZNHY-PKV Mon Jul 04 12:02:20 2011f
   aSumTol=aSumTol*aSumTol;
   aD2=aP1.SquareDistance(aP2);
   bRet=aD2<aSumTol;
   return bRet;
-  //
-  //if (aP1.Distance(aP2) < aSumTol) {
-  //  return Standard_True;
-  //}
-  //return Standard_False;
-  //modified by NIZNHY-PKV Mon Jul 04 12:02:24 2011t
 }
 
 //=======================================================================
@@ -500,7 +480,7 @@ static
 //purpose  : 
 //=======================================================================
   Standard_Real IntTools_Tools::CurveTolerance(const Handle(Geom_Curve)& aC3D,
-                                              const Standard_Real aTolBase)
+            const Standard_Real aTolBase)
 {
   Standard_Real aTolReached, aTf, aTl, aTolMin, aTolMax;
 
@@ -535,16 +515,17 @@ static
 
 #include <Geom_Parabola.hxx>
 #include <gp_Parab.hxx>
+#include <BndLib_Add3dCurve.hxx>
 //=======================================================================
 //function : ParabolaTolerance
 //purpose  : 
 //=======================================================================
 void ParabolaTolerance(const Handle(Geom_Curve)& aC3D,
-                      const Standard_Real aTf,
-                      const Standard_Real aTl,
-                      const Standard_Real aTol,
-                      Standard_Real& aTolMin,
-                      Standard_Real& aTolMax)
+         const Standard_Real aTf,
+         const Standard_Real aTl,
+         const Standard_Real aTol,
+         Standard_Real& aTolMin,
+         Standard_Real& aTolMax)
 {
   
   aTolMin=aTol;
@@ -603,4 +584,197 @@ void ParabolaTolerance(const Handle(Geom_Curve)& aC3D,
   aTolMax=(aTol1>aTol2) ? aTol1 : aTol2;
   aTolMin=(aTol1<aTol2) ? aTol1 : aTol2;
 }
+/////////////////////////////////////////////////////////////////////////
+//=======================================================================
+//function : CheckCurve
+//purpose  : 
+//=======================================================================
+Standard_Boolean IntTools_Tools::CheckCurve(const Handle (Geom_Curve)& aC3D,
+                                            const Standard_Real aTolR3D,
+                                            Bnd_Box& aBox)
+{
+  Standard_Boolean bRet;  
+  Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax, dX, dY, dZ;
+  Standard_Real dS, aTol;
+  GeomAdaptor_Curve aGAC;
+  //
+  aGAC.Load(aC3D);
+  BndLib_Add3dCurve::Add(aGAC, aTolR3D, aBox);
+  // 910/B1
+  aBox.Get(aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
+  dX=aXmax-aXmin;
+  dY=aYmax-aYmin;
+  dZ=aZmax-aZmin;
+  dS=1.e-12;
+  aTol=2.*aTolR3D+dS;
+  bRet=(dX>aTol ||  dY>aTol || dZ>aTol);
+  //
+  return bRet;
+}
+//=======================================================================
+//function : IsOnPave
+//purpose  : 
+//=======================================================================
+Standard_Boolean IntTools_Tools::IsOnPave(const Standard_Real aT1,
+                                          const IntTools_Range& aRange,
+                                          const Standard_Real aTolerance)
+{
+  Standard_Boolean firstisonpave1, firstisonpave2, bIsOnPave;
+  //
+  firstisonpave1  = (Abs(aRange.First() - aT1) < aTolerance);
+  firstisonpave2  = (Abs(aRange.Last()  - aT1) < aTolerance);
+  bIsOnPave=(firstisonpave1 || firstisonpave2);
+  return bIsOnPave;
+}
+//=======================================================================
+// function: VertexParameters
+// purpose: 
+//=======================================================================
+void IntTools_Tools::VertexParameters(const IntTools_CommonPrt& aCPart,
+                                      Standard_Real& aT1, 
+                                      Standard_Real& aT2)
+{
+  const IntTools_Range& aR1=aCPart.Range1();
+  aT1=0.5*(aR1.First()+aR1.Last());
+  //
+  if((aCPart.VertexParameter1() >= aR1.First()) &&
+     (aCPart.VertexParameter1() <= aR1.Last())) {
+    aT1 = aCPart.VertexParameter1();
+  }
+  //
+  const IntTools_SequenceOfRanges& aRanges2=aCPart.Ranges2();
+  const IntTools_Range& aR2=aRanges2(1);
+  aT2=0.5*(aR2.First()+aR2.Last());
+  //
+  if((aCPart.VertexParameter2() >= aR2.First()) &&
+     (aCPart.VertexParameter2() <= aR2.Last())) {
+    aT2 = aCPart.VertexParameter2();
+  }
+}
+//=======================================================================
+// function: VertexParameter
+// purpose: 
+//=======================================================================
+void IntTools_Tools::VertexParameter(const IntTools_CommonPrt& aCPart,
+                                     Standard_Real& aT)
+{
+  const IntTools_Range& aR=aCPart.Range1();
+  aT=0.5*(aR.First()+aR.Last());
+  if((aCPart.VertexParameter1() >= aR.First()) &&
+     (aCPart.VertexParameter1() <= aR.Last())) {
+    aT = aCPart.VertexParameter1();
+  }
+}
+//=======================================================================
+// function: IsOnPave1
+// purpose: 
+//=======================================================================
+Standard_Boolean IntTools_Tools::IsOnPave1(const Standard_Real aTR,
+                                           const IntTools_Range& aCPRange,
+                                           const Standard_Real aTolerance)
+{
+  Standard_Boolean bIsOnPave;
+  Standard_Real aT1, aT2, dT1, dT2;
+  //
+  aT1=aCPRange.First();
+  aT2=aCPRange.Last();
+  bIsOnPave=(aTR>=aT1 && aTR<=aT1);
+  if (bIsOnPave) {
+    return bIsOnPave;
+  }
+  //
+  dT1=Abs(aTR-aT1);  
+  dT2=Abs(aTR-aT2);
+  bIsOnPave=(dT1<=aTolerance || dT2<=aTolerance);
+  return bIsOnPave;
+}
+//=======================================================================
+// function: IsInRange
+// purpose: 
+//=======================================================================
+Standard_Boolean IntTools_Tools::IsInRange(const IntTools_Range& aRRef,
+                                           const IntTools_Range& aR,
+                                           const Standard_Real aTolerance)
+{
+  Standard_Boolean bIsIn;
+  Standard_Real aT1, aT2, aTRef1, aTRef2;
+  //
+  aR.Range(aT1, aT2);
+  aRRef.Range(aTRef1, aTRef2);
+  //
+  aTRef1-=aTolerance;
+  aTRef2+=aTolerance;
+  //
+  bIsIn = (aT1>=aTRef1 && aT1<=aTRef2) ||
+          (aT2>=aTRef1 && aT2<=aTRef2);
+  //
+  return bIsIn;
+}
+//=======================================================================
+//function : SegPln
+//purpose  : 
+//=======================================================================
+Standard_Integer IntTools_Tools::SegPln(const gp_Lin& theLin,
+                                        const Standard_Real theTLin1,
+                                        const Standard_Real theTLin2,
+                                        const Standard_Real theTolLin,
+                                        const gp_Pln& thePln,
+                                        const Standard_Real theTolPln,
+                                        gp_Pnt& theP,
+                                        Standard_Real& theTP,
+                                        Standard_Real& theTolP,
+                                        Standard_Real& theTPmin,
+                                        Standard_Real& theTPmax)
+{
+  Standard_Integer iRet;
+  Standard_Real aTol, aA, aB, aC, aD, aE, aH, aTP, aDist1, aDist2;
+  gp_Pnt aP1, aP2;
+  //
+  iRet=0;
+  aTol=theTolLin+theTolPln;
+  //
+  const gp_Ax3& aPosPln=thePln.Position();
+  const gp_Dir& aDirPln=aPosPln.Direction();
+  const gp_Pnt& aLocPln=aPosPln.Location();
+  //
+  const gp_Dir& aDirLin=theLin.Direction();
+  const gp_Pnt& aLocLin=theLin.Location();
+  //
+  aP1.SetXYZ(aLocLin.XYZ()+theTLin1*aDirLin.XYZ());
+  aDist1=aDirPln.X()*(aP1.X()-aLocPln.X())+
+         aDirPln.Y()*(aP1.Y()-aLocPln.Y())+
+         aDirPln.Z()*(aP1.Z()-aLocPln.Z());
+  //
+  aP2.SetXYZ(aLocLin.XYZ()+theTLin2*aDirLin.XYZ());
+  aDist2=aDirPln.X()*(aP2.X()-aLocPln.X())+
+         aDirPln.Y()*(aP2.Y()-aLocPln.Y())+
+         aDirPln.Z()*(aP2.Z()-aLocPln.Z());
+  //
+  if (aDist1<aTol && aDist2<aTol){
+    iRet=1; // common block
+    return iRet;
+  }
+  //
+  if (aDist1*aDist2 > 0.) {
+    iRet=2; // segment lays on one side to the Plane
+    return iRet;
+  } 
+  //
+  thePln.Coefficients(aA, aB, aC, aD);
+  aE=aA*aLocLin.X()+aB*aLocLin.Y()+aC*aLocLin.Z()+aD;
+  aH=aA*aDirLin.X()+aB*aDirLin.Y()+aC*aDirLin.Z();
+  aTP=-aE/aH;
+  if (aTP < theTLin1-aTol || aTP > theTLin2+aTol) {
+    iRet=3; // no intersections due to range of the Line
+    return iRet;
+  }
+  //
+  theTP=aTP;
+  theP.SetXYZ(aLocLin.XYZ()+aTP*aDirLin.XYZ());
+  theTolP=aTol;
+  theTPmin=theTP-theTolPln;
+  theTPmax=theTP+theTolPln;
+  iRet=0; // intersection point
+  return iRet;
+}
 
index 6bbdedb..9319392 100644 (file)
@@ -24,7 +24,7 @@
 #include <BRep_Tool.hxx>
 #include <BRep_Builder.hxx>
 #include <Geom_Surface.hxx>
-#include <BOPInt_Context.hxx>
+#include <IntTools_Context.hxx>
 #include <TopExp_Explorer.hxx>
 #include <TopExp.hxx>
 #include <GeomAPI_ProjectPointOnSurf.hxx>
index edede8a..8325b04 100755 (executable)
@@ -1,7 +1,6 @@
 IntTools
 BRepAlgoAPI
 BOPCol
-BOPInt
 BOPDS
 BOPAlgo
 BOPTools