0025477: Boolean Operations with additional tolerance - Fuzzy Boolean operations

Implementation of Fuzzy Boolean operations. Such operations allow to perform Boolean operations on the shapes
with near-coincidence between the entities of these shapes, i.e. between shapes in which some entities from one shape
are intended to be coincide with some entities from the other, but the coincidence is not precise.

API for Boolean operations has been improved to have a possibility to add new options.

Modified entities:
1. New option of setting additional tolerance have been added to the following classes:
class BOPAlgo_ArgumentAnalyzer
class BOPAlgo_BOP
class BOPAlgo_Builder
class BOPAlgo_MakerVolume
class BOPAlgo_PaveFiller
class BOPDS_DS
class BRepAlgoAPI_BooleanOperation
class BRepAlgoAPI_Check
class BRepAlgoAPI_Common
class BRepAlgoAPI_Cut
class BRepAlgoAPI_Fuse
class BRepAlgoAPI_Section

2. Following draw commands have been modified to support new functionality:
BOP commands:
bop b1 b2 [tol]
bcommon r b1 b2 [tol]
bcut r b1 b2 [tol]
bfuse r b1 b2 [tol]
bsection r s1 s2 [-n2d/-n2d1/-n2d2] [-na] [tol]
mkvolume r b1 b2 ... [-c] [-ni] [-s] [tol]
bfillds [-s -t] [tol]

Check commands:
bopcheck Shape [level of check: 0 - 9] [-t -s] [-tol tol]
bopargcheck [-F/O/C/T/S/U] [/R|F|T|V|E|I|P|C|S]] [#BF] [-tol tol]

3. Two new classes have been added to API to provide the root interface for algorithms
class BRepAlgoAPI_Algo
class BRepAlgoAPI_BuilderAlgo

Fix to eliminate the warning.

Test-cases for issue #25477

src/BOPAlgo/BOPAlgo_ArgumentAnalyzer.cdl

@@ -14,6 +14,7 @@
 -- commercial license or contractual agreement.
 
 class ArgumentAnalyzer from BOPAlgo
+  inherits Algo from BOPAlgo
     ---Purpose: check the validity of argument(s) for Boolean Operations
     
 uses
@@ -21,11 +22,13 @@ uses
     Operation   from BOPAlgo, 
     CheckStatus from BOPAlgo,
     ShapeEnum  from TopAbs,
-    ListOfCheckResult from BOPAlgo
+    ListOfCheckResult  from BOPAlgo,
+    DataMapOfShapeReal from BOPCol
     
 is
     Create
        returns ArgumentAnalyzer;
+    ---C++: alias "Standard_EXPORT virtual ~BOPAlgo_ArgumentAnalyzer();"
     ---Purpose: empty constructor
 
     SetShape1(me: in out; TheShape: Shape from TopoDS);
@@ -169,6 +172,23 @@ is
 --  TestMergeFace(me: out)
 --  is protected;  
 
+    SetFuzzyValue(me:out; 
+      theFuzz : Real from Standard);
+    ---C++: inline
+    ---Purpose: Sets the additional tolerance
+
+    FuzzyValue(me)
+    returns Real from Standard;
+    ---C++: inline
+    ---Purpose: Returns the additional tolerance 
+
+    UpdateTolerances(me:out)
+    is protected; 
+    ---Purpose: Updates the shapes tolerance values.
+
+    SetDefaultTolerances(me:out)
+    is protected; 
+    ---Purpose: Reverts the tolerance values for all entities to default values.
 
 fields
 
@@ -187,5 +207,7 @@ fields
     myCurveOnSurfaceMode : Boolean   from Standard; 
     myEmpty1, myEmpty2   : Boolean   from Standard; 
     myResult             : ListOfCheckResult from BOPAlgo;
+    myFuzzyValue         : Real      from Standard;
+    myToleranceMap       : DataMapOfShapeReal from BOPCol;
 
 end ArgumentAnalyzer;

src/BOPAlgo/BOPAlgo_ArgumentAnalyzer.cxx

@@ -31,6 +31,9 @@
 #include <TopoDS_Shell.hxx>
 #include <TopoDS_Solid.hxx>
 
+#include <BRep_TVertex.hxx>
+#include <BRep_TEdge.hxx>
+#include <BRep_TFace.hxx>
 #include <BRep_Builder.hxx>
 #include <BRep_Tool.hxx>
 
@@ -49,6 +52,7 @@
 
 #include <IntTools_Context.hxx>
 
+#include <BOPTools.hxx>
 #include <BOPTools_AlgoTools3D.hxx>
 #include <BOPTools_AlgoTools.hxx>
 
@@ -64,6 +68,7 @@
 // purpose:
 // ================================================================================
 BOPAlgo_ArgumentAnalyzer::BOPAlgo_ArgumentAnalyzer() : 
+BOPAlgo_Algo(),
 myStopOnFirst(Standard_False),
 myOperation(BOPAlgo_UNKNOWN),
 myArgumentTypeMode(Standard_False),
@@ -76,9 +81,19 @@ myMergeEdgeMode(Standard_False),
 myContinuityMode(Standard_False),
 myCurveOnSurfaceMode(Standard_False),
 myEmpty1(Standard_False),
-myEmpty2(Standard_False)
+myEmpty2(Standard_False),
+myFuzzyValue(0.)
 {
 }
+//=======================================================================
+// function: ~
+// purpose: 
+//=======================================================================
+BOPAlgo_ArgumentAnalyzer::~BOPAlgo_ArgumentAnalyzer()
+{
+  myResult.Clear();
+  myToleranceMap.Clear();
+}
 
 // ================================================================================
 // function: SetShape1
@@ -157,47 +172,82 @@ void BOPAlgo_ArgumentAnalyzer::Perform()
   try {
     OCC_CATCH_SIGNALS
     myResult.Clear();
-
+    //
+    UserBreak();
+    //
+    // 1. Prepare
     Prepare();
-
+    //
+    UserBreak();
+    //
+    // 2. Update Tolerances according to myFuzzyValue
+    UpdateTolerances();
+    //
+    UserBreak();
+    //
+    // 3. Test types
     if(myArgumentTypeMode) {
       TestTypes();
     }
-
+    //
+    UserBreak();
+    //
+    // 4. Test self-interference
     if(mySelfInterMode) {
       TestSelfInterferences();
     }
-
+    //
+    UserBreak();
+    //
+    // 5. Test small edges
     if(mySmallEdgeMode) {
       if(!(!myResult.IsEmpty() && myStopOnFirst))
         TestSmallEdge();
     }
-
+    //
+    UserBreak();
+    //
+    // 6. Test possibility to rebuild faces
     if(myRebuildFaceMode) {
       if(!(!myResult.IsEmpty() && myStopOnFirst))
         TestRebuildFace();
     }
-
+    //
+    UserBreak();
+    //
+    // 7. Test tangent
     if(myTangentMode) {
       if(!(!myResult.IsEmpty() && myStopOnFirst))
         TestTangent();
     }
-
+    //
+    UserBreak();
+    //
+    // 8. Test merge vertices
     if(myMergeVertexMode) {
       if(!(!myResult.IsEmpty() && myStopOnFirst))
         TestMergeVertex();
     }
-    
+    //
+    UserBreak();
+    //
+    // 9. Test merge edges
     if(myMergeEdgeMode) {
       if(!(!myResult.IsEmpty() && myStopOnFirst))
         TestMergeEdge();
     }
-
+    //
+    UserBreak();
+    //
+    // 10. Test shapes continuity
     if(myContinuityMode) {
       if(!(!myResult.IsEmpty() && myStopOnFirst))
         TestContinuity();
     }
-
+    //
+    UserBreak();
+    //
+    // 11. Test validity of the curves on the surfaces
     if(myCurveOnSurfaceMode) {
       if(!(!myResult.IsEmpty() && myStopOnFirst))
         TestCurveOnSurface();
@@ -208,6 +258,8 @@ void BOPAlgo_ArgumentAnalyzer::Perform()
     aResult.SetCheckStatus(BOPAlgo_CheckUnknown);
     myResult.Append(aResult);
   }
+  //
+  SetDefaultTolerances();
 }
 
 // ================================================================================
@@ -329,6 +381,8 @@ void BOPAlgo_ArgumentAnalyzer::TestSelfInterferences()
     anArgs.Append(aS);
     aChecker.SetArguments(anArgs);
     aChecker.SetNonDestructive(Standard_True);
+    aChecker.SetRunParallel(myRunParallel);
+    aChecker.SetProgressIndicator(myProgressIndicator);
     //
     aChecker.Perform();
     iErr=aChecker.ErrorStatus();
@@ -874,3 +928,121 @@ void BOPAlgo_ArgumentAnalyzer::TestCurveOnSurface()
   }
 }
 
+// ================================================================================
+// function: UpdateTolerances
+// purpose:
+// ================================================================================
+void BOPAlgo_ArgumentAnalyzer::UpdateTolerances()
+{
+  if (myFuzzyValue == 0.) {
+    return;
+  }
+  //
+  BOPCol_MapOfShape aMapShapes;
+  //
+  if (!myShape1.IsNull()) {
+    BOPTools::MapShapes(myShape1, aMapShapes);
+  }
+  if (!myShape2.IsNull()) {
+    BOPTools::MapShapes(myShape2, aMapShapes);
+  }
+  //
+  if (aMapShapes.IsEmpty()) {
+    return;
+  }
+  //
+  Standard_Real aTol, aFuzz;
+  TopAbs_ShapeEnum aType;
+  BOPCol_MapIteratorOfMapOfShape aIt;
+  //
+  aFuzz = myFuzzyValue / 2.;
+  aIt.Initialize(aMapShapes);
+  for (; aIt.More(); aIt.Next()) {
+    const TopoDS_Shape& aS = aIt.Value();
+    aType = aS.ShapeType();
+    //
+    switch (aType) {
+    case TopAbs_VERTEX: {
+      const TopoDS_Vertex& aV = *(TopoDS_Vertex*)&aS;
+      const Handle(BRep_TVertex)& TV = 
+        *((Handle(BRep_TVertex)*)&aV.TShape());
+      aTol = TV->Tolerance();
+      myToleranceMap.Bind(aS, aTol);
+      TV->Tolerance(aTol + aFuzz);
+      break;
+    }
+    case TopAbs_EDGE: {
+      const TopoDS_Edge& aE = *(TopoDS_Edge*)&aS;
+      const Handle(BRep_TEdge)& TE = 
+        *((Handle(BRep_TEdge)*)&aE.TShape());
+      aTol = TE->Tolerance();
+      myToleranceMap.Bind(aS, aTol);
+      TE->Tolerance(aTol + aFuzz);
+      break;
+    }
+    case TopAbs_FACE: {
+      const TopoDS_Face& aF = *(TopoDS_Face*)&aS;
+      const Handle(BRep_TFace)& TF = 
+        *((Handle(BRep_TFace)*)&aF.TShape());
+      aTol = TF->Tolerance();
+      myToleranceMap.Bind(aS, aTol);
+      TF->Tolerance(aTol + aFuzz);
+      break;
+    }
+    default:
+      break;
+    } // switch (aType) {
+  } // for (; aIt.More(); aIt.Next()) {
+}
+
+// ================================================================================
+// function: SetDefaultTolerances
+// purpose:
+// ================================================================================
+void BOPAlgo_ArgumentAnalyzer::SetDefaultTolerances()
+{
+  if (myFuzzyValue == 0.) {
+    return;
+  }
+  //
+  if (myToleranceMap.IsEmpty()) {
+    return;
+  }
+  //
+  Standard_Real aTol;
+  TopAbs_ShapeEnum aType;
+  BOPCol_DataMapIteratorOfDataMapOfShapeReal aIt;
+  //
+  aIt.Initialize(myToleranceMap);
+  for (; aIt.More(); aIt.Next()) {
+    const TopoDS_Shape& aS = aIt.Key();
+    aTol = aIt.Value();
+    aType = aS.ShapeType();
+    //
+    switch (aType) {
+    case TopAbs_VERTEX: {
+      const TopoDS_Vertex& aV = *(TopoDS_Vertex*)&aS;
+      const Handle(BRep_TVertex)& TV = 
+        *((Handle(BRep_TVertex)*)&aV.TShape());
+      TV->Tolerance(aTol);
+      break;
+    }
+    case TopAbs_EDGE: {
+      const TopoDS_Edge& aE = *(TopoDS_Edge*)&aS;
+      const Handle(BRep_TEdge)& TE = 
+        *((Handle(BRep_TEdge)*)&aE.TShape());
+      TE->Tolerance(aTol);
+      break;
+    }
+    case TopAbs_FACE: {
+      const TopoDS_Face& aF = *(TopoDS_Face*)&aS;
+      const Handle(BRep_TFace)& TF = 
+        *((Handle(BRep_TFace)*)&aF.TShape());
+      TF->Tolerance(aTol);
+      break;
+    }
+    default:
+      break;
+    } // switch (aType) {
+  } // for (; aIt.More(); aIt.Next()) {
+}

src/BOPAlgo/BOPAlgo_ArgumentAnalyzer.lxx

@@ -61,6 +61,24 @@ inline Standard_Boolean& BOPAlgo_ArgumentAnalyzer::CurveOnSurfaceMode()
 {
   return myCurveOnSurfaceMode;
 }
+//=======================================================================
+//function : SetFuzzyValue
+//purpose  : 
+//=======================================================================
+inline void BOPAlgo_ArgumentAnalyzer::SetFuzzyValue(const Standard_Real theFuzz)
+{
+  if (theFuzz > 0.) {
+    myFuzzyValue = theFuzz;
+  }
+}
+//=======================================================================
+//function : FuzzyValue
+//purpose  : 
+//=======================================================================
+inline Standard_Real BOPAlgo_ArgumentAnalyzer::FuzzyValue() const
+{
+  return myFuzzyValue;
+}
 // inline Standard_Boolean& BOPAlgo_ArgumentAnalyzer::MergeFaceMode() 
 // {
 //   return myMergeFaceMode;

src/BOPAlgo/BOPAlgo_BOP.cxx

@@ -350,6 +350,9 @@ void BOPAlgo_BOP::Perform()
   //
   pPF=new BOPAlgo_PaveFiller(aAllocator);
   pPF->SetArguments(aLS);
+  pPF->SetRunParallel(myRunParallel);
+  pPF->SetProgressIndicator(myProgressIndicator);
+  pPF->SetFuzzyValue(myFuzzyValue);
   //
   pPF->Perform();
   //

src/BOPAlgo/BOPAlgo_Builder.cdl

@@ -221,6 +221,14 @@ is
     ---C++: return const &	  
     ---Purpose:  Returns mySplits.
 
+    SetFuzzyValue(me:out; 
+        theFuzz : Real from Standard);
+    ---Purpose: Sets the additional tolerance
+
+    FuzzyValue(me)
+    returns Real from Standard;
+    ---Purpose: Returns the additional tolerance 
+    
 fields 
     myArguments  : ListOfShape from BOPCol is protected; 
     myMapFence   : MapOfShape from BOPCol is protected; 
@@ -234,6 +242,7 @@ fields
     --
     mySplits     : DataMapOfShapeListOfShape from BOPCol is protected; 
     myOrigins    : DataMapOfShapeShape from BOPCol is protected;
+    myFuzzyValue : Real from Standard is protected; 
  
 end Builder;
 

src/BOPAlgo/BOPAlgo_Builder.cxx

@@ -42,7 +42,8 @@ BOPAlgo_Builder::BOPAlgo_Builder()
   myImages(100, myAllocator),
   myShapesSD(100, myAllocator),
   mySplits(100, myAllocator),
-  myOrigins(100, myAllocator)
+  myOrigins(100, myAllocator),
+  myFuzzyValue(0.)
 {
 }
 //=======================================================================
@@ -61,7 +62,8 @@ BOPAlgo_Builder::BOPAlgo_Builder
   myImages(100, myAllocator), 
   myShapesSD(100, myAllocator),
   mySplits(100, myAllocator),
-  myOrigins(100, myAllocator)
+  myOrigins(100, myAllocator),
+  myFuzzyValue(0.)
 {
 }
 //=======================================================================
@@ -172,6 +174,24 @@ BOPDS_PDS BOPAlgo_Builder::PDS()
   return myDS;
 }
 //=======================================================================
+//function : SetFuzzyValue
+//purpose  : 
+//=======================================================================
+void BOPAlgo_Builder::SetFuzzyValue(const Standard_Real theFuzz)
+{
+  if (theFuzz > 0.) {
+    myFuzzyValue = theFuzz;
+  }
+}
+//=======================================================================
+//function : FuzzyValue
+//purpose  : 
+//=======================================================================
+Standard_Real BOPAlgo_Builder::FuzzyValue() const
+{
+  return myFuzzyValue;
+}
+//=======================================================================
 // function: CheckData
 // purpose: 
 //=======================================================================
@@ -236,6 +256,8 @@ void BOPAlgo_Builder::Perform()
   //
   pPF->SetArguments(myArguments);
   pPF->SetRunParallel(myRunParallel);
+  pPF->SetProgressIndicator(myProgressIndicator);
+  pPF->SetFuzzyValue(myFuzzyValue);
   //
   pPF->Perform();
   //

src/BOPAlgo/BOPAlgo_CheckerSI.cxx

@@ -104,6 +104,7 @@ void BOPAlgo_CheckerSI::Init()
   // 1. myDS
   myDS=new BOPDS_DS(myAllocator);
   myDS->SetArguments(myArguments);
+  myDS->SetFuzzyValue(myFuzzyValue);
   myDS->Init();
   //
   // 2.myIterator 

src/BOPAlgo/BOPAlgo_MakerVolume.cxx

@@ -43,6 +43,29 @@ static
                      BOPCol_MapOfShape& aMFence,
                      BOPCol_ListOfShape& theLS);
 
+//=======================================================================
+//function : CheckData
+//purpose  : 
+//=======================================================================
+void BOPAlgo_MakerVolume::CheckData()
+{
+  if (myArguments.IsEmpty()) {
+    myErrorStatus = 100; // no arguments to process
+    return;
+  }
+  // myPaveFiller
+  if (!myPaveFiller) {
+    myErrorStatus = 101; 
+    return;
+  }
+  //
+  myErrorStatus = myPaveFiller->ErrorStatus();
+  if (myErrorStatus) {
+    myErrorStatus = 102; // PaveFiller is failed
+    return;
+  }
+}
+
 //=======================================================================
 //function : Perform
 //purpose  : 
@@ -84,6 +107,8 @@ void BOPAlgo_MakerVolume::Perform()
   }
   //
   pPF->SetRunParallel(myRunParallel);
+  pPF->SetProgressIndicator(myProgressIndicator);
+  pPF->SetFuzzyValue(myFuzzyValue);
   pPF->Perform();
   //
   myEntryPoint = 1;

src/BOPAlgo/BOPAlgo_MakerVolume.lxx

@@ -92,26 +92,3 @@ inline const BOPCol_ListOfShape& BOPAlgo_MakerVolume::Faces()const
 {
   return myFaces;
 }
-
-//=======================================================================
-//function : CheckData
-//purpose  : 
-//=======================================================================
-inline void BOPAlgo_MakerVolume::CheckData()
-{
-  if (myArguments.IsEmpty()) {
-    myErrorStatus = 100; // no arguments to process
-    return;
-  }
-  // myPaveFiller
-  if (!myPaveFiller) {
-    myErrorStatus = 101; 
-    return;
-  }
-  //
-  myErrorStatus = myPaveFiller->ErrorStatus();
-  if (myErrorStatus) {
-    myErrorStatus = 102; // PaveFiller is failed
-    return;
-  }
-}

src/BOPAlgo/BOPAlgo_PaveFiller.cdl

@@ -464,11 +464,19 @@ is
     -- Updates pave blocks which have the paves with indices contained  
     -- in the map <theDMI>.
 
+    SetFuzzyValue(me:out; 
+        theFuzz : Real from Standard);
+    ---Purpose: Sets the additional tolerance
+
+    FuzzyValue(me)
+    returns Real from Standard;
+    ---Purpose: Returns the additional tolerance 
+
 fields  
     myArguments   : ListOfShape from BOPCol is protected;  
     myDS          : PDS from BOPDS is protected; 
     myIterator    : PIterator from BOPDS is protected; 
     myContext     : Context from IntTools is protected;   
     mySectionAttribute : SectionAttribute from BOPAlgo is protected;
-
+    myFuzzyValue  : Real from Standard is protected;
 end PaveFiller;

src/BOPAlgo/BOPAlgo_PaveFiller.cxx

@@ -33,7 +33,8 @@
 //=======================================================================
 BOPAlgo_PaveFiller::BOPAlgo_PaveFiller()
 :
-  BOPAlgo_Algo()
+  BOPAlgo_Algo(),
+  myFuzzyValue(0.)
 {
   myDS=NULL;
   myIterator=NULL;
@@ -45,7 +46,8 @@ BOPAlgo_PaveFiller::BOPAlgo_PaveFiller()
 BOPAlgo_PaveFiller::BOPAlgo_PaveFiller
   (const Handle(NCollection_BaseAllocator)& theAllocator)
 :
-  BOPAlgo_Algo(theAllocator)
+  BOPAlgo_Algo(theAllocator),
+  myFuzzyValue(0.)
 {
   myDS=NULL;
   myIterator=NULL;
@@ -123,6 +125,24 @@ const BOPCol_ListOfShape& BOPAlgo_PaveFiller::Arguments()const
   return myArguments;
 }
 //=======================================================================
+//function : SetFuzzyValue
+//purpose  : 
+//=======================================================================
+void BOPAlgo_PaveFiller::SetFuzzyValue(const Standard_Real theFuzz)
+{
+  if (theFuzz > 0.) {
+    myFuzzyValue = theFuzz;
+  }
+}
+//=======================================================================
+//function : FuzzyValue
+//purpose  : 
+//=======================================================================
+Standard_Real BOPAlgo_PaveFiller::FuzzyValue() const
+{
+  return myFuzzyValue;
+}
+//=======================================================================
 // function: Init
 // purpose: 
 //=======================================================================
@@ -141,6 +161,7 @@ void BOPAlgo_PaveFiller::Init()
   // 1.myDS 
   myDS=new BOPDS_DS(myAllocator);
   myDS->SetArguments(myArguments);
+  myDS->SetFuzzyValue(myFuzzyValue);
   myDS->Init();
   //
   // 2.myIterator 
@@ -170,6 +191,8 @@ void BOPAlgo_PaveFiller::Perform()
   catch (Standard_Failure) {
     myErrorStatus=11;
   } 
+  //
+  myDS->SetDefaultTolerances();
 }
 //=======================================================================
 // function: PerformInternal
@@ -244,7 +267,6 @@ void BOPAlgo_PaveFiller::PerformInternal()
     return; 
   }
   //
-  //modified by NIZNHY-PKV Fri Sep 12 07:06:50 2014f
   // 03
   PerformVZ();
   if (myErrorStatus) {
@@ -265,5 +287,4 @@ void BOPAlgo_PaveFiller::PerformInternal()
   if (myErrorStatus) {
     return;
   }
-  //modified by NIZNHY-PKV Fri Sep 12 07:06:52 2014t
 } 

src/BOPCol/BOPCol.cdl

@@ -24,6 +24,7 @@ uses
 is 
     imported BaseAllocator from BOPCol; 
     imported DataMapOfShapeInteger from BOPCol; 
+    imported DataMapOfShapeReal from BOPCol; 
     imported MapOfInteger from BOPCol; 
     imported ListOfInteger from BOPCol; 
     imported PInteger from BOPCol; 

src/BOPCol/BOPCol_DataMapOfShapeReal.hxx

@@ -0,0 +1,26 @@
+// 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.
+
+#ifndef BOPCol_DataMapOfShapeReal_HeaderFile
+#define BOPCol_DataMapOfShapeReal_HeaderFile
+
+#include <TopoDS_Shape.hxx>  
+#include <TopTools_ShapeMapHasher.hxx>
+  
+#include <NCollection_DataMap.hxx>
+
+typedef NCollection_DataMap<TopoDS_Shape, Standard_Real, TopTools_ShapeMapHasher> BOPCol_DataMapOfShapeReal; 
+typedef BOPCol_DataMapOfShapeReal::Iterator BOPCol_DataMapIteratorOfDataMapOfShapeReal; 
+ 
+#endif

src/BOPCol/FILES

@@ -1,5 +1,6 @@
 BOPCol_Array1.hxx
 BOPCol_DataMapOfShapeInteger.hxx
+BOPCol_DataMapOfShapeReal.hxx
 BOPCol_MapOfInteger.hxx
 BOPCol_ListOfInteger.hxx
 BOPCol_PInteger.hxx

src/BOPDS/BOPDS_DS.cdl

@@ -39,6 +39,7 @@ uses
     -- 
     ListOfShape from BOPCol,  
     DataMapOfIntegerInteger from BOPCol, 
+    DataMapOfIntegerReal    from BOPCol,
     DataMapOfShapeInteger   from BOPCol, 
     ListOfInteger           from BOPCol, 
     MapOfInteger            from BOPCol, 
@@ -635,7 +636,18 @@ is
             --- Computes bouding box <theBox> for the solid with DS-index <theIndex>
             ---  
              
+    SetFuzzyValue(me:out; 
+                theFuzz : Real from Standard);
+    ---C++: inline 
+    ---Purpose: Sets the extended tolerance
  
+    FuzzyValue(me)
+             returns Real from Standard;
+    ---C++: inline 
+    ---Purpose: Returns the extended tolerance 
+     
+    SetDefaultTolerances(me:out);
+    ---Purpose: Reverts the tolerance values of unchanged entities to default values.
 
 fields  
     myAllocator        : BaseAllocator from BOPCol is protected;
@@ -666,4 +678,9 @@ fields
     myInterfEZ         : VectorOfInterfEZ from BOPDS is protected;
     myInterfFZ         : VectorOfInterfFZ from BOPDS is protected;
     myInterfZZ         : VectorOfInterfZZ from BOPDS is protected; 
+    -- 
+    -- extended tolerance for intersection
+    myFuzzyValue       : Real from Standard is protected;
+    myToleranceMap     : DataMapOfIntegerReal from BOPCol is protected; 
+
 end DS;

src/BOPDS/BOPDS_DS.cxx

@@ -27,6 +27,10 @@
 #include <TopoDS_Vertex.hxx>
 #include <TopoDS_Edge.hxx>
 #include <TopoDS_Face.hxx>
+//
+#include <BRep_TVertex.hxx>
+#include <BRep_TEdge.hxx>
+#include <BRep_TFace.hxx>
 #include <BRep_Tool.hxx>
 //
 #include <BRepBndLib.hxx>
@@ -34,6 +38,7 @@
 #include <BOPCol_MapOfInteger.hxx>
 #include <BOPCol_ListOfInteger.hxx>
 #include <BOPCol_DataMapOfShapeInteger.hxx>
+#include <BOPCol_DataMapOfIntegerMapOfInteger.hxx>
 //
 #include <BOPDS_IndexRange.hxx>
 #include <BOPDS_ShapeInfo.hxx>
@@ -68,6 +73,16 @@ static
   Standard_Real ComputeParameter(const TopoDS_Vertex& aV,
                                  const TopoDS_Edge& aE);
 
+static 
+  void AddShapeAndSubShapes(const Standard_Integer nS,
+                            const BOPDS_ShapeInfo& theSI,
+                            BOPCol_MapOfInteger& theMI);
+
+static 
+  void CollectEdges(const BOPDS_DS& theDS,
+                    const Standard_Integer nF,
+                    BOPCol_MapOfInteger& theMI);
+
 //=======================================================================
 //function : 
 //purpose  : 
@@ -93,7 +108,9 @@ BOPDS_DS::BOPDS_DS()
   myInterfVZ(myAllocator),
   myInterfEZ(myAllocator),
   myInterfFZ(myAllocator),
-  myInterfZZ(myAllocator)
+  myInterfZZ(myAllocator),
+  myFuzzyValue(0.),
+  myToleranceMap(100, myAllocator)
 {
   myNbShapes=0;
   myNbSourceShapes=0;
@@ -123,7 +140,9 @@ BOPDS_DS::BOPDS_DS(const Handle(NCollection_BaseAllocator)& theAllocator)
   myInterfVZ(myAllocator),
   myInterfEZ(myAllocator),
   myInterfFZ(myAllocator),
-  myInterfZZ(myAllocator)
+  myInterfZZ(myAllocator),
+  myFuzzyValue(0.),
+  myToleranceMap(100, myAllocator)
 {
   myNbShapes=0;
   myNbSourceShapes=0;
@@ -144,6 +163,7 @@ void BOPDS_DS::Clear()
 {
   myNbShapes=0;
   myNbSourceShapes=0;
+  myFuzzyValue=0.;
   //
   myArguments.Clear();
   myRanges.Clear();
@@ -164,6 +184,7 @@ void BOPDS_DS::Clear()
   myInterfEZ.Clear();
   myInterfFZ.Clear();
   myInterfZZ.Clear();
+  myToleranceMap.Clear();
 }
 //=======================================================================
 //function : SetArguments
@@ -325,7 +346,7 @@ void BOPDS_DS::Init()
 {
   Standard_Integer i1, i2, j, aI, aNb, aNbS, aNbE, aNbSx;
   Standard_Integer n1, n2, n3, nV, nW, nE, aNbF;
-  Standard_Real aTol;
+  Standard_Real aTol, aFuzz;
   TopAbs_ShapeEnum aTS;
   TopoDS_Iterator aItS;
   BOPCol_ListIteratorOfListOfInteger aIt1, aIt2, aIt3;
@@ -386,6 +407,7 @@ void BOPDS_DS::Init()
     i1=i2+1;
   }
   //
+  aFuzz = myFuzzyValue / 2.;
   myNbSourceShapes=NbShapes();
   //
   // 2 Bounding Boxes
@@ -403,7 +425,15 @@ void BOPDS_DS::Init()
       Bnd_Box& aBox=aSI.ChangeBox();
       const TopoDS_Vertex& aV=*((TopoDS_Vertex*)&aS);
       const gp_Pnt& aP=BRep_Tool::Pnt(aV);
-      aTol=BRep_Tool::Tolerance(aV);
+      //
+      const Handle(BRep_TVertex)& TV = 
+        *((Handle(BRep_TVertex)*)&aV.TShape());
+      aTol = TV->Tolerance();
+      //
+      myToleranceMap.Bind(j, aTol);
+      aTol += aFuzz;
+      TV->Tolerance(aTol);
+      //
       aBox.SetGap(aTol);
       aBox.Add(aP);
     }
@@ -417,7 +447,14 @@ void BOPDS_DS::Init()
     if (aTS==TopAbs_EDGE) {
       const TopoDS_Shape& aS=aSI.Shape();
       const TopoDS_Edge& aE=*((TopoDS_Edge*)&aS);
-      aTol=BRep_Tool::Tolerance(aE);
+      //
+      const Handle(BRep_TEdge)& TE = 
+        *((Handle(BRep_TEdge)*)&aE.TShape());
+      aTol = TE->Tolerance();
+      //
+      myToleranceMap.Bind(j, aTol);
+      aTol += aFuzz;
+      TE->Tolerance(aTol);
       //
       if (!BRep_Tool::Degenerated(aE)) {
         Standard_Boolean bInf1, bInf2;
@@ -494,7 +531,14 @@ void BOPDS_DS::Init()
     if (aTS==TopAbs_FACE) {
       const TopoDS_Shape& aS=aSI.Shape();
       const TopoDS_Face& aF=*((TopoDS_Face*)&aS);
-      aTol=BRep_Tool::Tolerance(aF);
+      //
+      const Handle(BRep_TFace)& TF = 
+        *((Handle(BRep_TFace)*)&aF.TShape());
+      aTol = TF->Tolerance();
+      //
+      myToleranceMap.Bind(j, aTol);
+      aTol += aFuzz;
+      TF->Tolerance(aTol);
       //
       Bnd_Box& aBox=aSI.ChangeBox();
       BRepBndLib::Add(aS, aBox);
@@ -2017,3 +2061,236 @@ void BOPDS_DS::BuildBndBoxSolid(const Standard_Integer theIndex,
     }
   }
 }
+
+//=======================================================================
+//function : DefaultTolerances
+//purpose  : 
+//=======================================================================
+void BOPDS_DS::SetDefaultTolerances()
+{
+  if (myFuzzyValue == 0.) {
+    return;
+  }
+  //
+  Standard_Boolean bAdd;
+  Standard_Integer i, j, n1, n2, nS, nSOp, nSs;
+  Standard_Integer anIntType, aNbFF, aNbFIn;
+  Standard_Real aTolDef;
+  TopAbs_ShapeEnum aTS1, aTS2;
+  BOPCol_MapOfInteger aMICh;
+  BOPCol_DataMapOfIntegerMapOfInteger aDMI;
+  BOPCol_ListIteratorOfListOfInteger aItLI;
+  BOPDS_MapIteratorMapOfPassKey aItPK;
+  BOPDS_ListIteratorOfListOfPaveBlock aItPB;
+  BOPCol_MapIteratorOfMapOfInteger aItMI;
+  BOPCol_DataMapIteratorOfDataMapOfIntegerReal aItDMIR;
+  //
+  // 1. Collect interfered shapes
+  // 1.1. Interferences V/V, V/E, V/F, E/E and E/F
+  aItPK.Initialize(myInterfTB);
+  for (; aItPK.More(); aItPK.Next()) {
+    const BOPDS_PassKey& aPK = aItPK.Value();
+    aPK.Ids(n1, n2);
+    //
+    const BOPDS_ShapeInfo& aSI1 = ShapeInfo(n1);
+    const BOPDS_ShapeInfo& aSI2 = ShapeInfo(n2);
+    //
+    aTS1 = aSI1.ShapeType();
+    aTS2 = aSI2.ShapeType();
+    //
+    anIntType = BOPDS_Tools::TypeToInteger(aTS1, aTS2);
+    if (anIntType < 5) {
+      AddShapeAndSubShapes(n1, aSI1, aMICh);
+      AddShapeAndSubShapes(n2, aSI2, aMICh);
+    } // if (anIntType < 5) {
+  } // for (; aIt.More(); aIt.Next()) {
+  //
+  // 1.2 FaceInfo information
+  aNbFF = myFaceInfoPool.Extent();
+  for (i = 0; i < aNbFF; ++i) {
+    const BOPDS_FaceInfo& aFI = myFaceInfoPool(i);
+    nS = aFI.Index();
+    if (aMICh.Contains(nS)) {
+      continue;
+    }
+    //
+    aNbFIn = (aFI.PaveBlocksIn().Extent() + 
+              aFI.VerticesIn().Extent() +
+              aFI.PaveBlocksSc().Extent() +
+              aFI.VerticesSc().Extent());
+    if (aNbFIn > 0) {
+      AddShapeAndSubShapes(nS, ShapeInfo(nS), aMICh);
+    } // if (aNbFIn > 0) {
+  } // for (i = 0; i < aNbFF; ++i) {
+  //
+  // 1.3. Empty F/F interferences
+  aNbFF = myInterfFF.Extent();
+  for (i = 0; i < aNbFF; ++i) {
+    BOPDS_InterfFF& aFF = myInterfFF(i);
+    if ((aFF.Curves().Extent() == 0) &&
+        (aFF.Points().Extent() == 0)) {
+      aFF.Indices(n1, n2);
+      for (j = 0; j < 2; ++j) {
+        nS = !j ? n1 : n2;
+        if (aMICh.Contains(nS)) {
+          continue;
+        }
+        nSOp = !j ? n2 : n1;
+        //
+        BOPCol_MapOfInteger aME, aMEOp;
+        //
+        if (aDMI.IsBound(nS)) {
+          aME = aDMI.Find(nS);
+        } else {
+          CollectEdges(*this, nS, aME);
+          aDMI.Bind(nS, aME);
+        }
+        //
+        if (aDMI.IsBound(nSOp)) {
+          aMEOp = aDMI.Find(nSOp);
+        } else {
+          CollectEdges(*this, nSOp, aMEOp);
+          aDMI.Bind(nSOp, aMEOp);
+        }
+        //
+        bAdd = Standard_True;
+        aItMI.Initialize(aME);
+        for (; aItMI.More(); aItMI.Next()) {
+          nSs = aItMI.Value();
+          if (!aMEOp.Contains(nSs)) {
+            bAdd = Standard_False;
+            break;
+          }
+        }
+        //
+        if (bAdd) {
+          AddShapeAndSubShapes(nS, ShapeInfo(nS), aMICh);
+          if (j == 0) {
+            AddShapeAndSubShapes(nSOp, ShapeInfo(nSOp), aMICh);
+          }
+        } // if (bAdd) {
+      } // for (j = 0; j < 2; ++j) {
+    } //if ((aFF.Curves().Extent() == 0) &&
+  } // for (i = 0; i < aNbFF; ++i) {
+  //
+  // 2. Back to default tolerance values
+  aItDMIR.Initialize(myToleranceMap);
+  for (; aItDMIR.More(); aItDMIR.Next()) {
+    i = aItDMIR.Key();
+    //
+    if (aMICh.Contains(i)) {
+      continue;
+    }
+    //
+    const BOPDS_ShapeInfo& aSI = ShapeInfo(i);
+    aTolDef = aItDMIR.Value();
+    aTS1 = aSI.ShapeType();
+    switch (aTS1) {
+      case TopAbs_VERTEX: {
+        const TopoDS_Vertex& aV = *(TopoDS_Vertex*)&aSI.Shape();
+        const Handle(BRep_TVertex)& aTV = 
+          *((Handle(BRep_TVertex)*)&aV.TShape());
+        aTV->Tolerance(aTolDef);
+        break;
+      }
+      case TopAbs_EDGE: {
+        const TopoDS_Edge& aE = *(TopoDS_Edge*)&aSI.Shape();
+        const Handle(BRep_TEdge)& aTE = 
+          *((Handle(BRep_TEdge)*)&aE.TShape());
+        aTE->Tolerance(aTolDef);
+        //
+        const BOPDS_ListOfPaveBlock& aLPB = PaveBlocks(i);
+        aItPB.Initialize(aLPB);
+        for (; aItPB.More(); aItPB.Next()) {
+          const Handle(BOPDS_PaveBlock)& aPB = aItPB.Value();
+          nS = aPB->Edge();
+          const TopoDS_Edge& aEIm = *(TopoDS_Edge*)&Shape(nS);
+          const Handle(BRep_TEdge)& aTEIm = 
+          *((Handle(BRep_TEdge)*)&aEIm.TShape());
+          aTEIm->Tolerance(aTolDef);
+        }
+        break;
+      }
+      case TopAbs_FACE: {
+        const TopoDS_Face& aF = *(TopoDS_Face*)&aSI.Shape();
+        const Handle(BRep_TFace)& aTF = 
+          *((Handle(BRep_TFace)*)&aF.TShape());
+        aTF->Tolerance(aTolDef);
+        break;
+      }
+      default:
+        break;
+    } // switch (aTS1) {
+  } // for (; aItDMIR.More(); aItDMIR.Next()) {
+}
+
+//=======================================================================
+//function : AddShapeAndSubShapes
+//purpose  : 
+//=======================================================================
+void AddShapeAndSubShapes(const Standard_Integer nS,
+                          const BOPDS_ShapeInfo& theSI,
+                          BOPCol_MapOfInteger& theMI)
+{
+  Standard_Integer nSs;
+  if (theMI.Add(nS)) {
+    const BOPCol_ListOfInteger& aLI = theSI.SubShapes();
+    BOPCol_ListIteratorOfListOfInteger aItLI(aLI);
+    for (; aItLI.More(); aItLI.Next()) {
+      nSs = aItLI.Value();
+      theMI.Add(nSs);
+    }
+  }
+}
+
+//=======================================================================
+//function : CollectEdges
+//purpose  : 
+//=======================================================================
+void CollectEdges(const BOPDS_DS& theDS,
+                  const Standard_Integer nF,
+                  BOPCol_MapOfInteger& theMI)
+{
+  Standard_Integer i, j, aNbPB, nE, nEIm;
+  BOPCol_ListIteratorOfListOfInteger aItLI;
+  BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
+  //
+  // ON edges
+  const BOPDS_ShapeInfo& aSI = theDS.ShapeInfo(nF);
+  const BOPCol_ListOfInteger& aLI = aSI.SubShapes();
+  aItLI.Initialize(aLI);
+  for (; aItLI.More(); aItLI.Next()) {
+    nE = aItLI.Value();
+    const BOPDS_ShapeInfo& aSIE = theDS.ShapeInfo(nE);
+    if (aSIE.ShapeType() != TopAbs_EDGE) {
+      continue;
+    }
+    //
+    if (!aSIE.HasReference()) {
+      theMI.Add(nE);
+      continue;
+    }
+    //
+    const BOPDS_ListOfPaveBlock& aLPB = theDS.PaveBlocks(nE);
+    aItLPB.Initialize(aLPB);
+    for (; aItLPB.More(); aItLPB.Next()) {
+      const Handle(BOPDS_PaveBlock)& aPB = aItLPB.Value();
+      nEIm = aPB->Edge();
+      theMI.Add(nEIm);
+    }
+  }
+  // IN and SC edges
+  const BOPDS_FaceInfo& aFI = theDS.FaceInfo(nF);
+  const BOPDS_IndexedMapOfPaveBlock& aMPBIn = aFI.PaveBlocksIn();
+  const BOPDS_IndexedMapOfPaveBlock& aMPBSc = aFI.PaveBlocksSc();
+  //
+  for (i = 0; i < 2; ++i) {
+    const BOPDS_IndexedMapOfPaveBlock& aMPB = !i ? aMPBIn : aMPBSc;
+    aNbPB = aMPB.Extent();
+    for (j = 1; j <= aNbPB; ++j) {
+      const Handle(BOPDS_PaveBlock)& aPB = aMPB(j);
+      nE = aPB->Edge();
+      theMI.Add(nE);
+    }
+  }
+}

src/BOPDS/BOPDS_DS.lxx

@@ -133,3 +133,21 @@ inline const BOPDS_MapOfPassKey& BOPDS_DS::Interferences()const
 {
   return myInterfTB;
 }
+//=======================================================================
+//function : SetFuzzyValue
+//purpose  : 
+//=======================================================================
+inline void BOPDS_DS::SetFuzzyValue(const Standard_Real theFuzz)
+{
+  if (theFuzz > 0.) {
+    myFuzzyValue = theFuzz;
+  }
+}
+//=======================================================================
+//function : FuzzyValue
+//purpose  : 
+//=======================================================================
+inline Standard_Real BOPDS_DS::FuzzyValue() const
+{
+  return myFuzzyValue;
+}

src/BOPTest/BOPTest_BOPCommands.cxx

@@ -24,6 +24,8 @@
 
 #include <TopoDS_Shape.hxx>
 #include <TopoDS_Compound.hxx>
+#include <TopoDS_Iterator.hxx>
+//
 #include <BRep_Builder.hxx>
 
 #include <BOPAlgo_PaveFiller.hxx>
@@ -95,24 +97,26 @@ static Standard_Integer mkvolume   (Draw_Interpretor&, Standard_Integer, const c
   const char* g = "BOP commands";
   // Commands
   
-  theCommands.Add("bop"       , "use bop s1 s2"   , __FILE__, bop, g);
+  theCommands.Add("bop"       , "use bop s1 s2 [tol]" , __FILE__, bop, g);
   theCommands.Add("bopcommon" , "use bopcommon r"     , __FILE__, bopcommon, g);
   theCommands.Add("bopfuse"   , "use bopfuse r"       , __FILE__,bopfuse, g);
-  theCommands.Add("bopcut"    , "use bopcut"      , __FILE__,bopcut, g);
+  theCommands.Add("bopcut"    , "use bopcut r"        , __FILE__,bopcut, g);
-  theCommands.Add("boptuc"    , "use boptuc"      , __FILE__,boptuc, g);
+  theCommands.Add("boptuc"    , "use boptuc r"        , __FILE__,boptuc, g);
-  theCommands.Add("bopsection", "use bopsection"  , __FILE__,bopsection, g);
+  theCommands.Add("bopsection", "use bopsection r"    , __FILE__,bopsection, g);
   //
-  theCommands.Add("bcommon" , "use bcommon r s1 s2" , __FILE__,bcommon, g);
+  theCommands.Add("bcommon" , "use bcommon r s1 s2 [tol]" , __FILE__,bcommon, g);
-  theCommands.Add("bfuse"   , "use bfuse r s1 s2"   , __FILE__,bfuse, g);
+  theCommands.Add("bfuse"   , "use bfuse r s1 s2 [tol]"   , __FILE__,bfuse, g);
-  theCommands.Add("bcut"    , "use bcut r s1 s2"    , __FILE__,bcut, g);
+  theCommands.Add("bcut"    , "use bcut r s1 s2 [tol]"    , __FILE__,bcut, g);
-  theCommands.Add("btuc"    , "use btuc r s1 s2"    , __FILE__,btuc, g);
+  theCommands.Add("btuc"    , "use btuc r s1 s2 [tol]"    , __FILE__,btuc, g);
-  theCommands.Add("bsection", "Use >bsection r s1 s2 [-n2d/-n2d1/-n2d2] [-na]", 
+  theCommands.Add("bsection", "Use >bsection r s1 s2 [-n2d/-n2d1/-n2d2] [-na] [tol]", 
                                                       __FILE__, bsection, g);
   //
   theCommands.Add("bopcurves", "use  bopcurves F1 F2 [-2d]", __FILE__, bopcurves, g);
   theCommands.Add("bopnews", "use  bopnews -v[e,f]"  , __FILE__, bopnews, g);
-  theCommands.Add("bparallelmode", "bparallelmode [1/0] : show / set parallel mode for boolean operations", __FILE__, bparallelmode, g);
+  theCommands.Add("bparallelmode", "bparallelmode [1/0] : show / set parallel mode for boolean operations", 
-  theCommands.Add("mkvolume", "make solids from set of shapes.\nmkvolume r b1 b2 ... [-ni (do not intersect)] [-s (run in non parallel mode)]", __FILE__, mkvolume , g);
+                  __FILE__, bparallelmode, g);
+  theCommands.Add("mkvolume", "make solids from set of shapes.\nmkvolume r b1 b2 ... [-c] [-ni] [-s] [tol]", 
+                  __FILE__, mkvolume , g);
 }
 
 //=======================================================================
@@ -123,11 +127,12 @@ Standard_Integer bop (Draw_Interpretor& di, Standard_Integer n, const char** a)
 {
   char buf[32];
   Standard_Integer iErr;
+  Standard_Real aTol;
   TopoDS_Shape aS1, aS2;
   BOPCol_ListOfShape aLC;
   //
-  if (n!=3) {
+  if (n < 3 || n > 4) {
-    di << " use bop Shape1 Shape2\n";
+    di << " use bop Shape1 Shape2 [tol]\n";
     return 1;
   }
   //
@@ -139,6 +144,11 @@ Standard_Integer bop (Draw_Interpretor& di, Standard_Integer n, const char** a)
     return 1;
   }
   //
+  aTol = 0.;
+  if (n == 4) {
+    aTol = Draw::Atof(a[3]);
+  }
+  //
   aLC.Append(aS1);
   aLC.Append(aS2);
   //
@@ -150,6 +160,7 @@ Standard_Integer bop (Draw_Interpretor& di, Standard_Integer n, const char** a)
   pPF=new BOPAlgo_PaveFiller(aAL);
   //
   pPF->SetArguments(aLC);
+  pPF->SetFuzzyValue(aTol);
   //
   pPF->Perform();
   iErr=pPF->ErrorStatus();
@@ -203,7 +214,7 @@ Standard_Integer bopsmt(Draw_Interpretor& di,
                         const BOPAlgo_Operation aOp)
 {
   if (n<2) {
-    di << " use bopsmt r\n";
+    di << " use bopsmt r\n [tol]";
     return 0;
   }
   //
@@ -349,75 +360,48 @@ Standard_Integer  bsection(Draw_Interpretor& di,
                            Standard_Integer n, 
                            const char** a)
 {
-  const char* usage = " Usage: bsection Result s1 s2 [-n2d/-n2d1/-n2d2] [-na]\n";
+  const char* usage = " Usage: bsection Result s1 s2 [-n2d/-n2d1/-n2d2] [-na] [tol]\n";
   if (n < 4) {
     di << usage;
     return 1;
   }
-
+  //
   TopoDS_Shape aS1 = DBRep::Get(a[2]);
   TopoDS_Shape aS2 = DBRep::Get(a[3]);
-  
+  //
   if (aS1.IsNull() || aS2.IsNull()) {
     di << " Null shapes are not allowed \n";
     return 1;
   }
-
+  //
   Standard_Boolean bApp, bPC1, bPC2;
+  Standard_Integer i;
+  Standard_Real aTol;
   //
   bApp = Standard_True;
   bPC1 = Standard_True;
   bPC2 = Standard_True;
-  
+  aTol = 0.;
-  Standard_Boolean isbadparameter = Standard_False;
+  //
-  
+  for (i = 4; i < n; ++i) {
-  if(n > 4) {
+    if (!strcmp(a[i], "-n2d")) {
-    const char* key1 = a[4];
-    const char* key2 = (n > 5) ? a[5] : NULL;
-    const char* pcurveconf = NULL;
-
-    if (key1 && 
-        (!strcasecmp(key1,"-n2d") || 
-         !strcasecmp(key1,"-n2d1") || 
-         !strcasecmp(key1,"-n2d2"))) {
-      pcurveconf = key1;
-    }
-    else {
-      if (!strcasecmp(key1,"-na")) {
-        bApp = Standard_False;
-      }
-      else {
-        isbadparameter = Standard_True;
-      }
-    }
-    if (key2) {
-      if(!strcasecmp(key2,"-na")) {
-        bApp = Standard_False;
-      }
-      else {
-        isbadparameter = Standard_True;
-      }
-    }
-
-    if(!isbadparameter && pcurveconf) {      
-      if (!strcasecmp(pcurveconf, "-n2d1")) {
-        bPC1 = Standard_False;
-      }
-      else {
-        if (!strcasecmp(pcurveconf, "-n2d2")) {
-          bPC2 = Standard_False;
-        }
-        else {
-          if (!strcasecmp(pcurveconf, "-n2d")) {
       bPC1 = Standard_False;
       bPC2 = Standard_False;
     }
+    else if (!strcmp(a[i], "-n2d1")) {
+      bPC1 = Standard_False;
+    }
+    else if (!strcmp(a[i], "-n2d2")) {
+      bPC2 = Standard_False;
+    }
+    else if (!strcmp(a[i], "-na")) {
+      bApp = Standard_False;
+    }
+    else {
+      aTol = Draw::Atof(a[i]);
     }
   }
-    }
+  //
-  }
-      
-  if(!isbadparameter) {
   Standard_Integer iErr;
   char buf[80];
   //
@@ -425,6 +409,7 @@ Standard_Integer  bsection(Draw_Interpretor& di,
   aSec.Approximation(bApp);
   aSec.ComputePCurveOn1(bPC1);
   aSec.ComputePCurveOn2(bPC2);
+  aSec.SetFuzzyValue(aTol);
   //
   aSec.Build();
   iErr=aSec.ErrorStatus();
@@ -441,12 +426,8 @@ Standard_Integer  bsection(Draw_Interpretor& di,
   }
   DBRep::Set(a[1], aR);
   return 0;
-  }
-  else {
-    di << usage;
-    return 1;
-  }
 }
+
 //=======================================================================
 //function : bsmt
 //purpose  : 
@@ -460,9 +441,10 @@ Standard_Integer bsmt (Draw_Interpretor& di,
   Standard_Integer iErr;
   TopoDS_Shape aS1, aS2;
   BOPCol_ListOfShape aLC;
+  Standard_Real aTol;
   //
-  if (n!=4) {
+  if (n < 4 || n > 5) {
-    di << " use bx r s1 s2\n";
+    di << " use bx r s1 s2 [tol]\n";
     return 1;
   }
   //
@@ -473,6 +455,12 @@ Standard_Integer bsmt (Draw_Interpretor& di,
     di << " null shapes are not allowed \n";
     return 1;
   }
+  //
+  aTol = 0.;
+  if (n == 5) {
+    aTol = Draw::Atof(a[4]);
+  }
+  //
   aLC.Append(aS1);
   aLC.Append(aS2);
   //
@@ -480,6 +468,7 @@ Standard_Integer bsmt (Draw_Interpretor& di,
   BOPAlgo_PaveFiller aPF(aAL);
   //
   aPF.SetArguments(aLC);
+  aPF.SetFuzzyValue(aTol);
   //
   aPF.Perform();
   iErr=aPF.ErrorStatus();
@@ -781,63 +770,81 @@ Standard_Integer bparallelmode(Draw_Interpretor& di, Standard_Integer n, const c
 //=======================================================================
 Standard_Integer mkvolume(Draw_Interpretor& di, Standard_Integer n, const char** a) 
 {
-  const char* usage = "Usage: mkvolume r b1 b2 ... [-ni (do not intersect)] [-s (run in non parallel mode)]\n";
   if (n < 3) {
-    di << usage;
+    di << "Usage: mkvolume r b1 b2 ... [-c] [-ni] [-s] [tol]\n";
+    di << "Options:\n";
+    di << " -c  - use this option if the arguments are compounds\n";
+    di << "       containing shapes that should be interfered;\n";
+    di << " -ni - use this option if the arguments should not be interfered;\n";
+    di << " -s  - use this option to run the operation in non parallel mode;\n";
+    di << " tol - additional tolerance value (real).\n";
     return 1;
   }
   //
-  Standard_Boolean bToIntersect, bRunParallel;
+  const char* usage = "Type mkvolume without arguments for the usage of the command.\n";
-  Standard_Integer i, aNb;
   //
-  aNb = n;
+  Standard_Boolean bToIntersect, bRunParallel, bCompounds;
+  Standard_Integer i;
+  Standard_Real aTol;
+  TopoDS_Shape aS;
+  BOPCol_ListOfShape aLS;
+  //
+  aTol = 0.;
   bToIntersect = Standard_True;
   bRunParallel = Standard_True;
+  bCompounds = Standard_False;
   //
-  if (!strcmp(a[n-1], "-ni")) {
+  for (i = 2; i < n; ++i) {
-    bToIntersect = Standard_False;
-    aNb = n-1;
-  } 
-  else if (!strcmp(a[n-1], "-s")) {
-    bRunParallel = Standard_False;
-    aNb = n-1;
-  }
-  if (n > 3) {
-    if (!strcmp(a[n-2], "-ni")) {
-      bToIntersect = Standard_False;
-      aNb = n-2;
-    } 
-    else if (!strcmp(a[n-2], "-s")) {
-      bRunParallel = Standard_False;
-      aNb = n-2;
-    }
-  }
-  //
-  if (aNb < 3) {
-    di << "no shapes to process.\n";
-    di << usage;
-    return 1;
-  }
-  //
-  BOPCol_ListOfShape aLS;
-  TopoDS_Shape aS;
-  for (i = 2; i < aNb; ++i) {
     aS = DBRep::Get(a[i]);
     if (!aS.IsNull()) {
       aLS.Append(aS);
     }
+    else {
+      if (!strcmp(a[i], "-c")) {
+        bCompounds = Standard_True;
+      }
+      else if (!strcmp(a[i], "-ni")) {
+        bToIntersect = Standard_False;
+      }
+      else if (!strcmp(a[i], "-s")) {
+        bRunParallel = Standard_False;
+      }
+      else {
+        aTol = Draw::Atof(a[i]);
+      }
+    }
   }
   //
   if (aLS.IsEmpty()) {
-    di << "no shapes to process.\n";
+    di << "No shapes to process.\n";
     di << usage;
     return 1;
   }
   //
+  // treat list of arguments for the case of compounds
+  if (bToIntersect && bCompounds) {
+    BOPCol_ListOfShape aLSx;
+    BOPCol_ListIteratorOfListOfShape aItLS;
+    //
+    aItLS.Initialize(aLS);
+    for (; aItLS.More(); aItLS.Next()) {
+      const TopoDS_Shape& aSx = aItLS.Value();
+      TopoDS_Iterator aItS(aSx);
+      for (; aItS.More(); aItS.Next()) {
+        const TopoDS_Shape& aSxS = aItS.Value();
+        aLSx.Append(aSxS);
+      }
+    }
+    //
+    aLS.Clear();
+    aLS.Assign(aLSx);
+  }
+  //
   BOPAlgo_MakerVolume aMV;
   aMV.SetArguments(aLS);
   aMV.SetIntersect(bToIntersect);
   aMV.SetRunParallel(bRunParallel);
+  aMV.SetFuzzyValue(aTol);
   //
   aMV.Perform();
   if (aMV.ErrorStatus()) {
@@ -851,4 +858,3 @@ Standard_Integer mkvolume(Draw_Interpretor& di, Standard_Integer n, const char**
   //
   return 0;
 }
-

src/BOPTest/BOPTest_CheckCommands.cxx

@@ -152,7 +152,7 @@ Standard_Integer bopcheck (Draw_Interpretor& di,
                            const char** a )
 {
   if (n<2) {
-    di << " Use > bopcheck Shape [level of check: 0 - 9] [-t -s]" << "\n";
+    di << " Use > bopcheck Shape [level of check: 0 - 9] [-t -s] [-tol tol]" << "\n";
     di << " The level of check defines "; 
     di << " which interferences will be checked:\n";
     di << " 0 - V/V only\n"; 
@@ -177,29 +177,39 @@ Standard_Integer bopcheck (Draw_Interpretor& di,
   //
   Standard_Boolean bRunParallel, bShowTime;
   Standard_Integer i, aLevel, aNbInterfTypes;
+  Standard_Real aTolerance;
   //
   aNbInterfTypes=BOPDS_DS::NbInterfTypes();
   //
   aLevel=aNbInterfTypes-1;
   //
   if (n>2) {
+    if (a[2][0] != '-') {
       aLevel=Draw::Atoi(a[2]); 
     }
+  }
   //
   if (aLevel < 0 || aLevel > aNbInterfTypes-1) {
     di << "Invalid level";
     return 1;
   }
   //
+  aTolerance = 0;
   bShowTime=Standard_False;
   bRunParallel=Standard_True;
-  for (i=3; i<n; ++i) {
+  for (i=2; i<n; ++i) {
     if (!strcmp(a[i], "-s")) {
       bRunParallel=Standard_False;
     }
     else if (!strcmp(a[i], "-t")) {
       bShowTime=Standard_True;
     }
+    else if (!strcmp(a[i], "-tol")) {
+      if (i+1 < n) {
+        ++i;
+        aTolerance = Draw::Atof(a[i]);
+      }
+    }
   }
   //
   //aLevel = (n==3) ? Draw::Atoi(a[2]) : aNbInterfTypes-1;
@@ -233,6 +243,7 @@ Standard_Integer bopcheck (Draw_Interpretor& di,
   aChecker.SetArguments(aLS);
   aChecker.SetLevelOfCheck(aLevel);
   aChecker.SetRunParallel(bRunParallel);
+  aChecker.SetFuzzyValue(aTolerance);
   //
   aChrono.Start();
   //
@@ -331,7 +342,7 @@ Standard_Integer bopargcheck (Draw_Interpretor& di,
   if (n<2) {
     di << "\n";
     di << " Use >bopargcheck Shape1 [[Shape2] ";
-    di << "[-F/O/C/T/S/U] [/R|F|T|V|E|I|P|C|S]] [#BF]" << "\n" << "\n";
+    di << "[-F/O/C/T/S/U] [/R|F|T|V|E|I|P|C|S]] [#BF] [-tol tol]" << "\n" << "\n";
     di << " -<Boolean Operation>" << "\n";
     di << " F (fuse)" << "\n";
     di << " O (common)" << "\n";
@@ -385,11 +396,19 @@ Standard_Integer bopargcheck (Draw_Interpretor& di,
   Standard_Integer indxAD = 0;
   Standard_Boolean isS2 = Standard_False;
   Standard_Integer indxS2 = 0;
+  Standard_Real aTolerance = 0;
 
   if(n >= 3) {
     Standard_Integer iIndex = 0;
     for(iIndex = 2; iIndex < n; iIndex++) {
-      if(a[iIndex][0] == '-')
+      if(!strcmp(a[iIndex], "-tol"))
+      {
+        if ((iIndex+1) < n) {
+          ++iIndex;
+          aTolerance = Draw::Atof(a[iIndex]);
+        }
+      }
+      else if(a[iIndex][0] == '-')
       {
         isBO = Standard_True;
         indxBO = iIndex;
@@ -432,6 +451,7 @@ Standard_Integer bopargcheck (Draw_Interpretor& di,
   
   // init checker
   BOPAlgo_ArgumentAnalyzer aChecker;
+  aChecker.SetFuzzyValue(aTolerance);
   aChecker.SetShape1(aS1);
 
   // set default options (always tested!) for single and couple shapes
@@ -729,13 +749,13 @@ Standard_Integer bopargcheck (Draw_Interpretor& di,
         if (S1_BadType != 0)
           CString1="YES";
         else
-          CString1="NO";
+          CString1=aChecker.ArgumentTypeMode() ? "NO" : "DISABLED";
         di << "Shapes are not suppotrted by BOP: " << CString1 << "\n";
         Standard_CString CString2;
         if (S1_SelfInt != 0)
           CString2="YES";
         else
-          CString2="NO";
+          CString2=aChecker.SelfInterMode() ? "NO" : "DISABLED";
         di << "Self-Intersections              : " << CString2;
         if(S1_SelfInt != 0)
           di << "  Cases(" << S1_SelfInt << ")  Total shapes(" << S1_SelfIntAll << ")" << "\n";
@@ -745,13 +765,13 @@ Standard_Integer bopargcheck (Draw_Interpretor& di,
         if (S1_OpAb != 0)
           CString13="YES";
         else
-          CString13="NO";
+          CString13=aChecker.SelfInterMode() ? "NO" : "DISABLED";
         di << "Check for SI has been aborted   : " << CString13 << "\n";
         Standard_CString CString3;
         if (S1_SmalE != 0)
           CString3="YES";
         else
-          CString3="NO";
+          CString3=aChecker.SmallEdgeMode() ? "NO" : "DISABLED";
         di << "Too small edges                 : " << CString3;
         if(S1_SmalE != 0)
           di << "  Cases(" << S1_SmalE << ")  Total shapes(" << S1_SmalEAll << ")" << "\n";
@@ -761,7 +781,7 @@ Standard_Integer bopargcheck (Draw_Interpretor& di,
         if (S1_BadF != 0)
           CString4="YES";
         else
-          CString4="NO";
+          CString4=aChecker.RebuildFaceMode() ? "NO" : "DISABLED";
         di << "Bad faces                       : " << CString4;
         if(S1_BadF != 0)
           di << "  Cases(" << S1_BadF << ")  Total shapes(" << S1_BadFAll << ")" << "\n";
@@ -771,7 +791,7 @@ Standard_Integer bopargcheck (Draw_Interpretor& di,
         if (S1_BadV != 0)
           CString5="YES";
         else
-          CString5="NO";
+          CString5=aChecker.MergeVertexMode() ? "NO" : "DISABLED";
         di << "Too close vertices              : " << CString5;
         if(S1_BadV != 0)
           di << "  Cases(" << S1_BadV << ")  Total shapes(" << S1_BadVAll << ")" << "\n";
@@ -781,7 +801,7 @@ Standard_Integer bopargcheck (Draw_Interpretor& di,
         if (S1_BadE != 0)
           CString6="YES";
         else
-          CString6="NO";
+          CString6=aChecker.MergeEdgeMode() ? "NO" : "DISABLED";
         di << "Too close edges                 : " << CString6;
         if(S1_BadE != 0)
           di << "  Cases(" << S1_BadE << ")  Total shapes(" << S1_BadEAll << ")" << "\n";
@@ -791,7 +811,7 @@ Standard_Integer bopargcheck (Draw_Interpretor& di,
         if (S1_C0 != 0)
           CString15="YES";
         else
-          CString15="NO";
+          CString15=aChecker.ContinuityMode() ? "NO" : "DISABLED";
         di << "Shapes with Continuity C0       : " << CString15;
         if(S1_C0 != 0)
           di << "  Cases(" << S1_C0 << ")  Total shapes(" << S1_C0All << ")" << "\n";
@@ -802,7 +822,7 @@ Standard_Integer bopargcheck (Draw_Interpretor& di,
         if (S1_COnS != 0)
           CString17="YES";
         else
-          CString17="NO";
+          CString17=aChecker.CurveOnSurfaceMode() ? "NO" : "DISABLED";
         di << "Invalid Curve on Surface        : " << CString17;
         if(S1_COnS != 0)
           di << "  Cases(" << S1_COnS << ")  Total shapes(" << S1_COnSAll << ")" << "\n";
@@ -819,13 +839,13 @@ Standard_Integer bopargcheck (Draw_Interpretor& di,
         if (S2_BadType != 0)
           CString7="YES";
         else
-          CString7="NO";
+          CString7=aChecker.ArgumentTypeMode() ? "NO" : "DISABLED";
         di << "Shapes are not suppotrted by BOP: " << CString7 << "\n";
         Standard_CString CString8;
         if (S2_SelfInt != 0)
           CString8="YES";
         else
-          CString8="NO";
+          CString8=aChecker.SelfInterMode() ? "NO" : "DISABLED";
         di << "Self-Intersections              : " << CString8;
         if(S2_SelfInt != 0)
           di << "  Cases(" << S2_SelfInt << ")  Total shapes(" << S2_SelfIntAll << ")" << "\n";
@@ -836,13 +856,13 @@ Standard_Integer bopargcheck (Draw_Interpretor& di,
         if (S2_OpAb != 0)
           CString14="YES";
         else
-          CString14="NO";
+          CString14=aChecker.SelfInterMode() ? "NO" : "DISABLED";
         di << "Check for SI has been aborted   : " << CString14 << "\n";
         Standard_CString CString9;
         if (S2_SmalE != 0)
           CString9="YES";
         else
-          CString9="NO";
+          CString9=aChecker.SmallEdgeMode() ? "NO" : "DISABLED";
         di << "Too small edges                 : " << CString9;
         if(S2_SmalE != 0)
           di << "  Cases(" << S2_SmalE << ")  Total shapes(" << S2_SmalEAll << ")" << "\n";
@@ -852,7 +872,7 @@ Standard_Integer bopargcheck (Draw_Interpretor& di,
         if (S2_BadF != 0)
           CString10="YES";
         else
-          CString10="NO";
+          CString10=aChecker.RebuildFaceMode() ? "NO" : "DISABLED";
         di << "Bad faces                       : " << CString10;
         if(S2_BadF != 0)
           di << "  Cases(" << S2_BadF << ")  Total shapes(" << S2_BadFAll << ")" << "\n";
@@ -862,7 +882,7 @@ Standard_Integer bopargcheck (Draw_Interpretor& di,
         if (S2_BadV != 0)
           CString11="YES";
         else
-          CString11="NO";
+          CString11=aChecker.MergeVertexMode() ? "NO" : "DISABLED";
         di << "Too close vertices              : " << CString11;
         if(S2_BadV != 0)
           di << "  Cases(" << S2_BadV << ")  Total shapes(" << S2_BadVAll << ")" << "\n";
@@ -872,7 +892,7 @@ Standard_Integer bopargcheck (Draw_Interpretor& di,
         if (S2_BadE != 0)
           CString12="YES";
         else
-          CString12="NO";
+          CString12=aChecker.MergeEdgeMode() ? "NO" : "DISABLED";
         di << "Too close edges                 : " << CString12;
         if(S2_BadE != 0)
           di << "  Cases(" << S2_BadE << ")  Total shapes(" << S2_BadEAll << ")" << "\n";
@@ -882,7 +902,7 @@ Standard_Integer bopargcheck (Draw_Interpretor& di,
         if (S2_C0 != 0)
           CString16="YES";
         else
-          CString16="NO";
+          CString16=aChecker.ContinuityMode() ? "NO" : "DISABLED";
         di << "Shapes with Continuity C0       : " << CString16;
         if(S2_C0 != 0)
           di << "  Cases(" << S2_C0 << ")  Total shapes(" << S2_C0All << ")" << "\n";
@@ -893,7 +913,7 @@ Standard_Integer bopargcheck (Draw_Interpretor& di,
         if (S2_COnS != 0)
           CString18="YES";
         else
-          CString18="NO";
+          CString18=aChecker.CurveOnSurfaceMode() ? "NO" : "DISABLED";
         di << "Invalid Curve on Surface        : " << CString18;
         if(S2_COnS != 0)
           di << "  Cases(" << S2_COnS << ")  Total shapes(" << S2_COnSAll << ")" << "\n";
@@ -975,7 +995,7 @@ Standard_Integer checkcurveonsurf(Draw_Interpretor& di,
   }
   //
   Standard_Integer nE, nF, anECounter, aFCounter;
-  Standard_Real aT, aTolE, aD, aDMax;
+  Standard_Real aT, aTolE, aDMax;
   TopExp_Explorer aExpF, aExpE;
   char buf[200], aFName[10], anEName[10];
   NCollection_DataMap<TopoDS_Shape, Standard_Real, TopTools_ShapeMapHasher> aDMETol;
@@ -1002,10 +1022,9 @@ Standard_Integer checkcurveonsurf(Draw_Interpretor& di,
       }
       //
       if (aDMETol.IsBound(aE)) {
-        aD = aDMETol.Find(aE);
+        Standard_Real& aD = aDMETol.ChangeFind(aE);
         if (aDMax > aD) {
-          aDMETol.UnBind(aE);
+          aD = aDMax;
-          aDMETol.Bind(aE, aDMax);
         }
       }
       else {

src/BOPTest/BOPTest_PartitionCommands.cxx

@@ -54,9 +54,9 @@ void BOPTest::PartitionCommands(Draw_Interpretor& theCommands)
   // Chapter's name
   const char* g = "Partition commands";
   // Commands  
-  theCommands.Add("bfillds", "use bfillds [-s -t]"  , __FILE__, bfillds, g);
+  theCommands.Add("bfillds", "use bfillds [-s -t] [tol]" , __FILE__, bfillds, g);
   theCommands.Add("bbuild" , "use bbuild r [-s -t]"      , __FILE__, bbuild, g);
-  theCommands.Add("bbop"   , "use bbop r op [-s -t]", __FILE__, bbop, g);
+  theCommands.Add("bbop"   , "use bbop r op [-s -t]"     , __FILE__, bbop, g);
   theCommands.Add("bclear" , "use bclear"                , __FILE__, bclear, g);
 }
 
@@ -84,14 +84,15 @@ Standard_Integer bfillds(Draw_Interpretor& di,
                          Standard_Integer n, 
                          const char** a) 
 { 
-  if (n>3) {
+  if (n > 4) {
-    di << " use bfillds [-s -t]\n";
+    di << " use bfillds [-s -t] [tol]\n";
     return 0;
   }
   //
   char buf[32];
   Standard_Boolean bRunParallel, bShowTime;
   Standard_Integer i, aNbS, iErr;
+  Standard_Real aTol;
   BOPCol_ListIteratorOfListOfShape aIt;
   BOPCol_ListOfShape aLC;
   BOPTime_Chronometer aChrono;
@@ -103,8 +104,9 @@ Standard_Integer bfillds(Draw_Interpretor& di,
     return 0;
   }
   //
-  bShowTime=Standard_False;
+  bShowTime = Standard_False;
-  bRunParallel=Standard_True;
+  bRunParallel = Standard_True;
+  aTol = 0.;
   for (i=1; i<n; ++i) {
     if (!strcmp(a[i], "-s")) {
       bRunParallel=Standard_False;
@@ -112,6 +114,9 @@ Standard_Integer bfillds(Draw_Interpretor& di,
     else if (!strcmp(a[i], "-t")) {
       bShowTime=Standard_True;
     }
+    else {
+      aTol = Draw::Atof(a[i]);
+    }
   }
   //
   BOPCol_ListOfShape& aLT=BOPTest_Objects::Tools();
@@ -132,6 +137,7 @@ Standard_Integer bfillds(Draw_Interpretor& di,
   //
   aPF.SetArguments(aLC);
   aPF.SetRunParallel(bRunParallel);
+  aPF.SetFuzzyValue(aTol);
   //
   aChrono.Start();
   //
@@ -318,6 +324,14 @@ Standard_Integer bbop(Draw_Interpretor& di,
     //
     pBOP->SetOperation(aOp);
   }
+  else {
+    BOPCol_ListOfShape& aLSTools=BOPTest_Objects::Tools();
+    aIt.Initialize(aLSTools);
+    for (; aIt.More(); aIt.Next()) {
+      const TopoDS_Shape& aS=aIt.Value();
+      pBuilder->AddArgument(aS);
+    }
+  }
   //
   pBuilder->SetRunParallel(bRunParallel);
   //

src/BOPTools/BOPTools_AlgoTools_1.cxx

@@ -1191,8 +1191,8 @@ static Standard_Boolean MinComputing( BOPTools_CheckCurveOnSurface& theFunction,
 // Function : ComputeTolerance
 // purpose : 
 //=======================================================================
-Standard_Boolean BOPTools_AlgoTools::
+Standard_Boolean BOPTools_AlgoTools::ComputeTolerance
-          ComputeTolerance( const Handle(Geom_Curve)& theCurve3D,
+  (const Handle(Geom_Curve)& theCurve3D,
    const Handle(Geom2d_Curve)& theCurve2D,
    const Handle(Geom_Surface)& theSurf,
    Standard_Real& theMaxDist,

src/BRepAlgoAPI/BRepAlgoAPI.cdl

@@ -14,12 +14,46 @@
 -- Alternatively, this file may be used under the terms of Open CASCADE
 -- commercial license or contractual agreement.
 
--- modified by  Peter KURNEV Tue Mar  5 14:01:51 2002
-
-
-
 package BRepAlgoAPI 
         
+uses  
+   TopTools,
+   TopoDS,
+   gp,
+   Geom,
+   Geom2d,
+   Message,
+   BOPCol,
+   BOPAlgo,
+   BOPDS,
+   BRepBuilderAPI
+is
+
+    deferred class BooleanOperation;
+    class Fuse;
+    class Common;
+    class Cut;
+    class Section;
+    class Check;
+    ---Purpose: Check shapes on validity for boolean
+    --- operation.
+
+    deferred class Algo;
+    deferred class BuilderAlgo;
+
+    DumpOper( theFilePath : CString from Standard;
+              theShape1 : Shape from TopoDS;
+              theShape2 : Shape from TopoDS;
+              theResult : Shape from TopoDS;
+              theOperation : Operation from BOPAlgo;
+              isNonValidArgs : Boolean from Standard );
+        ---Purpose: Dump arguments and result of boolean operation in the file specified by path.
+        ---Level: Public
+
+end BRepAlgoAPI;
+
+
+
      ---Purpose:  The BRepAlgoAPI package provides a full range of
      -- services to perform Boolean Operations on arguments (shapes
      -- that are defined in the BRep data structures). The
@@ -85,40 +119,3 @@ package BRepAlgoAPI
      -- each other. The same condition is true for SHELLs or FACEs,
      -- WIREs or EDGEs.
      -- It does not support Boolean Operations for COMPSOLID type of shape.
-        
-uses  
-   TopTools, 
-   TopoDS, 
-   gp,
-   Geom,
-   Geom2d, 
-   BOPAlgo, 
-   BOPDS,
-   BRepBuilderAPI   
-is
-	     
-    deferred class BooleanOperation; 
-
-    class Fuse;                    
-
-    class Common;                         
-
-    class Cut;                           
-
-    class Section;                       
-
-    class Check;
-        ---Purpose: Check shapes on validity for boolean
-        --- operation.
- 
-    DumpOper( theFilePath : CString from Standard;
-              theShape1 : Shape from TopoDS;
-              theShape2 : Shape from TopoDS;
-              theResult : Shape from TopoDS;
-              theOperation : Operation from BOPAlgo;
-              isNonValidArgs : Boolean from Standard );
-        ---Purpose: Dump arguments and result of boolean operation in the file specified by path.
-        ---Level: Public
-
-end BRepAlgoAPI;
-

src/BRepAlgoAPI/BRepAlgoAPI_Algo.cdl

@@ -0,0 +1,75 @@
+-- Created by: Peter KURNEV
+-- Copyright (c) 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.
+
+deferred class Algo from BRepAlgoAPI
+        inherits MakeShape from BRepBuilderAPI
+ ---Purpose: provides the root interface for algorithms
+
+uses
+    BaseAllocator from BOPCol,
+    ProgressIndicator from Message,
+    Shape from TopoDS
+
+--raises
+
+is
+    Initialize 
+        returns Algo from BRepAlgoAPI;
+    ---C++: alias "Standard_EXPORT virtual ~BRepAlgoAPI_Algo();"
+
+    Initialize (theAllocator: BaseAllocator from BOPCol) 
+        returns Algo from BRepAlgoAPI;
+
+    ErrorStatus (me)
+        returns Integer from Standard; 
+
+    WarningStatus (me)
+        returns Integer from Standard;
+
+    Allocator(me)
+        returns BaseAllocator from BOPCol;
+    ---C++: return const &
+
+    SetRunParallel(me:out;
+            theFlag:Boolean from Standard);
+    ---Purpose: Set the flag of parallel processing
+    -- if <theFlag> is true  the parallel processing is switched on
+    -- if <theFlag> is false the parallel processing is switched off
+    --
+    RunParallel(me)
+        returns Boolean from Standard;
+    ---Purpose: Returns the flag of parallel processing
+
+    SetProgressIndicator(me:out;
+            theObj: ProgressIndicator from Message);
+    ---Purpose: Set the Progress Indicator object.
+
+    UserBreak(me)
+        is protected;
+    ---Purpose: Breaks the execution if the break signal
+    -- is indicated by myProgressIndicator.
+
+    Shape(me)
+        returns Shape from TopoDS
+        is redefined;
+    ---C++: return const &
+
+fields 
+    myAllocator     : BaseAllocator from BOPCol is protected;
+    myErrorStatus   : Integer from Standard is protected;
+    myWarningStatus : Integer from Standard is protected;
+    myRunParallel   : Boolean from Standard is protected;
+    myProgressIndicator : ProgressIndicator from Message is protected;
+
+end Algo;

src/BRepAlgoAPI/BRepAlgoAPI_Algo.cxx

@@ -0,0 +1,126 @@
+// Created by: Peter KURNEV
+// Copyright (c) 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 <BRepAlgoAPI_Algo.ixx>
+
+#include <Standard_NotImplemented.hxx>
+#include <NCollection_BaseAllocator.hxx>
+
+//=======================================================================
+// function: 
+// purpose: 
+//=======================================================================
+BRepAlgoAPI_Algo::BRepAlgoAPI_Algo()
+:
+  myAllocator(NCollection_BaseAllocator::CommonBaseAllocator()),
+  myErrorStatus(1),
+  myWarningStatus(0),
+  myRunParallel(Standard_False)
+{}
+//=======================================================================
+// function: 
+// purpose: 
+//=======================================================================
+BRepAlgoAPI_Algo::BRepAlgoAPI_Algo
+  (const Handle(NCollection_BaseAllocator)& theAllocator)
+:
+  myAllocator(theAllocator),
+  myErrorStatus(1),
+  myWarningStatus(0),
+  myRunParallel(Standard_False)
+{}
+
+//=======================================================================
+// function: ~
+// purpose: 
+//=======================================================================
+BRepAlgoAPI_Algo::~BRepAlgoAPI_Algo()
+{
+}
+//=======================================================================
+//function : Allocator
+//purpose  : 
+//=======================================================================
+const Handle(NCollection_BaseAllocator)& BRepAlgoAPI_Algo::Allocator()const
+{
+  return myAllocator;
+}
+//=======================================================================
+// function: ErrorStatus
+// purpose: 
+//=======================================================================
+Standard_Integer BRepAlgoAPI_Algo::ErrorStatus()const
+{
+  return myErrorStatus;
+}
+//=======================================================================
+// function: WarningStatus
+// purpose: 
+//=======================================================================
+Standard_Integer BRepAlgoAPI_Algo::WarningStatus()const
+{
+  return myWarningStatus;
+}
+//=======================================================================
+//function : SetRunParallel
+//purpose  : 
+//=======================================================================
+void BRepAlgoAPI_Algo::SetRunParallel(const Standard_Boolean theFlag)
+{
+  myRunParallel=theFlag;
+}
+//=======================================================================
+//function : RunParallel
+//purpose  : 
+//=======================================================================
+Standard_Boolean BRepAlgoAPI_Algo::RunParallel()const
+{
+  return myRunParallel;
+}
+//=======================================================================
+//function : SetProgressIndicator
+//purpose  : 
+//=======================================================================
+void BRepAlgoAPI_Algo::SetProgressIndicator
+  (const Handle(Message_ProgressIndicator)& theObj)
+{
+  if (!theObj.IsNull()) {
+    myProgressIndicator=theObj;
+  }
+}
+//=======================================================================
+//function : UserBreak
+//purpose  : 
+//=======================================================================
+void BRepAlgoAPI_Algo::UserBreak() const
+{
+  if (myProgressIndicator.IsNull()) {
+    return;
+  }
+  if (myProgressIndicator->UserBreak()) {
+    Standard_NotImplemented::Raise("");
+  }
+} 
+//=======================================================================
+//function : Shape
+//purpose  : 
+//=======================================================================
+const TopoDS_Shape& BRepAlgoAPI_Algo::Shape() const
+{
+  return myShape;
+}
+
+//  myErrorStatus
+//
+// 1 - object is just initialized

src/BRepAlgoAPI/BRepAlgoAPI_BooleanOperation.cdl

@@ -14,12 +14,8 @@
 -- Alternatively, this file may be used under the terms of Open CASCADE
 -- commercial license or contractual agreement.
 
--- modified by  Peter KURNEV   Tue Mar  5 14:01:51 2002
--- modified by  Eugeny MALTCHIKOV Wed Jul 04 11:13:01 2012 
-
-
 deferred class BooleanOperation from BRepAlgoAPI
-    inherits MakeShape from BRepBuilderAPI
+    inherits BuilderAlgo from BRepAlgoAPI
 
      ---Purpose: The abstract class BooleanOperation is the root
      -- class of Boolean Operations (see Overview).
@@ -34,29 +30,48 @@ deferred class BooleanOperation from BRepAlgoAPI
 uses
 
     Shape from TopoDS, 
+    DataMapOfShapeShape from TopTools, 
     ListOfShape from TopTools,
     Operation   from BOPAlgo,
-    Builder    from BOPAlgo,
+    PaveFiller from BOPAlgo
-    PBuilder    from BOPAlgo,
-    PaveFiller  from BOPAlgo, 
-    PPaveFiller from BOPAlgo,
-    DataMapOfIntegerListOfShape  from  TopTools, 
-    DataMapOfIntegerShape  from  TopTools,
-    DataMapOfShapeShape  from  TopTools 
     
 is 
+    Initialize
+        returns BooleanOperation from BRepAlgoAPI; 
 
     Initialize (S1 :Shape from TopoDS;  
                 S2 :Shape from TopoDS; 
                 anOperation:Operation from BOPAlgo); 
+    
     ---Purpose: Prepares the operations for S1 and S2.
      
     Initialize (S1   :Shape from TopoDS; 
                 S2   :Shape from TopoDS; 
-            aDSF :PaveFiller from BOPAlgo;               
+                aPF  :PaveFiller from BOPAlgo;               
                 anOperation:Operation from BOPAlgo); 
      ---Purpose: Prepares the operations for S1 and S2.
 
+   
+    
+    SetShape1(me:out; 
+            S:Shape from TopoDS); 
+
+    SetShape2(me:out; 
+            S:Shape from TopoDS);  
+ 
+    Shape1(me)   
+        returns Shape from TopoDS 
+        is static; 
+    ---Purpose: Returns the first shape involved in this Boolean operation.
+    ---C++: return const &
+    ---C++: alias "Standard_EXPORT virtual ~BRepAlgoAPI_BooleanOperation();" 
+
+    Shape2(me)  
+        returns Shape from TopoDS 
+        is static;
+    ---Purpose: Returns the second shape involved in this Boolean operation.
+    ---C++: return const &
+       
     SetOperation (me:out; 
             anOp:  Operation from BOPAlgo); 
     ---Purpose:  Sets the type of Boolean operation to perform      
@@ -67,6 +82,9 @@ is
     ---                    BOPAlgo_CUT21 
     ---  
      
+    Operation  (me) 
+        returns Operation from BOPAlgo;
+    ---Purpose: Returns the type of Boolean Operation that has been performed.  
    
     Build  (me:out) 
         is redefined virtual; 
@@ -74,21 +92,8 @@ is
     -- -      Filling interference Data Structure (if it is necessary)
     -- -      Building the result of the operation. 
      
-    Shape1(me)   
+    BuilderCanWork(me)  
-        returns Shape from TopoDS 
+        returns Boolean from Standard;  
-        is static;
-    ---Purpose: Returns the first shape involved in this Boolean operation.
-    ---C++: return const &
-
-    Shape2(me)  
-        returns Shape from TopoDS 
-        is static;
-    ---Purpose: Returns the second shape involved in this Boolean operation.
-    ---C++: return const &
-     
-    Operation  (me) 
-        returns Operation from BOPAlgo;
-    ---Purpose: Returns the type of Boolean Operation that has been performed.  
  
     FuseEdges(me)   
         returns Boolean from Standard;
@@ -97,26 +102,12 @@ is
     RefineEdges(me:out);
     ---Purpose: Fuse C1 edges
      
-    PrepareFiller(me:out) 
+     SectionEdges (me:  in  out)  
-        returns Boolean from Standard 
+        returns ListOfShape from TopTools;    
-        is protected;   
+    --- Purpose: Returns a list of section edges.
-  
+    -- The edges represent the result of intersection between arguments of
-    ---Category: Querying
+    -- Boolean Operation. They are computed during operation execution.
-    BuilderCanWork(me)  
+    ---C++:  return const &  
-        returns Boolean from Standard;
-
-    ErrorStatus(me) 
-        returns Integer from Standard; 
-    ---Purpose:  Returns the error status of operation.  
-    --- 0 - Ok
-    --- 1 - The Object is created but Nothing is Done 
-    --- 2 - Null source shapes is not allowed
-    --- 3 - Check types of the arguments
-    --- 4 - Can not allocate memory for the DSFiller
-    --- 5 - The Builder can not work with such types of arguments
-    --- 6 - Unknown operation is not allowed 
-    --- 7 - Can not allocate memory for the Builder
-    --  > 100 - See the Builder's  ErrorStatus
          
     Modified (me: in out;  
             aS : Shape from TopoDS) 
@@ -158,20 +149,17 @@ is
     ---Purpose: Returns true if there is at least one deleted shape.
     ---         For use in BRepNaming.
  
-    Destroy (me: in out); 
+    --  
-    ---C++: alias "Standard_EXPORT virtual ~BRepAlgoAPI_BooleanOperation(){Destroy();}" 
+    -- protected 
-     
+    --    
-    SectionEdges (me:  in  out)  
+    PrepareFiller(me:out) 
-        returns ListOfShape from TopTools;    
+        returns Boolean from Standard 
-    --- Purpose: Returns a list of section edges.
+        is protected;      
-    -- The edges represent the result of intersection between arguments of
-    -- Boolean Operation. They are computed during operation execution.
-    ---C++:  return const &  
        
     RefinedList (me:  in  out;  
             theL : ListOfShape from TopTools)  
         returns ListOfShape from TopTools
-        is private;
+        is protected;
     ---Purpose: Returns the list  of shapes generated from the shape <S>.
     ---         For use in BRepNaming.
     ---C++:  return const &
@@ -179,12 +167,10 @@ is
 fields
     myS1       : Shape from TopoDS        is protected;
     myS2       : Shape from TopoDS        is protected;
+    myOperation: Operation from BOPAlgo   is protected;   
+    --
+    myEntryType: Integer from Standard is protected;    
     myBuilderCanWork : Boolean from Standard is protected;  
-    myOperation      : Operation from BOPAlgo   is protected;  
-    myErrorStatus    : Integer from Standard    is protected;        
-    myDSFiller       : PPaveFiller from BOPAlgo is protected;  
-    myBuilder        : PBuilder from BOPAlgo    is protected;  
-    myEntryType      : Integer     from Standard;   
      
     --    for  edge  refiner
     myFuseEdges      : Boolean from Standard ; 

src/BRepAlgoAPI/BRepAlgoAPI_BooleanOperation.cxx

@@ -16,21 +16,42 @@
 
 #include <BRepAlgoAPI_BooleanOperation.ixx>
 
-#include <BRepAlgoAPI.hxx>
-#include <BRepAlgoAPI_Check.hxx>
-
-#include <BRepLib_FuseEdges.hxx>
 #include <TopExp.hxx>
-#include <TopTools_MapOfShape.hxx>
-#include <TopTools_ListIteratorOfListOfShape.hxx>
 
+#include <TopTools_IndexedMapOfShape.hxx>
+#include <TopTools_DataMapOfIntegerListOfShape.hxx>
+#include <TopTools_DataMapOfIntegerShape.hxx>
+#include <TopTools_ListIteratorOfListOfShape.hxx>
+#include <TopTools_MapOfShape.hxx>
+
+#include <BRepAlgoAPI_Check.hxx>
+#include <BRepAlgoAPI.hxx>
+#include <BRepLib_FuseEdges.hxx>
+
+#include <BOPDS_PDS.hxx>
 #include <BOPDS_DS.hxx>
+#include <BOPDS_VectorOfCurve.hxx>
+#include <BOPDS_Interf.hxx>
+#include <BOPDS_Curve.hxx>
+#include <BOPDS_ListOfPaveBlock.hxx>
 
 #include <BOPAlgo_PaveFiller.hxx>
 #include <BOPAlgo_BOP.hxx>
 #include <BOPAlgo_Section.hxx>
 
-
+//=======================================================================
+//function : BRepAlgoAPI_BooleanOperation
+//purpose  : 
+//=======================================================================
+BRepAlgoAPI_BooleanOperation::BRepAlgoAPI_BooleanOperation()
+:
+  BRepAlgoAPI_BuilderAlgo(), 
+  myOperation(BOPAlgo_UNKNOWN),
+  myEntryType(1),
+  myBuilderCanWork(Standard_False),
+  myFuseEdges(Standard_False)
+{
+}
 //=======================================================================
 //function : BRepAlgoAPI_BooleanOperation
 //purpose  : 
@@ -40,14 +61,12 @@ BRepAlgoAPI_BooleanOperation::BRepAlgoAPI_BooleanOperation
    const TopoDS_Shape& aS2,
    const BOPAlgo_Operation anOp)
 : 
+  BRepAlgoAPI_BuilderAlgo(),
   myS1(aS1),
   myS2(aS2),
-  myBuilderCanWork(Standard_False),
   myOperation(anOp),
-  myErrorStatus(1),
-  myDSFiller(NULL),
-  myBuilder(NULL),
   myEntryType(1),
+  myBuilderCanWork(Standard_False),
   myFuseEdges(Standard_False)
 {
 }
@@ -55,40 +74,36 @@ BRepAlgoAPI_BooleanOperation::BRepAlgoAPI_BooleanOperation
 //function : BRepAlgoAPI_BooleanOperation
 //purpose  : 
 //=======================================================================
-  BRepAlgoAPI_BooleanOperation::BRepAlgoAPI_BooleanOperation(const TopoDS_Shape& aS1, 
+BRepAlgoAPI_BooleanOperation::BRepAlgoAPI_BooleanOperation
+  (const TopoDS_Shape& aS1, 
    const TopoDS_Shape& aS2,
-                                                             const BOPAlgo_PaveFiller& aDSFiller,
+   const BOPAlgo_PaveFiller& aPF,
    const BOPAlgo_Operation anOp)
 : 
+  BRepAlgoAPI_BuilderAlgo(),
   myS1(aS1),
   myS2(aS2),
-  myBuilderCanWork(Standard_False),
   myOperation(anOp),
-  myErrorStatus(1),
-  myDSFiller(NULL),
-  myBuilder(NULL),
   myEntryType(0),
+  myBuilderCanWork(Standard_False),
   myFuseEdges(Standard_False)
 {
-  if ((Standard_Address) &aDSFiller!=NULL) {
+  myDSFiller=(BOPAlgo_PaveFiller*)&aPF;
-    myDSFiller=(BOPAlgo_PaveFiller*)&aDSFiller;
-  }
 }
 //=======================================================================
-//function : Destroy
+//function : ~
 //purpose  : 
 //=======================================================================
-  void BRepAlgoAPI_BooleanOperation::Destroy()
+BRepAlgoAPI_BooleanOperation::~BRepAlgoAPI_BooleanOperation()
 {
-  if (myBuilder!=NULL) {
+  if (myBuilder) {
     delete myBuilder;
     myBuilder=NULL;
   }
-  if (myDSFiller!=NULL && myEntryType) {
+  if (myDSFiller && myEntryType) {
     delete myDSFiller;
     myDSFiller=NULL;
   }
-
   //
   myModifFaces.Clear();
   myEdgeMap.Clear();
@@ -97,7 +112,8 @@ BRepAlgoAPI_BooleanOperation::BRepAlgoAPI_BooleanOperation
 //function : SetOperation
 //purpose  : 
 //=======================================================================
-  void BRepAlgoAPI_BooleanOperation::SetOperation (const BOPAlgo_Operation anOp)
+void BRepAlgoAPI_BooleanOperation::SetOperation 
+  (const BOPAlgo_Operation anOp)
 {
   myOperation=anOp;
 }
@@ -105,38 +121,42 @@ BRepAlgoAPI_BooleanOperation::BRepAlgoAPI_BooleanOperation
 //function : Operation
 //purpose  : 
 //=======================================================================
-  BOPAlgo_Operation BRepAlgoAPI_BooleanOperation::Operation ()const
+BOPAlgo_Operation BRepAlgoAPI_BooleanOperation::Operation ()const
 {
   return myOperation;
 }
-
 //=======================================================================
-//function : FuseEdges
+//function : SetShape1
 //purpose  : 
 //=======================================================================
-  Standard_Boolean BRepAlgoAPI_BooleanOperation::FuseEdges ()const
+void  BRepAlgoAPI_BooleanOperation::SetShape1(const TopoDS_Shape& aS) 
 {
-  return myFuseEdges;
+  myS1=aS;
+} 
+//=======================================================================
+//function : SetShape2
+//purpose  : 
+//=======================================================================
+void  BRepAlgoAPI_BooleanOperation::SetShape2(const TopoDS_Shape& aS) 
+{
+  myS2=aS;
 } 
-
 //=======================================================================
 //function : Shape1
 //purpose  : 
 //=======================================================================
-  const TopoDS_Shape& BRepAlgoAPI_BooleanOperation::Shape1() const 
+const TopoDS_Shape& BRepAlgoAPI_BooleanOperation::Shape1() const 
 {
   return myS1;
 }
-
 //=======================================================================
 //function : Shape2
 //purpose  : 
 //=======================================================================
-  const TopoDS_Shape& BRepAlgoAPI_BooleanOperation::Shape2() const 
+const TopoDS_Shape& BRepAlgoAPI_BooleanOperation::Shape2() const 
 {
   return myS2;
 }
-
 //=======================================================================
 //function : BuilderCanWork
 //purpose  : 
@@ -146,54 +166,18 @@ BRepAlgoAPI_BooleanOperation::BRepAlgoAPI_BooleanOperation
   return myBuilderCanWork;
 }
 //=======================================================================
-//function : ErrorStatus
+//function : FuseEdges
 //purpose  : 
 //=======================================================================
-  Standard_Integer BRepAlgoAPI_BooleanOperation::ErrorStatus()const
+Standard_Boolean BRepAlgoAPI_BooleanOperation::FuseEdges ()const
 {
-  return myErrorStatus;    
+  return myFuseEdges;
 }
-//=======================================================================
-//function : Modified
-//purpose  : 
-//=======================================================================
-const TopTools_ListOfShape& BRepAlgoAPI_BooleanOperation::Modified(const TopoDS_Shape& aS) 
-{
-  if (myBuilder==NULL) {
-    myGenerated.Clear();
-    return myGenerated;
-  }
-  else {
-    myGenerated = myBuilder->Modified(aS);
-
-    if(myFuseEdges) {
-      TopTools_ListOfShape theLS;
-      theLS.Assign(myGenerated);
-      //
-      RefinedList(theLS);
-    }
-    return myGenerated;
-  }
-}
-
-//=======================================================================
-//function : IsDeleted
-//purpose  : 
-//=======================================================================
-  Standard_Boolean BRepAlgoAPI_BooleanOperation::IsDeleted(const TopoDS_Shape& aS) 
-{
-  Standard_Boolean bDeleted = Standard_True; 
-  if (myBuilder != NULL) {
-    bDeleted=myBuilder->IsDeleted(aS);
-  }
-  return bDeleted; 
-}
-
 //=======================================================================
 //function : PrepareFiller
 //purpose  : 
 //=======================================================================
-  Standard_Boolean BRepAlgoAPI_BooleanOperation::PrepareFiller()
+Standard_Boolean BRepAlgoAPI_BooleanOperation::PrepareFiller()
 {
   Standard_Boolean bIsNewFiller=Standard_False;
   myErrorStatus=1;
@@ -223,6 +207,9 @@ const TopTools_ListOfShape& BRepAlgoAPI_BooleanOperation::Modified(const TopoDS_
     aLS.Append(myS2);
     //
     myDSFiller->SetArguments(aLS);
+    myDSFiller->SetRunParallel(myRunParallel);
+    myDSFiller->SetProgressIndicator(myProgressIndicator);
+    myDSFiller->SetFuzzyValue(myFuzzyValue);
   }
 
   return bIsNewFiller;
@@ -231,7 +218,7 @@ const TopTools_ListOfShape& BRepAlgoAPI_BooleanOperation::Modified(const TopoDS_
 //function : Build
 //purpose  : 
 //=======================================================================
-  void BRepAlgoAPI_BooleanOperation::Build()
+void BRepAlgoAPI_BooleanOperation::Build()
 {
   Standard_Boolean bIsNewFiller;
   Standard_Integer iErr;
@@ -288,6 +275,8 @@ const TopTools_ListOfShape& BRepAlgoAPI_BooleanOperation::Modified(const TopoDS_
     pBOP->SetOperation(myOperation);
   }
   //
+  myBuilder->SetRunParallel(myRunParallel);
+  myBuilder->SetProgressIndicator(myProgressIndicator);
   myBuilder->PerformWithFiller(*myDSFiller);
   iErr = myBuilder->ErrorStatus();
   if (!iErr) {
@@ -316,7 +305,94 @@ const TopTools_ListOfShape& BRepAlgoAPI_BooleanOperation::Modified(const TopoDS_
   }
 }
 
-//
+//=======================================================================
+//function : RefineEdges
+//purpose  : 
+//=======================================================================
+void BRepAlgoAPI_BooleanOperation::RefineEdges ()
+{
+  if(myFuseEdges) return; //Edges have been refined yet
+
+  BRepLib_FuseEdges FE(myShape);
+  FE.SetConcatBSpl(Standard_True);
+
+  // avoid fusing old edges
+  TopTools_IndexedMapOfShape mapOldEdges;
+  TopExp::MapShapes (myS1, TopAbs_EDGE, mapOldEdges);
+  TopExp::MapShapes (myS2, TopAbs_EDGE, mapOldEdges);
+  FE.AvoidEdges (mapOldEdges);
+
+  // Get List of edges that have been fused
+  myFuseEdges = Standard_False;
+  myModifFaces.Clear();
+  myEdgeMap.Clear();
+  TopTools_DataMapOfIntegerListOfShape aFusedEdges;
+
+  FE.Edges(aFusedEdges);
+  Standard_Integer nle = aFusedEdges.Extent();
+  if (nle != 0) {
+    FE.Perform();
+    myShape = FE.Shape();
+
+    TopTools_DataMapOfIntegerShape aResultEdges;
+
+    FE.ResultEdges(aResultEdges);
+    FE.Faces(myModifFaces);
+    myFuseEdges = Standard_True;
+    
+    Standard_Integer i;
+    for(i = 1; i <= nle; ++i) {
+      const TopoDS_Shape& aNewE = aResultEdges(i);
+      const TopTools_ListOfShape& aListOfOldEdges = aFusedEdges(i);
+      TopTools_ListIteratorOfListOfShape anIter(aListOfOldEdges);
+      for(; anIter.More(); anIter.Next()) {
+        myEdgeMap.Bind(anIter.Value(), aNewE);
+      }
+    }
+  }
+}
+//=======================================================================
+//function : RefinedList
+//purpose  : 
+//=======================================================================
+const TopTools_ListOfShape& BRepAlgoAPI_BooleanOperation::RefinedList
+  (const TopTools_ListOfShape& theL) 
+{
+  myGenerated.Clear();
+  TopTools_MapOfShape aMap;
+
+  TopTools_ListIteratorOfListOfShape anIter(theL);
+
+  for(; anIter.More(); anIter.Next()) {
+    const TopoDS_Shape& anS = anIter.Value();
+
+    if(anS.ShapeType() == TopAbs_EDGE) {
+      if(myEdgeMap.IsBound(anS)) {
+        const TopoDS_Shape& aNewEdge = myEdgeMap.Find(anS);
+        if(aMap.Add(aNewEdge)) {
+          myGenerated.Append(aNewEdge);
+        }
+      }
+      else {
+        myGenerated.Append(anS);
+      }
+    }
+    else if (anS.ShapeType() == TopAbs_FACE) {
+      if(myModifFaces.IsBound(anS)) {
+        myGenerated.Append(myModifFaces.Find(anS));
+      }
+      else {
+        myGenerated.Append(anS);
+      }
+    }
+    else {
+      myGenerated.Append(anS);
+    }
+  }
+
+  return myGenerated;
+
+}
 //=======================================================================
 //function : SectionEdges
 //purpose  : 
@@ -364,12 +440,12 @@ const  TopTools_ListOfShape& BRepAlgoAPI_BooleanOperation::SectionEdges()
   //
   return myGenerated;
 }
-
+//=======================================================================
-// ================================================================================================
+//function : Generated
-// function: Generated
+//purpose  : 
-// purpose:
+//=======================================================================
-// ================================================================================================
+const TopTools_ListOfShape& BRepAlgoAPI_BooleanOperation::Generated
-const TopTools_ListOfShape& BRepAlgoAPI_BooleanOperation::Generated(const TopoDS_Shape& S) 
+  (const TopoDS_Shape& S) 
 {
   if (myBuilder==NULL) {
     myGenerated.Clear();
@@ -384,10 +460,46 @@ const TopTools_ListOfShape& BRepAlgoAPI_BooleanOperation::Generated(const TopoDS
   return myBuilder->Generated(S);
 }
 
-// ================================================================================================
+//=======================================================================
-// function: HasModified
+//function : Modified
-// purpose:
+//purpose  : 
-// ================================================================================================
+//=======================================================================
+const TopTools_ListOfShape& BRepAlgoAPI_BooleanOperation::Modified
+  (const TopoDS_Shape& aS) 
+{
+  if (myBuilder==NULL) {
+    myGenerated.Clear();
+    return myGenerated;
+  }
+  else {
+    myGenerated = myBuilder->Modified(aS);
+
+    if(myFuseEdges) {
+      TopTools_ListOfShape theLS;
+      theLS.Assign(myGenerated);
+      //
+      RefinedList(theLS);
+    }
+    return myGenerated;
+  }
+}
+//=======================================================================
+//function : IsDeleted
+//purpose  : 
+//=======================================================================
+Standard_Boolean BRepAlgoAPI_BooleanOperation::IsDeleted
+  (const TopoDS_Shape& aS) 
+{
+  Standard_Boolean bDeleted = Standard_True; 
+  if (myBuilder != NULL) {
+    bDeleted=myBuilder->IsDeleted(aS);
+  }
+  return bDeleted; 
+}
+//=======================================================================
+//function : HasModified
+//purpose  : 
+//=======================================================================
 Standard_Boolean BRepAlgoAPI_BooleanOperation::HasModified() const
 {
   if (myBuilder==NULL) {
@@ -395,11 +507,10 @@ Standard_Boolean BRepAlgoAPI_BooleanOperation::HasModified() const
   }
   return myBuilder->HasModified();
 }
-
+//=======================================================================
-// ================================================================================================
+//function : HasGenerated
-// function: HasGenerated
+//purpose  : 
-// purpose:
+//=======================================================================
-// ================================================================================================
 Standard_Boolean BRepAlgoAPI_BooleanOperation::HasGenerated() const
 {
   if (myBuilder==NULL) {
@@ -407,11 +518,10 @@ Standard_Boolean BRepAlgoAPI_BooleanOperation::HasGenerated() const
   }
   return myBuilder->HasGenerated();
 }
-
+//=======================================================================
-// ================================================================================================
+//function : HasDeleted
-// function: HasDeleted
+//purpose  : 
-// purpose:
+//=======================================================================
-// ================================================================================================
 Standard_Boolean BRepAlgoAPI_BooleanOperation::HasDeleted() const
 {
   if (myBuilder==NULL) {
@@ -419,93 +529,3 @@ Standard_Boolean BRepAlgoAPI_BooleanOperation::HasDeleted() const
   }
   return myBuilder->HasDeleted();
 }
-//=======================================================================
-//function : RefineEdges
-//purpose  : 
-//=======================================================================
-
-  void BRepAlgoAPI_BooleanOperation::RefineEdges ()
-{
-  if(myFuseEdges) return; //Edges have been refined yet
-
-  BRepLib_FuseEdges FE(myShape);
-  FE.SetConcatBSpl(Standard_True);
-
-  // avoid fusing old edges
-  TopTools_IndexedMapOfShape mapOldEdges;
-  TopExp::MapShapes (myS1, TopAbs_EDGE, mapOldEdges);
-  TopExp::MapShapes (myS2, TopAbs_EDGE, mapOldEdges);
-  FE.AvoidEdges (mapOldEdges);
-
-  // Get List of edges that have been fused
-  myFuseEdges = Standard_False;
-  myModifFaces.Clear();
-  myEdgeMap.Clear();
-  TopTools_DataMapOfIntegerListOfShape aFusedEdges;
-
-  FE.Edges(aFusedEdges);
-  Standard_Integer nle = aFusedEdges.Extent();
-  if (nle != 0) {
-    FE.Perform();
-    myShape = FE.Shape();
-
-    TopTools_DataMapOfIntegerShape aResultEdges;
-
-    FE.ResultEdges(aResultEdges);
-    FE.Faces(myModifFaces);
-    myFuseEdges = Standard_True;
-    
-    Standard_Integer i;
-    for(i = 1; i <= nle; ++i) {
-      const TopoDS_Shape& aNewE = aResultEdges(i);
-      const TopTools_ListOfShape& aListOfOldEdges = aFusedEdges(i);
-      TopTools_ListIteratorOfListOfShape anIter(aListOfOldEdges);
-      for(; anIter.More(); anIter.Next()) {
-        myEdgeMap.Bind(anIter.Value(), aNewE);
-      }
-    }
-  }
-}
-
-//=======================================================================
-//function : RefinedList
-//purpose  : 
-//=======================================================================
-const TopTools_ListOfShape& 
-  BRepAlgoAPI_BooleanOperation::RefinedList(const TopTools_ListOfShape& theL) 
-{
-  myGenerated.Clear();
-  TopTools_MapOfShape aMap;
-
-  TopTools_ListIteratorOfListOfShape anIter(theL);
-
-  for(; anIter.More(); anIter.Next()) {
-    const TopoDS_Shape& anS = anIter.Value();
-
-    if(anS.ShapeType() == TopAbs_EDGE) {
-      if(myEdgeMap.IsBound(anS)) {
-        const TopoDS_Shape& aNewEdge = myEdgeMap.Find(anS);
-        if(aMap.Add(aNewEdge)) {
-          myGenerated.Append(aNewEdge);
-        }
-      }
-      else {
-        myGenerated.Append(anS);
-      }
-    }
-    else if (anS.ShapeType() == TopAbs_FACE) {
-      if(myModifFaces.IsBound(anS)) {
-        myGenerated.Append(myModifFaces.Find(anS));
-      }
-      else {
-        myGenerated.Append(anS);
-      }
-    }
-    else {
-      myGenerated.Append(anS);
-    }
-  }
-
-  return myGenerated;
-
-}

src/BRepAlgoAPI/BRepAlgoAPI_BuilderAlgo.cdl

@@ -0,0 +1,47 @@
+-- Created by: Peter KURNEV
+-- Copyright (c) 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.
+
+deferred class BuilderAlgo from BRepAlgoAPI
+        inherits Algo from BRepAlgoAPI
+ ---Purpose: provides the root interface for algorithms
+
+uses
+    BaseAllocator from BOPCol,
+    PPaveFiller from BOPAlgo,
+    PBuilder from BOPAlgo
+
+--raises
+
+is
+    Initialize
+    returns BuilderAlgo from BRepAlgoAPI;
+    ---C++: alias "Standard_EXPORT virtual ~BRepAlgoAPI_BuilderAlgo();"
+
+    Initialize (theAllocator: BaseAllocator from BOPCol)
+    returns BuilderAlgo from BRepAlgoAPI;
+
+    SetFuzzyValue(me:out; 
+        theFuzz : Real from Standard);
+    ---Purpose: Sets the additional tolerance
+
+    FuzzyValue(me)
+    returns Real from Standard;
+    ---Purpose: Returns the additional tolerance 
+
+fields
+    myDSFiller   : PPaveFiller from BOPAlgo  is protected;
+    myBuilder    : PBuilder    from BOPAlgo  is protected;
+    myFuzzyValue : Real        from Standard is protected;
+
+end BuilderAlgo;

src/BRepAlgoAPI/BRepAlgoAPI_BuilderAlgo.cxx

@@ -0,0 +1,67 @@
+// Created by: Peter KURNEV
+// Copyright (c) 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 <BRepAlgoAPI_BuilderAlgo.ixx>
+
+#include <NCollection_BaseAllocator.hxx>
+
+//=======================================================================
+// function: 
+// purpose: 
+//=======================================================================
+BRepAlgoAPI_BuilderAlgo::BRepAlgoAPI_BuilderAlgo()
+:
+  BRepAlgoAPI_Algo(),
+  myDSFiller(NULL),
+  myBuilder(NULL),
+  myFuzzyValue(0.)
+{}
+//=======================================================================
+// function: 
+// purpose: 
+//=======================================================================
+BRepAlgoAPI_BuilderAlgo::BRepAlgoAPI_BuilderAlgo
+  (const Handle(NCollection_BaseAllocator)& theAllocator)
+:
+  BRepAlgoAPI_Algo(theAllocator),
+  myDSFiller(NULL),
+  myBuilder(NULL),
+  myFuzzyValue(0.)
+{}
+
+//=======================================================================
+// function: ~
+// purpose: 
+//=======================================================================
+BRepAlgoAPI_BuilderAlgo::~BRepAlgoAPI_BuilderAlgo()
+{
+}
+//=======================================================================
+//function : SetFuzzyValue
+//purpose  : 
+//=======================================================================
+void BRepAlgoAPI_BuilderAlgo::SetFuzzyValue(const Standard_Real theFuzz)
+{
+  if (theFuzz > 0.) {
+    myFuzzyValue = theFuzz;
+  }
+}
+//=======================================================================
+//function : FuzzyValue
+//purpose  : 
+//=======================================================================
+Standard_Real BRepAlgoAPI_BuilderAlgo::FuzzyValue() const
+{
+  return myFuzzyValue;
+}

src/BRepAlgoAPI/BRepAlgoAPI_Check.cdl

@@ -14,6 +14,7 @@
 -- commercial license or contractual agreement.
 
 class Check from BRepAlgoAPI 
+  inherits Algo from BRepAlgoAPI
     ---Purpose:  
     -- The class Check provides a diagnostic tool for checking  
     -- single shape or couple of shapes. 
@@ -116,10 +117,19 @@ is
     ---C++: return const&
     ---Purpose: Returns faulty shapes.
 
+    SetFuzzyValue(me:out; 
+        theFuzz : Real from Standard);
+    ---Purpose: Sets the additional tolerance
+
+    FuzzyValue(me)
+      returns Real from Standard;
+    ---Purpose: Returns the additional tolerance 
+    
 fields  
   myS1, myS2   : Shape from TopoDS is protected;  
   myAnalyzer   : PArgumentAnalyzer from BOPAlgo is protected;
   myResult     : ListOfCheckResult from BOPAlgo is protected;
+  myFuzzyValue : Real from Standard is protected;
    
 end BooleanOperation;
 

src/BRepAlgoAPI/BRepAlgoAPI_Check.cxx

@@ -21,8 +21,11 @@
 //function : BRepAlgoAPI_Check
 //purpose  : 
 //=======================================================================
-  BRepAlgoAPI_Check::BRepAlgoAPI_Check()
+BRepAlgoAPI_Check::BRepAlgoAPI_Check()
-: myAnalyzer(NULL)
+: 
+  BRepAlgoAPI_Algo(),
+  myAnalyzer(NULL),
+  myFuzzyValue(0.)
 {
 }
 
@@ -30,9 +33,11 @@
 //function : BRepAlgoAPI_Check
 //purpose  : 
 //=======================================================================
-  BRepAlgoAPI_Check::BRepAlgoAPI_Check(const TopoDS_Shape& theS,
+BRepAlgoAPI_Check::BRepAlgoAPI_Check(const TopoDS_Shape& theS,
                                      const Standard_Boolean bTestSE,
                                      const Standard_Boolean bTestSI)
+: BRepAlgoAPI_Algo(),
+  myFuzzyValue(0.)
 {
   Init(theS, TopoDS_Shape(), BOPAlgo_UNKNOWN, bTestSE, bTestSI);
   //
@@ -43,11 +48,13 @@
 //function : BRepAlgoAPI_Check
 //purpose  : 
 //=======================================================================
-  BRepAlgoAPI_Check::BRepAlgoAPI_Check(const TopoDS_Shape& theS1,
+BRepAlgoAPI_Check::BRepAlgoAPI_Check(const TopoDS_Shape& theS1,
                                      const TopoDS_Shape& theS2,
                                      const BOPAlgo_Operation theOp,
                                      const Standard_Boolean bTestSE,
                                      const Standard_Boolean bTestSI)
+: BRepAlgoAPI_Algo(),
+  myFuzzyValue(0.)
 {
   Init(theS1, theS2, theOp, bTestSE, bTestSI);
   //
@@ -58,7 +65,7 @@
 //function : ~BRepAlgoAPI_Check
 //purpose  : 
 //=======================================================================
-  BRepAlgoAPI_Check::~BRepAlgoAPI_Check()
+BRepAlgoAPI_Check::~BRepAlgoAPI_Check()
 {
   if(myAnalyzer){
     delete myAnalyzer;
@@ -67,11 +74,30 @@
   myResult.Clear();
 }
 
+//=======================================================================
+//function : SetFuzzyValue
+//purpose  : 
+//=======================================================================
+void BRepAlgoAPI_Check::SetFuzzyValue(const Standard_Real theFuzz)
+{
+  if (theFuzz > 0.) {
+    myFuzzyValue = theFuzz;
+  }
+}
+//=======================================================================
+//function : FuzzyValue
+//purpose  : 
+//=======================================================================
+Standard_Real BRepAlgoAPI_Check::FuzzyValue() const
+{
+  return myFuzzyValue;
+}
+
 //=======================================================================
 //function : SetData
 //purpose  : 
 //=======================================================================
-  void BRepAlgoAPI_Check::SetData(const TopoDS_Shape& theS,
+void BRepAlgoAPI_Check::SetData(const TopoDS_Shape& theS,
                                 const Standard_Boolean bTestSE,
                                 const Standard_Boolean bTestSI)
 {
@@ -82,7 +108,7 @@
 //function : SetData
 //purpose  : 
 //=======================================================================
-  void BRepAlgoAPI_Check::SetData(const TopoDS_Shape& theS1,
+void BRepAlgoAPI_Check::SetData(const TopoDS_Shape& theS1,
                                 const TopoDS_Shape& theS2,
                                 const BOPAlgo_Operation theOp,
                                 const Standard_Boolean bTestSE,
@@ -90,13 +116,11 @@
 {
   Init(theS1, theS2, theOp, bTestSE, bTestSI);
 }
-
-
 //=======================================================================
 //function : Init
 //purpose  : 
 //=======================================================================
-  void BRepAlgoAPI_Check::Init(const TopoDS_Shape& theS1,
+void BRepAlgoAPI_Check::Init(const TopoDS_Shape& theS1,
                              const TopoDS_Shape& theS2,
                              const BOPAlgo_Operation theOp,
                              const Standard_Boolean bTestSE,
@@ -114,13 +138,17 @@
   myAnalyzer->ArgumentTypeMode() = Standard_True;
   myAnalyzer->SmallEdgeMode() = bTestSE;
   myAnalyzer->SelfInterMode() = bTestSI;
+  //
+  myAnalyzer->SetRunParallel(myRunParallel);
+  myAnalyzer->SetProgressIndicator(myProgressIndicator);
+  myAnalyzer->SetFuzzyValue(myFuzzyValue);
 }
 
 //=======================================================================
 //function : Result
 //purpose  : 
 //=======================================================================
-  const BOPAlgo_ListOfCheckResult& BRepAlgoAPI_Check::Result()
+const BOPAlgo_ListOfCheckResult& BRepAlgoAPI_Check::Result()
 {
   return myResult;
 }
@@ -129,7 +157,7 @@
 //function : IsValid
 //purpose  : 
 //=======================================================================
-  Standard_Boolean BRepAlgoAPI_Check::IsValid()
+Standard_Boolean BRepAlgoAPI_Check::IsValid()
 {
   return myResult.IsEmpty();
 }
@@ -138,7 +166,7 @@
 //function : Perform
 //purpose  : 
 //=======================================================================
-  void BRepAlgoAPI_Check::Perform()
+void BRepAlgoAPI_Check::Perform()
 {
   Standard_Boolean isS1, isS2;
   //incompatibility of shape types, small edges and self-interference
@@ -175,5 +203,3 @@
     myResult.Append(aRes);
   }
 }
-
-

src/BRepAlgoAPI/BRepAlgoAPI_Common.cdl

@@ -14,7 +14,8 @@
 -- Alternatively, this file may be used under the terms of Open CASCADE
 -- commercial license or contractual agreement.
 
-class Common from BRepAlgoAPI inherits BooleanOperation from BRepAlgoAPI
+class Common from BRepAlgoAPI  
+    inherits BooleanOperation from BRepAlgoAPI
 
  ---Purpose: The class Common provides a
      -- Boolean common operation on a pair of arguments (Boolean Intersection).
@@ -28,6 +29,11 @@ uses
     PaveFiller from BOPAlgo
 
 is  
+    Create 
+        returns Common from BRepAlgoAPI;  
+    ---C++: alias "Standard_EXPORT virtual ~BRepAlgoAPI_Common();"  
+    --- Purpose: Empty constructor      
+        
     Create (S1,S2 : Shape from TopoDS)  
      returns Common from BRepAlgoAPI;  
     ---Purpose: Constructs a common part for shapes aS1 and aS2 .
@@ -35,5 +41,7 @@ is
     Create (S1,S2 : Shape from TopoDS; 
          aDSF:PaveFiller from BOPAlgo)  
      returns Common from BRepAlgoAPI; 
+    --- Purpose: Constructs a common part for shapes aS1 and aS2 using aDSFiller 
+    
 end Common;
---- Purpose: Constructs a common part for shapes aS1 and aS2 using aDSFiller
+

src/BRepAlgoAPI/BRepAlgoAPI_Common.cxx

@@ -18,6 +18,23 @@
 
 #include <BRepAlgoAPI_BooleanOperation.hxx>
 
+//=======================================================================
+//function : BRepAlgoAPI_Common
+//purpose  : 
+//=======================================================================
+BRepAlgoAPI_Common::BRepAlgoAPI_Common()
+:
+  BRepAlgoAPI_BooleanOperation()
+{
+  myOperation=BOPAlgo_COMMON;
+}
+//=======================================================================
+//function : ~BRepAlgoAPI_Common
+//purpose  : 
+//=======================================================================
+BRepAlgoAPI_Common::~BRepAlgoAPI_Common()
+{
+}
 //=======================================================================
 //function : BRepAlgoAPI_Common
 //purpose  : 

src/BRepAlgoAPI/BRepAlgoAPI_Cut.cdl

@@ -14,7 +14,8 @@
 -- Alternatively, this file may be used under the terms of Open CASCADE
 -- commercial license or contractual agreement.
 
-class Cut from BRepAlgoAPI inherits BooleanOperation from BRepAlgoAPI
+class Cut from BRepAlgoAPI  
+    inherits BooleanOperation from BRepAlgoAPI
  ---Purpose:  The class Cut provides a Boolean
      -- cut operation on a pair of arguments (Boolean Subtraction).
      -- The class Cut provides a framework for:
@@ -27,6 +28,13 @@ uses
     PaveFiller from BOPAlgo
 
 is 
+ 
+    Create 
+        returns Cut from BRepAlgoAPI;   
+    ---C++: alias "Standard_EXPORT virtual ~BRepAlgoAPI_Cut();"  
+    --- Purpose: Empty constructor 
+        
+
     Create (S1,S2 : Shape from TopoDS)  
         returns Cut from BRepAlgoAPI;  
     ---Purpose: Shape aS2 cuts shape aS1. The

src/BRepAlgoAPI/BRepAlgoAPI_Cut.cxx

@@ -22,9 +22,28 @@
 //function : BRepAlgoAPI_Cut
 //purpose  : 
 //=======================================================================
-  BRepAlgoAPI_Cut::BRepAlgoAPI_Cut(const TopoDS_Shape& S1, 
+BRepAlgoAPI_Cut::BRepAlgoAPI_Cut()
+:
+  BRepAlgoAPI_BooleanOperation()
+{
+  myOperation=BOPAlgo_CUT;
+}
+//=======================================================================
+//function : ~BRepAlgoAPI_Cut
+//purpose  : 
+//=======================================================================
+BRepAlgoAPI_Cut::~BRepAlgoAPI_Cut()
+{
+}
+
+//=======================================================================
+//function : BRepAlgoAPI_Cut
+//purpose  : 
+//=======================================================================
+BRepAlgoAPI_Cut::BRepAlgoAPI_Cut(const TopoDS_Shape& S1, 
                                  const TopoDS_Shape& S2)
-: BRepAlgoAPI_BooleanOperation(S1, S2, BOPAlgo_CUT)
+:
+  BRepAlgoAPI_BooleanOperation(S1, S2, BOPAlgo_CUT)
 {
   BRepAlgoAPI_BooleanOperation* pBO=
     (BRepAlgoAPI_BooleanOperation*) (void*) this;
@@ -34,11 +53,12 @@
 //function : BRepAlgoAPI_Cut
 //purpose  : 
 //=======================================================================
-  BRepAlgoAPI_Cut::BRepAlgoAPI_Cut(const TopoDS_Shape& S1, 
+BRepAlgoAPI_Cut::BRepAlgoAPI_Cut(const TopoDS_Shape& S1, 
                                  const TopoDS_Shape& S2,
                                  const BOPAlgo_PaveFiller& aDSF,
                                  const Standard_Boolean bFWD)
-: BRepAlgoAPI_BooleanOperation(S1, S2, aDSF, (bFWD) ? BOPAlgo_CUT : BOPAlgo_CUT21)
+: 
+  BRepAlgoAPI_BooleanOperation(S1, S2, aDSF, (bFWD) ? BOPAlgo_CUT : BOPAlgo_CUT21)
 {
   BRepAlgoAPI_BooleanOperation* pBO=
     (BRepAlgoAPI_BooleanOperation*) (void*) this;

src/BRepAlgoAPI/BRepAlgoAPI_Fuse.cdl

@@ -28,6 +28,12 @@ uses
     PaveFiller from BOPAlgo
 
 is 
+ 
+    Create 
+        returns Fuse from BRepAlgoAPI;   
+    ---C++: alias "Standard_EXPORT virtual ~BRepAlgoAPI_Fuse();"  
+    --- Purpose: Empty constructor 
+        
     Create (S1,S2 : Shape from TopoDS)  
         returns Fuse from BRepAlgoAPI;  
     ---Purpose: Constructs a fuse of shapes aS1 and aS2.
@@ -35,7 +41,6 @@ is
     Create (S1,S2 : Shape from TopoDS; 
             aDSF:PaveFiller from BOPAlgo)  
         returns Fuse from BRepAlgoAPI; 
-    
      ---Purpose: Constructs a new shape that is a fuse of shapes aS1 and aS2 using aDSFiller. 
     
 end Fuse;

src/BRepAlgoAPI/BRepAlgoAPI_Fuse.cxx

@@ -22,9 +22,28 @@
 //function : BRepAlgoAPI_Fuse
 //purpose  : 
 //=======================================================================
-  BRepAlgoAPI_Fuse::BRepAlgoAPI_Fuse(const TopoDS_Shape& S1, 
+BRepAlgoAPI_Fuse::BRepAlgoAPI_Fuse()
+:
+  BRepAlgoAPI_BooleanOperation()
+{
+  myOperation=BOPAlgo_FUSE;
+}
+//=======================================================================
+//function : ~BRepAlgoAPI_Fuse
+//purpose  : 
+//=======================================================================
+BRepAlgoAPI_Fuse::~BRepAlgoAPI_Fuse()
+{
+}
+
+//=======================================================================
+//function : BRepAlgoAPI_Fuse
+//purpose  : 
+//=======================================================================
+BRepAlgoAPI_Fuse::BRepAlgoAPI_Fuse(const TopoDS_Shape& S1, 
                                    const TopoDS_Shape& S2)
-: BRepAlgoAPI_BooleanOperation(S1, S2, BOPAlgo_FUSE)
+: 
+  BRepAlgoAPI_BooleanOperation(S1, S2, BOPAlgo_FUSE)
 {
   BRepAlgoAPI_BooleanOperation* pBO=
     (BRepAlgoAPI_BooleanOperation*) (void*) this;
@@ -35,10 +54,11 @@
 //function : BRepAlgoAPI_Fuse
 //purpose  : 
 //=======================================================================
-  BRepAlgoAPI_Fuse::BRepAlgoAPI_Fuse(const TopoDS_Shape& S1, 
+BRepAlgoAPI_Fuse::BRepAlgoAPI_Fuse(const TopoDS_Shape& S1, 
                                    const TopoDS_Shape& S2,
                                    const BOPAlgo_PaveFiller& aDSF)
-: BRepAlgoAPI_BooleanOperation(S1, S2, aDSF, BOPAlgo_FUSE)
+: 
+  BRepAlgoAPI_BooleanOperation(S1, S2, aDSF, BOPAlgo_FUSE)
 {
   BRepAlgoAPI_BooleanOperation* pBO=
     (BRepAlgoAPI_BooleanOperation*) (void*) this;

src/BRepAlgoAPI/BRepAlgoAPI_Section.cdl

@@ -16,7 +16,8 @@
 
 -- modified by Michael KLOKOV  Wed Mar  6 15:01:25 2002
 
-class Section from BRepAlgoAPI inherits BooleanOperation from BRepAlgoAPI
+class Section from BRepAlgoAPI  
+    inherits BooleanOperation from BRepAlgoAPI
 
      ---Purpose: Computes the intersection of two shapes or geometries.
      -- Geometries can be surfaces of planes.
@@ -51,38 +52,52 @@ uses
     ListOfShape from TopTools
     
 is
+    Create 
+        returns Section from BRepAlgoAPI;   
+    ---C++: alias "Standard_EXPORT virtual ~BRepAlgoAPI_Section();"  
+    --- Purpose: Empty constructor 
+        
+ 
     Create (S1,S2 : Shape from TopoDS; 
             aDSF:PaveFiller from BOPAlgo;
             PerformNow : Boolean = Standard_True)  
         returns Section from BRepAlgoAPI;
-    ---C++: alias "Standard_EXPORT virtual ~BRepAlgoAPI_Section(){}"   
+    
 
     Create(Sh1,Sh2 : Shape from TopoDS;
             PerformNow : Boolean = Standard_True) 
+        returns Section from BRepAlgoAPI;
     ---Purpose: see upper
     ---Level: Public
-    	returns Section from BRepAlgoAPI;
      
-    Create(Sh : Shape from TopoDS; Pl : Pln from gp;
+
+    Create(Sh : Shape from TopoDS;  
+            Pl : Pln from gp;
             PerformNow : Boolean = Standard_True) 
+        returns Section from BRepAlgoAPI;
      ---Purpose: see upper
      ---Level: Public
-    	returns Section from BRepAlgoAPI;
      
-    Create(Sh : Shape from TopoDS; Sf : Surface from Geom;
+
+    Create(Sh : Shape from TopoDS;  
+            Sf : Surface from Geom;
             PerformNow : Boolean = Standard_True) 
+        returns Section from BRepAlgoAPI;
      ---Purpose: see upper
      ---Level: Public
-    	returns Section from BRepAlgoAPI;
      
-    Create(Sf : Surface from Geom; Sh : Shape from TopoDS;
+
+    Create(Sf : Surface from Geom;  
+            Sh : Shape from TopoDS;
             PerformNow : Boolean = Standard_True) 
+        returns Section from BRepAlgoAPI;
      ---Purpose: see upper
      ---Level: Public
-	returns Section from BRepAlgoAPI;
  
-    Create(Sf1 : Surface from Geom; Sf2 : Surface from Geom;
+    Create(Sf1 : Surface from Geom;  
+            Sf2 : Surface from Geom;
             PerformNow : Boolean = Standard_True) 
+        returns Section from BRepAlgoAPI;
      ---Purpose: This and the above classes construct a framework for
      -- computing the section lines of:
      -- -       two shapes Sh1 and Sh2, or
@@ -153,36 +168,43 @@ is
      -- S.Approximation (Standard_True);
      -- S.Build();
      -- TopoDS_Shape R = S.Shape();
-	returns Section from BRepAlgoAPI;
  
-    Init1(me : out;S1 : Shape from TopoDS);
+
+    Init1(me : out; 
+            S1 : Shape from TopoDS);
      ---Purpose: initialize first part
      ---Level: Public
  
-    Init1(me : out;Pl : Pln from gp);
+    Init1(me : out; 
+            Pl : Pln from gp);
      ---Purpose: initialize first part
      ---Level: Public
  
-    Init1(me : out;Sf : Surface from Geom);
+    Init1(me : out; 
+            Sf : Surface from Geom);
      ---Purpose: initialize first part
      ---Level: Public
  
-    Init2(me : out;S2 : Shape from TopoDS);
+    Init2(me : out; 
+            S2 : Shape from TopoDS);
      ---Purpose: initialize second part
      ---Level: Public
  
-    Init2(me : out;Pl : Pln from gp);
+    Init2(me : out; 
+            Pl : Pln from gp);
      ---Purpose: initialize second part
      ---Level: Public
  
-    Init2(me : out;Sf : Surface from Geom);
+    Init2(me : out; 
+            Sf : Surface from Geom);
      ---Purpose: Reinitializes the first and the
      -- second parts on which this algorithm is going to perform
      -- the intersection computation. This is done with either: the
      -- surface Sf, the plane Pl or the shape Sh.
      -- You use the function Build to construct the result.
  
-    Approximation(me : out;B : Boolean);
+    Approximation(me : out; 
+        B : Boolean from Standard);
      ---Level: Public
      ---Purpose: Defines an option for computation
      -- of further intersections. This computation will be performed by
@@ -202,12 +224,14 @@ is
      --   Note that as a result, approximations will be computed
      -- on edges built only on new intersection lines.
  
-    ComputePCurveOn1(me : out;B : Boolean);
+    ComputePCurveOn1(me : out; 
+        B : Boolean from Standard);
      ---Level: Public
      ---Purpose: 
      -- Indicates if the Pcurve must be (or not) performed on first part. 
 
-    ComputePCurveOn2(me : out;B : Boolean);
+    ComputePCurveOn2(me : out; 
+            B : Boolean from Standard);
      ---Level: Public
      ---Purpose: Define options for the computation of further
      -- intersections, which will be performed by the function Build
@@ -223,6 +247,7 @@ is
      -- These two functions may be used together.
  
     Build(me : in out) 
+        is redefined;
      ---Purpose:  Performs the computation of
      -- section lines between two parts defined at the time of
      -- construction of this framework or reinitialized with the Init1 and
@@ -267,11 +292,12 @@ is
      -- to ask for this computation option before calling this function.
      -- You may also have combined these computation options: look at the
      -- example given above to illustrate the use of the constructors.
-    	is redefined static;
      
-    HasAncestorFaceOn1(me; E : Shape from TopoDS;
+
+    HasAncestorFaceOn1(me;  
+            E : Shape from TopoDS;
             F : out Shape from TopoDS)
-    	returns Boolean;
+        returns Boolean from Standard;
      ---Level: Public
      ---Purpose:
      -- get the face of the first part giving section edge <E>.
@@ -282,9 +308,10 @@ is
      --   is not the result of common edges)
      -- When False, F remains untouched.
 
-    HasAncestorFaceOn2(me; E : Shape from TopoDS;
+    HasAncestorFaceOn2(me;  
+            E : Shape from TopoDS;
             F : out Shape from TopoDS)
-    	returns Boolean;
+        returns Boolean from Standard;
      ---Purpose:  Identifies the ancestor faces of
      -- the intersection edge E resulting from the last
      -- computation performed in this framework, that is, the faces of
@@ -305,8 +332,9 @@ is
      -- only if the returned Boolean value equals true.
 
     InitParameters(me: out) 
-    	---Level: Private
         is private;
+    ---Level: Private
+     
 
 fields
     myshapeisnull       : Boolean from Standard;

src/BRepAlgoAPI/BRepAlgoAPI_Section.cxx

@@ -36,18 +36,46 @@
 #include <BOPAlgo_BOP.hxx>
 #include <BOPDS_DS.hxx>
 
-static TopoDS_Shape MakeShape(const Handle(Geom_Surface)& S)
+//
+static 
+  TopoDS_Shape MakeShape(const Handle(Geom_Surface)& );
+
+static 
+  Standard_Boolean HasAncestorFaces(const BOPAlgo_PPaveFiller&, 
+                                    const TopoDS_Shape&,
+                                    TopoDS_Shape&,
+                                    TopoDS_Shape&);
+
+//=======================================================================
+//function : BRepAlgoAPI_Section
+//purpose  : 
+//=======================================================================
+BRepAlgoAPI_Section::BRepAlgoAPI_Section()
+:
+  BRepAlgoAPI_BooleanOperation()
 {
-  GeomAbs_Shape c = S->Continuity();
+  myOperation=BOPAlgo_SECTION;
-  if (c >= GeomAbs_C2) return BRepBuilderAPI_MakeFace(S, Precision::Confusion());
+  InitParameters(); 
-  else return BRepBuilderAPI_MakeShell(S);
+}
+//=======================================================================
+//function : ~BRepAlgoAPI_Section
+//purpose  : 
+//=======================================================================
+BRepAlgoAPI_Section::~BRepAlgoAPI_Section()
+{
+}
+//=======================================================================
+//function : InitParameters
+//purpose  : 
+//=======================================================================
+void BRepAlgoAPI_Section::InitParameters() 
+{
+  myparameterschanged = Standard_False;
+  myshapeisnull = Standard_False;
+  myApprox = Standard_False;
+  myComputePCurve1 = Standard_False;
+  myComputePCurve2 = Standard_False;
 }
-
-static Standard_Boolean HasAncestorFaces(const BOPAlgo_PPaveFiller& theDSFiller, 
-                                         const TopoDS_Shape&      E,
-                                         TopoDS_Shape&            F1,
-                                         TopoDS_Shape&            F2);
-
 //=======================================================================
 //function : Constructor
 //purpose  : 
@@ -55,31 +83,35 @@ static Standard_Boolean HasAncestorFaces(const BOPAlgo_PPaveFiller& theDSFiller,
 BRepAlgoAPI_Section::BRepAlgoAPI_Section(const TopoDS_Shape& Sh1,
                                          const TopoDS_Shape& Sh2,
                                          const Standard_Boolean PerformNow)
-: BRepAlgoAPI_BooleanOperation(Sh1, Sh2, BOPAlgo_SECTION)
+:
+  BRepAlgoAPI_BooleanOperation(Sh1, Sh2, BOPAlgo_SECTION)
 {
   InitParameters();
   myparameterschanged = Standard_True;
 
   if(myS1.IsNull() || myS2.IsNull()) {
-    //     StdFail_NotDone::Raise("BRepAlgoAPI_Section : Shape NULL");
     myshapeisnull = Standard_True;
   }
   if (PerformNow) {
     Build();
   }
 }
-
+//=======================================================================
-BRepAlgoAPI_Section::BRepAlgoAPI_Section(const TopoDS_Shape&      aS1, 
+//function : BRepAlgoAPI_Section
+//purpose  : 
+//=======================================================================
+BRepAlgoAPI_Section::BRepAlgoAPI_Section
+  (const TopoDS_Shape&      aS1, 
    const TopoDS_Shape&      aS2,
    const BOPAlgo_PaveFiller& aDSF,
    const Standard_Boolean   PerformNow)
-: BRepAlgoAPI_BooleanOperation(aS1, aS2, aDSF, BOPAlgo_SECTION)
+: 
+  BRepAlgoAPI_BooleanOperation(aS1, aS2, aDSF, BOPAlgo_SECTION)
 {
   InitParameters();
   myparameterschanged = Standard_True;
 
   if(myS1.IsNull() || myS2.IsNull()) {
-    //     StdFail_NotDone::Raise("BRepAlgoAPI_Section : Shape NULL");
     myshapeisnull = Standard_True;
   }
 
@@ -87,85 +119,87 @@ BRepAlgoAPI_Section::BRepAlgoAPI_Section(const TopoDS_Shape&      aS1,
     Build();
   }
 }
-
-
 //=======================================================================
 //function : Constructor
 //purpose  : 
 //=======================================================================
-BRepAlgoAPI_Section::BRepAlgoAPI_Section(const TopoDS_Shape&    Sh,
+BRepAlgoAPI_Section::BRepAlgoAPI_Section
+  (const TopoDS_Shape&    Sh,
    const gp_Pln&          Pl,
    const Standard_Boolean PerformNow)
-: BRepAlgoAPI_BooleanOperation(Sh, MakeShape(new Geom_Plane(Pl)), BOPAlgo_SECTION)
+: 
+  BRepAlgoAPI_BooleanOperation(Sh, MakeShape(new Geom_Plane(Pl)), 
+                               BOPAlgo_SECTION)
 {
   InitParameters();
   myparameterschanged = Standard_True;
 
   if(Sh.IsNull() || myS2.IsNull()) {
-    //     StdFail_NotDone::Raise("BRepAlgoAPI_Section : Shape NULL");
     myshapeisnull = Standard_True;
   }
   if (PerformNow) {
     Build();
   }
 }
-
 //=======================================================================
 //function : Constructor
 //purpose  : 
 //=======================================================================
-BRepAlgoAPI_Section::BRepAlgoAPI_Section(const TopoDS_Shape&         Sh,
+BRepAlgoAPI_Section::BRepAlgoAPI_Section
+  (const TopoDS_Shape&         Sh,
    const Handle(Geom_Surface)& Sf,
    const Standard_Boolean      PerformNow)
-: BRepAlgoAPI_BooleanOperation(Sh, MakeShape(Sf), BOPAlgo_SECTION)
+: 
+  BRepAlgoAPI_BooleanOperation(Sh, MakeShape(Sf), BOPAlgo_SECTION)
 {
   InitParameters();
   myparameterschanged = Standard_True;
 
   if(Sh.IsNull() || myS2.IsNull()) {
-//     StdFail_NotDone::Raise("BRepAlgoAPI_Section : Shape NULL");
     myshapeisnull = Standard_True;
   }
   if (PerformNow) {
     Build();
   }
 }
-
 //=======================================================================
 //function : Constructor
 //purpose  : 
 //=======================================================================
-BRepAlgoAPI_Section::BRepAlgoAPI_Section(const Handle(Geom_Surface)& Sf,
+BRepAlgoAPI_Section::BRepAlgoAPI_Section
+  (const Handle(Geom_Surface)& Sf,
    const TopoDS_Shape&         Sh,
    const Standard_Boolean      PerformNow)
-: BRepAlgoAPI_BooleanOperation(MakeShape(Sf), Sh, BOPAlgo_SECTION)
+: 
+  BRepAlgoAPI_BooleanOperation(MakeShape(Sf), Sh, BOPAlgo_SECTION)
 {
   InitParameters();
   myparameterschanged = Standard_True;
 
   if(myS1.IsNull() || Sh.IsNull()) {
-//     StdFail_NotDone::Raise("BRepAlgoAPI_Section : Shape NULL");
     myshapeisnull = Standard_True;
   }
   if (PerformNow) {
     Build();
   }
 }
-
 //=======================================================================
 //function : Constructor
 //purpose  : 
 //=======================================================================
-BRepAlgoAPI_Section::BRepAlgoAPI_Section(const Handle(Geom_Surface)& Sf1,
+BRepAlgoAPI_Section::BRepAlgoAPI_Section
+  (const Handle(Geom_Surface)& Sf1,
    const Handle(Geom_Surface)& Sf2,
    const Standard_Boolean PerformNow)
-: BRepAlgoAPI_BooleanOperation(MakeShape(Sf1), MakeShape(Sf2), BOPAlgo_SECTION)
+: 
+  BRepAlgoAPI_BooleanOperation(MakeShape(Sf1), 
+                               MakeShape(Sf2), 
+                               BOPAlgo_SECTION)
 {
   InitParameters();
   myparameterschanged = Standard_True;
 
   if(myS1.IsNull() || myS2.IsNull()) {
-//     StdFail_NotDone::Raise("BRepAlgoAPI_Section : Shape NULL");
     myshapeisnull = Standard_True;
   }
 
@@ -173,7 +207,6 @@ BRepAlgoAPI_Section::BRepAlgoAPI_Section(const Handle(Geom_Surface)& Sf1,
     Build();
   }
 }
-
 //=======================================================================
 //function : Init1
 //purpose  : 
@@ -201,7 +234,6 @@ void BRepAlgoAPI_Section::Init1(const TopoDS_Shape& S1)
   if(myparameterschanged)
     NotDone();
 }
-
 //=======================================================================
 //function : Init1
 //purpose  : 
@@ -210,7 +242,6 @@ void BRepAlgoAPI_Section::Init1(const gp_Pln& Pl)
 {
   Init1(MakeShape(new Geom_Plane(Pl)));
 }
-
 //=======================================================================
 //function : Init1
 //purpose  : 
@@ -219,7 +250,6 @@ void BRepAlgoAPI_Section::Init1(const Handle(Geom_Surface)& Sf)
 {
   Init1(MakeShape(Sf));
 }
-
 //=======================================================================
 //function : Init2
 //purpose  : 
@@ -248,7 +278,6 @@ void BRepAlgoAPI_Section::Init2(const TopoDS_Shape& S2)
     NotDone();
   }
 }
-
 //=======================================================================
 //function : Init2
 //purpose  : 
@@ -257,7 +286,6 @@ void BRepAlgoAPI_Section::Init2(const gp_Pln& Pl)
 {
   Init2(MakeShape(new Geom_Plane(Pl)));
 }
-
 //=======================================================================
 //function : Init2
 //purpose  : 
@@ -266,7 +294,6 @@ void BRepAlgoAPI_Section::Init2(const Handle(Geom_Surface)& Sf)
 {
   Init2(MakeShape(Sf));
 }
-
 //=======================================================================
 //function : Approximation
 //purpose  : 
@@ -278,7 +305,6 @@ void BRepAlgoAPI_Section::Approximation(const Standard_Boolean B)
     myparameterschanged = Standard_True;
   }
 }
-
 //=======================================================================
 //function : ComputePCurveOn1
 //purpose  : 
@@ -290,7 +316,6 @@ void BRepAlgoAPI_Section::ComputePCurveOn1(const Standard_Boolean B)
     myparameterschanged = Standard_True;
   }
 }
-
 //=======================================================================
 //function : ComputePCurveOn2
 //purpose  : 
@@ -302,7 +327,6 @@ void BRepAlgoAPI_Section::ComputePCurveOn2(const Standard_Boolean B)
     myparameterschanged = Standard_True;
   }
 }
-
 //=======================================================================
 //function : Build
 //purpose  : 
@@ -325,7 +349,9 @@ void BRepAlgoAPI_Section::Build()
     }
     //
     if (bIsNewFiller) {
-      BOPAlgo_SectionAttribute theSecAttr(myApprox, myComputePCurve1, myComputePCurve2);
+      BOPAlgo_SectionAttribute theSecAttr(myApprox, 
+                                          myComputePCurve1, 
+                                          myComputePCurve2);
       myDSFiller->SetSectionAttribute(theSecAttr);
       myDSFiller->Perform();
     }
@@ -335,12 +361,13 @@ void BRepAlgoAPI_Section::Build()
     myparameterschanged = Standard_False;
   }
 }
-
 //=======================================================================
 //function : HasAncestorFaceOn1
 //purpose  : 
 //=======================================================================
-Standard_Boolean BRepAlgoAPI_Section::HasAncestorFaceOn1(const TopoDS_Shape& E, TopoDS_Shape& F) const
+Standard_Boolean BRepAlgoAPI_Section::HasAncestorFaceOn1
+  (const TopoDS_Shape& E, 
+   TopoDS_Shape& F) const
 {
   Standard_Boolean aResult = Standard_False;
   if(E.IsNull()) {
@@ -359,12 +386,13 @@ Standard_Boolean BRepAlgoAPI_Section::HasAncestorFaceOn1(const TopoDS_Shape& E,
   F = F1;
   return aResult;
 }
-
 //=======================================================================
 //function : HasAncestorFaceOn2
 //purpose  : 
 //=======================================================================
-Standard_Boolean BRepAlgoAPI_Section::HasAncestorFaceOn2(const TopoDS_Shape& E,TopoDS_Shape& F) const
+Standard_Boolean BRepAlgoAPI_Section::HasAncestorFaceOn2
+  (const TopoDS_Shape& E,
+   TopoDS_Shape& F) const
 {
   Standard_Boolean aResult = Standard_False;
   if(E.IsNull()) {
@@ -385,26 +413,14 @@ Standard_Boolean BRepAlgoAPI_Section::HasAncestorFaceOn2(const TopoDS_Shape& E,T
 }
 
 //=======================================================================
-//function : InitParameters
+//function : HasAncestorFaces
 //purpose  : 
 //=======================================================================
-void BRepAlgoAPI_Section::InitParameters() 
+Standard_Boolean HasAncestorFaces(const BOPAlgo_PPaveFiller& theDSFiller, 
-{
-  myparameterschanged = Standard_False;
-  myshapeisnull = Standard_False;
-  myApprox = Standard_False;
-  myComputePCurve1 = Standard_False;
-  myComputePCurve2 = Standard_False;
-}
-
-// ------------------------------------------------------------------------
-// static function : HasAncestorFaces
-// purpose  : 
-// ------------------------------------------------------------------------
-static Standard_Boolean HasAncestorFaces(const BOPAlgo_PPaveFiller& theDSFiller, 
                                   const TopoDS_Shape& E,
                                   TopoDS_Shape& F1,
-                                         TopoDS_Shape&            F2) {
+                                  TopoDS_Shape&F2) 
+{
   
   Standard_Integer aNb, i, j, nE, nF1, nF2, aNbCurves;
   //
@@ -442,3 +458,15 @@ static Standard_Boolean HasAncestorFaces(const BOPAlgo_PPaveFiller& theDSFiller,
   }
   return Standard_False;
 }
+//=======================================================================
+//function : MakeShape
+//purpose  : 
+//=======================================================================
+TopoDS_Shape MakeShape(const Handle(Geom_Surface)& S)
+{
+  GeomAbs_Shape c = S->Continuity();
+  if (c >= GeomAbs_C2) {
+    return BRepBuilderAPI_MakeFace(S, Precision::Confusion());
+  }
+  return BRepBuilderAPI_MakeShell(S);
+}

src/BRepBuilderAPI/BRepBuilderAPI_MakeShape.cdl

@@ -54,7 +54,8 @@ is
     ---Level: Public
     raises
     NotDone from StdFail 
-    is static;
+    is virtual; 
+    --is static; 
 
 
     ------------------------------------------------------------------

tests/bugs/modalg_5/bug25477_1

@@ -0,0 +1,23 @@
+puts "========"
+puts "OCC25477"
+puts "========"
+puts ""
+############################################################################
+#  Boolean Operations with additional tolerance - Fuzzy Boolean operations
+############################################################################
+
+box b1 10 10 10
+box b2 10.00001 0 0 10 10 10
+
+bop b1 b2 0.00002
+bopfuse result
+
+set nb_v_good 12
+set nb_e_good 20
+set nb_w_good 10
+set nb_f_good 10
+set nb_sh_good 1
+set nb_sol_good 1
+set nb_compsol_good 0
+set nb_compound_good 1
+set nb_shape_good 55

tests/bugs/modalg_5/bug25477_2

@@ -0,0 +1,20 @@
+puts "========"
+puts "OCC25477"
+puts "========"
+puts ""
+############################################################################
+#  Boolean Operations with additional tolerance - Fuzzy Boolean operations
+############################################################################
+
+pload XDE
+
+testreadstep [locate_data_file OCC25477_test3_profile.stp] b1
+testreadstep [locate_data_file OCC25477_test3.stp] b2
+
+bclearobjects
+bcleartools
+baddobjects b1
+baddtools b2
+bfillds 5.e-5
+bbop res 2
+checkshape res