0025477: Boolean Operations with additional tolerance - Fuzzy Boolean operations
authoremv <emv@opencascade.com>
Fri, 28 Nov 2014 09:23:58 +0000 (12:23 +0300)
committerbugmaster <bugmaster@opencascade.com>
Fri, 28 Nov 2014 09:24:39 +0000 (12:24 +0300)
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

41 files changed:
src/BOPAlgo/BOPAlgo_ArgumentAnalyzer.cdl
src/BOPAlgo/BOPAlgo_ArgumentAnalyzer.cxx
src/BOPAlgo/BOPAlgo_ArgumentAnalyzer.lxx
src/BOPAlgo/BOPAlgo_BOP.cxx
src/BOPAlgo/BOPAlgo_Builder.cdl
src/BOPAlgo/BOPAlgo_Builder.cxx
src/BOPAlgo/BOPAlgo_CheckerSI.cxx
src/BOPAlgo/BOPAlgo_MakerVolume.cxx
src/BOPAlgo/BOPAlgo_MakerVolume.lxx
src/BOPAlgo/BOPAlgo_PaveFiller.cdl
src/BOPAlgo/BOPAlgo_PaveFiller.cxx
src/BOPCol/BOPCol.cdl
src/BOPCol/BOPCol_DataMapOfShapeReal.hxx [new file with mode: 0644]
src/BOPCol/FILES
src/BOPDS/BOPDS_DS.cdl
src/BOPDS/BOPDS_DS.cxx
src/BOPDS/BOPDS_DS.lxx
src/BOPTest/BOPTest_BOPCommands.cxx
src/BOPTest/BOPTest_CheckCommands.cxx
src/BOPTest/BOPTest_PartitionCommands.cxx
src/BOPTools/BOPTools_AlgoTools_1.cxx
src/BRepAlgoAPI/BRepAlgoAPI.cdl
src/BRepAlgoAPI/BRepAlgoAPI_Algo.cdl [new file with mode: 0644]
src/BRepAlgoAPI/BRepAlgoAPI_Algo.cxx [new file with mode: 0644]
src/BRepAlgoAPI/BRepAlgoAPI_BooleanOperation.cdl
src/BRepAlgoAPI/BRepAlgoAPI_BooleanOperation.cxx
src/BRepAlgoAPI/BRepAlgoAPI_BuilderAlgo.cdl [new file with mode: 0644]
src/BRepAlgoAPI/BRepAlgoAPI_BuilderAlgo.cxx [new file with mode: 0644]
src/BRepAlgoAPI/BRepAlgoAPI_Check.cdl
src/BRepAlgoAPI/BRepAlgoAPI_Check.cxx
src/BRepAlgoAPI/BRepAlgoAPI_Common.cdl
src/BRepAlgoAPI/BRepAlgoAPI_Common.cxx
src/BRepAlgoAPI/BRepAlgoAPI_Cut.cdl
src/BRepAlgoAPI/BRepAlgoAPI_Cut.cxx
src/BRepAlgoAPI/BRepAlgoAPI_Fuse.cdl
src/BRepAlgoAPI/BRepAlgoAPI_Fuse.cxx
src/BRepAlgoAPI/BRepAlgoAPI_Section.cdl
src/BRepAlgoAPI/BRepAlgoAPI_Section.cxx
src/BRepBuilderAPI/BRepBuilderAPI_MakeShape.cdl
tests/bugs/modalg_5/bug25477_1 [new file with mode: 0644]
tests/bugs/modalg_5/bug25477_2 [new file with mode: 0644]

index 0c15f28..90cfb12 100644 (file)
@@ -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);
@@ -167,8 +170,25 @@ is
     is protected;
 
 --  TestMergeFace(me: out)
---  is protected;
+--  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
 
@@ -186,6 +206,8 @@ fields
     myContinuityMode     : Boolean   from Standard; 
     myCurveOnSurfaceMode : Boolean   from Standard; 
     myEmpty1, myEmpty2   : Boolean   from Standard; 
-    myResult     : ListOfCheckResult from BOPAlgo; 
-        
+    myResult             : ListOfCheckResult from BOPAlgo;
+    myFuzzyValue         : Real      from Standard;
+    myToleranceMap       : DataMapOfShapeReal from BOPCol;
+
 end ArgumentAnalyzer;
index c0ee0a0..71c0e1e 100644 (file)
@@ -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()) {
+}
index d5102f0..846e296 100644 (file)
@@ -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;
index 3f94e9b..e05cd20 100644 (file)
@@ -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();
   //
index f310c7c..e7bfc23 100644 (file)
@@ -219,7 +219,15 @@ is
     Splits (me) 
     returns DataMapOfShapeListOfShape from BOPCol; 
     ---C++: return const &       
-    ---Purpose:  Returns mySplits. 
+    ---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; 
@@ -233,7 +241,8 @@ fields
     myShapesSD   : DataMapOfShapeShape from BOPCol is protected;   
     --
     mySplits     : DataMapOfShapeListOfShape from BOPCol is protected; 
-    myOrigins    : DataMapOfShapeShape from BOPCol is protected; 
+    myOrigins    : DataMapOfShapeShape from BOPCol is protected;
+    myFuzzyValue : Real from Standard is protected; 
  
 end Builder;
 
index ca6c22a..0726dec 100644 (file)
@@ -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();
   //
index 6c314de..b22be8b 100644 (file)
@@ -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 
index b602d21..3b10f07 100644 (file)
@@ -44,6 +44,29 @@ static
                      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;
index d5b3ece..5794e8f 100644 (file)
@@ -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;
-  }
-}
index 5e64364..2e615c0 100644 (file)
@@ -463,12 +463,20 @@ is
     ---Purpose: 
     -- 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;
index a4962d3..1114acf 100644 (file)
@@ -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
 } 
index b34cd5c..0204c52 100644 (file)
@@ -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; 
diff --git a/src/BOPCol/BOPCol_DataMapOfShapeReal.hxx b/src/BOPCol/BOPCol_DataMapOfShapeReal.hxx
new file mode 100644 (file)
index 0000000..c61a7f0
--- /dev/null
@@ -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
index 7245d70..fde2995 100644 (file)
@@ -1,5 +1,6 @@
 BOPCol_Array1.hxx
 BOPCol_DataMapOfShapeInteger.hxx
+BOPCol_DataMapOfShapeReal.hxx
 BOPCol_MapOfInteger.hxx
 BOPCol_ListOfInteger.hxx
 BOPCol_PInteger.hxx
index 2cb8087..4fc375f 100644 (file)
@@ -38,7 +38,8 @@ uses
     Shape         from TopoDS,
     -- 
     ListOfShape from BOPCol,  
-    DataMapOfIntegerInteger from BOPCol,
+    DataMapOfIntegerInteger from BOPCol, 
+    DataMapOfIntegerReal    from BOPCol,
     DataMapOfShapeInteger   from BOPCol, 
     ListOfInteger           from BOPCol, 
     MapOfInteger            from BOPCol, 
@@ -303,7 +304,7 @@ is
  
     IsCommonBlockOnEdge(me; 
                 thePB:PaveBlock from BOPDS)   
-    returns Boolean from Standard;      
+    returns Boolean from Standard;          
     ---Purpose: 
     --- Query 
     --- Returns true if common block contains more then one pave block 
@@ -500,7 +501,7 @@ is
     ---C++: inline  
             ---Purpose:  
             --- Selector/Modifier
-        --- Returns the collection of interferences Edge/Solid          
+        --- Returns the collection of interferences Edge/Solid          
   
     InterfFZ(me:out) 
             returns VectorOfInterfFZ from BOPDS; 
@@ -508,7 +509,7 @@ is
     ---C++: inline  
             ---Purpose:  
             --- Selector/Modifier
-        --- Returns the collection of interferences Face/Solid                  
+        --- Returns the collection of interferences Face/Solid                  
  
     InterfZZ(me:out) 
             returns VectorOfInterfZZ from BOPDS; 
@@ -516,12 +517,12 @@ is
     ---C++: inline  
             ---Purpose:  
             --- Selector/Modifier
-        --- Returns the collection of interferences Solid/Solid                 
-           
+        --- Returns the collection of interferences Solid/Solid                  
+            
     NbInterfTypes(myclass)  
-       returns Integer from Standard;  
-       ---C++: inline       
-          ---Purpose: 
+            returns Integer from Standard;  
+            ---C++: inline       
+           ---Purpose: 
            -- Returns the number of types of the interferences 
            -- 
  
@@ -556,14 +557,14 @@ is
     HasInterfShapeSubShapes(me; 
             theI1:Integer from Standard;  
             theI2:Integer from Standard; 
-           theFlag: Boolean from Standard=Standard_True) 
+                theFlag: Boolean from Standard=Standard_True) 
         returns Boolean from Standard;  
             ---Purpose: 
             --- Query
         --- Returns true if the shape with index theI1 is interfered 
         --- with  
-       --    any sub-shape of the shape with index theI2  (theFlag=true)    
-       --    all sub-shapes of the shape with index theI2 (theFlag=false)     
+            --    any sub-shape of the shape with index theI2  (theFlag=true)    
+            --    all sub-shapes of the shape with index theI2 (theFlag=false)     
   
     HasInterfSubShapes(me; 
             theI1:Integer from Standard;  
@@ -628,15 +629,26 @@ is
              ---
  
     BuildBndBoxSolid (me:out; 
-               theIndex:Integer from Standard;  
-               theBox:out Box from Bnd) 
-       is protected;  
-           ---Purpose: 
+                theIndex:Integer from Standard;  
+                theBox:out Box from Bnd) 
+            is protected;  
+            ---Purpose: 
             --- 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;
     myArguments        : ListOfShape from BOPCol is protected;   
@@ -665,5 +677,10 @@ fields
     myInterfVZ         : VectorOfInterfVZ from BOPDS is protected;
     myInterfEZ         : VectorOfInterfEZ from BOPDS is protected;
     myInterfFZ         : VectorOfInterfFZ from BOPDS is protected;
-    myInterfZZ         : VectorOfInterfZZ 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;
index 99c255a..c0df289 100644 (file)
 #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);
@@ -709,12 +753,12 @@ Standard_Boolean BOPDS_DS::HasInterfShapeSubShapes
     bRet=HasInterf(theI1, n2);
     if (theFlag) {
       if(bRet) {
- break;
+        break;
       }
     }
     else {
       if(!bRet) {
- break;
+        break;
       }
     }
   }
@@ -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);
+    }
+  }
+}
index ba91ecc..61dbd2c 100644 (file)
@@ -105,7 +105,7 @@ inline Standard_Integer BOPDS_DS::NbInterfTypes()
 //purpose  : 
 //=======================================================================
 inline void BOPDS_DS::AddInterf(const Standard_Integer theI1,
-                               const Standard_Integer theI2)
+                                const Standard_Integer theI2)
 {
   BOPDS_PassKey aPK;
   //
@@ -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;
+}
index 8de06dd..e48dd62 100644 (file)
@@ -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("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("boptuc"    , "use boptuc"      , __FILE__,boptuc, g);
-  theCommands.Add("bopsection", "use bopsection"  , __FILE__,bopsection, g);
-  //
-  theCommands.Add("bcommon" , "use bcommon r s1 s2" , __FILE__,bcommon, g);
-  theCommands.Add("bfuse"   , "use bfuse r s1 s2"   , __FILE__,bfuse, g);
-  theCommands.Add("bcut"    , "use bcut r s1 s2"    , __FILE__,bcut, g);
-  theCommands.Add("btuc"    , "use btuc r s1 s2"    , __FILE__,btuc, g);
-  theCommands.Add("bsection", "Use >bsection r s1 s2 [-n2d/-n2d1/-n2d2] [-na]", 
+  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 r"        , __FILE__,bopcut, g);
+  theCommands.Add("boptuc"    , "use boptuc r"        , __FILE__,boptuc, g);
+  theCommands.Add("bopsection", "use bopsection r"    , __FILE__,bopsection, g);
+  //
+  theCommands.Add("bcommon" , "use bcommon r s1 s2 [tol]" , __FILE__,bcommon, g);
+  theCommands.Add("bfuse"   , "use bfuse r s1 s2 [tol]"   , __FILE__,bfuse, g);
+  theCommands.Add("bcut"    , "use bcut r s1 s2 [tol]"    , __FILE__,bcut, 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] [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("mkvolume", "make solids from set of shapes.\nmkvolume r b1 b2 ... [-ni (do not intersect)] [-s (run in non parallel mode)]", __FILE__, mkvolume , g);
+  theCommands.Add("bparallelmode", "bparallelmode [1/0] : show / set parallel mode for boolean operations", 
+                  __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) {
-    di << " use bop Shape1 Shape2\n";
+  if (n < 3 || n > 4) {
+    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,104 +360,74 @@ 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;
-  
-  Standard_Boolean isbadparameter = Standard_False;
-  
-  if(n > 4) {
-    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;
-      }
+  aTol = 0.;
+  //
+  for (i = 4; i < n; ++i) {
+    if (!strcmp(a[i], "-n2d")) {
+      bPC1 = Standard_False;
+      bPC2 = Standard_False;
     }
-    if (key2) {
-      if(!strcasecmp(key2,"-na")) {
-        bApp = Standard_False;
-      }
-      else {
-        isbadparameter = Standard_True;
-      }
+    else if (!strcmp(a[i], "-n2d1")) {
+      bPC1 = Standard_False;
     }
-
-    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], "-n2d2")) {
+      bPC2 = Standard_False;
     }
-  }
-      
-  if(!isbadparameter) {
-    Standard_Integer iErr;
-    char buf[80];
-    //
-    BRepAlgoAPI_Section aSec(aS1, aS2, Standard_False);
-    aSec.Approximation(bApp);
-    aSec.ComputePCurveOn1(bPC1);
-    aSec.ComputePCurveOn2(bPC2);
-    //
-    aSec.Build();
-    iErr=aSec.ErrorStatus();
-    if (!aSec.IsDone()) {
-      Sprintf(buf, " ErrorStatus : %d\n",  iErr);
-      di << buf;
-      return 0;
+    else if (!strcmp(a[i], "-na")) {
+      bApp = Standard_False;
     }
-    //
-    const TopoDS_Shape& aR=aSec.Shape();
-    if (aR.IsNull()) {
-      di << " null shape\n";
-      return 0;
+    else {
+      aTol = Draw::Atof(a[i]);
     }
-    DBRep::Set(a[1], aR);
+  }
+  //
+  Standard_Integer iErr;
+  char buf[80];
+  //
+  BRepAlgoAPI_Section aSec(aS1, aS2, Standard_False);
+  aSec.Approximation(bApp);
+  aSec.ComputePCurveOn1(bPC1);
+  aSec.ComputePCurveOn2(bPC2);
+  aSec.SetFuzzyValue(aTol);
+  //
+  aSec.Build();
+  iErr=aSec.ErrorStatus();
+  if (!aSec.IsDone()) {
+    Sprintf(buf, " ErrorStatus : %d\n",  iErr);
+    di << buf;
     return 0;
   }
-  else {
-    di << usage;
-    return 1;
+  //
+  const TopoDS_Shape& aR=aSec.Shape();
+  if (aR.IsNull()) {
+    di << " null shape\n";
+    return 0;
   }
+  DBRep::Set(a[1], aR);
+  return 0;
 }
+
 //=======================================================================
 //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) {
-    di << " use bx r s1 s2\n";
+  if (n < 4 || n > 5) {
+    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;
-  Standard_Integer i, aNb;
+  const char* usage = "Type mkvolume without arguments for the usage of the command.\n";
+  //
+  Standard_Boolean bToIntersect, bRunParallel, bCompounds;
+  Standard_Integer i;
+  Standard_Real aTol;
+  TopoDS_Shape aS;
+  BOPCol_ListOfShape aLS;
   //
-  aNb = n;
+  aTol = 0.;
   bToIntersect = Standard_True;
   bRunParallel = Standard_True;
+  bCompounds = Standard_False;
   //
-  if (!strcmp(a[n-1], "-ni")) {
-    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) {
+  for (i = 2; i < n; ++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;
 }
-
index 6ff8ae4..a63ed3e 100644 (file)
@@ -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,13 +177,16 @@ 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) {
-    aLevel=Draw::Atoi(a[2]); 
+    if (a[2][0] != '-') {
+      aLevel=Draw::Atoi(a[2]); 
+    }
   }
   //
   if (aLevel < 0 || aLevel > aNbInterfTypes-1) {
@@ -191,15 +194,22 @@ Standard_Integer bopcheck (Draw_Interpretor& di,
     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;
@@ -411,7 +430,7 @@ Standard_Integer bopargcheck (Draw_Interpretor& di,
       }
     }
   }
-
+  
   // set & test second shape
   TopoDS_Shape aS22, aS2;
   if(isS2) {
@@ -429,9 +448,10 @@ 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);
-          aDMETol.Bind(aE, aDMax);
+          aD = aDMax;
         }
       }
       else {
index 58c3e87..d7ce474 100644 (file)
@@ -54,10 +54,10 @@ 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("bbuild" , "use bbuild r [-s -t]" , __FILE__, bbuild, g);
-  theCommands.Add("bbop"   , "use bbop r op [-s -t]", __FILE__, bbop, g);
-  theCommands.Add("bclear" , "use bclear"           , __FILE__, bclear, 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("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) {
-    di << " use bfillds [-s -t]\n";
+  if (n > 4) {
+    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;
-  bRunParallel=Standard_True;
+  bShowTime = Standard_False;
+  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);
   //
index 01cc7b7..439b185 100644 (file)
@@ -1191,12 +1191,12 @@ static Standard_Boolean MinComputing( BOPTools_CheckCurveOnSurface& theFunction,
 // Function : ComputeTolerance
 // purpose : 
 //=======================================================================
-Standard_Boolean BOPTools_AlgoTools::
-          ComputeTolerance( const Handle(Geom_Curve)& theCurve3D,
-                            const Handle(Geom2d_Curve)& theCurve2D,
-                            const Handle(Geom_Surface)& theSurf,
-                            Standard_Real& theMaxDist,
-                            Standard_Real& theMaxPar)
+Standard_Boolean BOPTools_AlgoTools::ComputeTolerance
+  (const Handle(Geom_Curve)& theCurve3D,
+   const Handle(Geom2d_Curve)& theCurve2D,
+   const Handle(Geom_Surface)& theSurf,
+   Standard_Real& theMaxDist,
+   Standard_Real& theMaxPar)
 {
   if (theCurve3D.IsNull() ||
       theCurve2D.IsNull() ||
index a467961..1fbd068 100644 (file)
 -- 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 
-
-       ---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
-       -- implemented new algorithm is intended to replace the Old
-       -- Boolean Operations algorithm in the BRepAlgoAPI package.
-       -- The New algorithm is free of a large number of weak spots
-       -- and limitations characteristics of the Old algorithm. 
-       -- It is more powerful and flexible. 
-       -- It can process arguments the Old algorithm was not adapted for.
-       -- The new algorithm is based on a new approach to operations
-       -- with interfered shapes. The advantages of the new algorithm
-       -- include an ability to treat arguments that have shared
-       -- entities. It can properly process two solids with shared
-       -- faces (in terms of TopoDS_Shape::IsSame()), two
-       -- faces that have shared edges and so on. Now the New Boolean
-       -- Operation algorithm can treat a wide range of shapes while the
-       -- Old one fails on them.
-       -- A generalization of treatment of same-domain faces
-       -- was included into the New algorithm. Two faces that share
-       -- the same domain are processed according to the common rule
-       -- even if the underlying surfaces are of different types. This
-       -- allows to execute Boolean Operations properly for the same
-       -- domain faces. It also concerns solids and shells that have the
-       -- same domain faces. It is quite frequent when two faces share
-       -- the same domain. And the New algorithm successfully copes
-       -- with it in contrast to the Old one.
-       --  Generalization oftreatment of degenerated edges
-       -- gives a possibility to process them properly. Although there
-       -- are still some difficulties with processing faces in areas close
-       -- to degenerated edges.
-       --  Now the processing of arguments having internal sub-shapes gives
-       -- a correct result. Internal sub-shape means a sub-shape of a
-       -- shape with the orientation TopAbs_INTERNAL and is located
-       -- inside the shape boundaries. The New algorithm processes faces
-       -- with internal edges properly. The new API of the Boolean
-       -- Operations (in addition to the old API) allows to reuse the
-       -- already computed interference between arguments in different
-       -- types of Boolean Operations. It is possible to use once computed
-       -- interference in FUSE, CUT and COMMON operations on given
-       -- arguments. So there is no need to re-compute the interference
-       -- between the arguments. It allows to reduce time for more than one
-       -- operation on given arguments.
-       --   The shape type of a Boolean Operation result and types of the arguments:
-       -- -      For arguments with the same shape type (e.g. SOLID /
-       --   SOLID) the type of the resulting shape will be a
-       --   COMPOUND, containing shapes of this type;
-       -- -      For arguments with different shape types (e.g.
-       --   SHELL / SOLID) the type of the resulting shape will be a
-       --   COMPOUND, containing shapes of the type that is the same as
-       --   that of the low type of the argument. Example: For
-       --   SHELL/SOLID the result is a COMPOUND of SHELLs. 
-       -- -      For arguments with different shape types some of
-       --   Boolean Operations can not be done using the default
-       --   implementation, because of a non-manifold type of the
-       --   result. Example: the FUSE operation for SHELL and SOLID
-       --   can not be done, but the CUT operation can be done, where
-       --   SHELL is the object and SOLID is the tool.
-       -- It is possible to perform Boolean Operations on arguments
-       -- of the COMPOUND shape type. In this case each compound must not
-       -- be heterogeneous, i.e. it must contain equidimensional shapes
-       -- (EDGEs or/and WIREs, FACEs or/and SHELLs, SOLIDs). SOLIDs
-       -- inside the COMPOUND must not contact (intersect or touch)
-       -- 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, 
+   TopTools,
+   TopoDS,
    gp,
    Geom,
-   Geom2d, 
-   BOPAlgo, 
+   Geom2d,
+   Message,
+   BOPCol,
+   BOPAlgo,
    BOPDS,
-   BRepBuilderAPI   
+   BRepBuilderAPI
 is
-            
-    deferred class BooleanOperation; 
-
-    class Fuse;                    
 
-    class Common;                         
-
-    class Cut;                           
+    deferred class BooleanOperation;
+    class Fuse;
+    class Common;
+    class Cut;
+    class Section;
+    class Check;
+    ---Purpose: Check shapes on validity for boolean
+    --- operation.
 
-    class Section;                       
+    deferred class Algo;
+    deferred class BuilderAlgo;
 
-    class Check;
-        ---Purpose: Check shapes on validity for boolean
-        --- operation.
     DumpOper( theFilePath : CString from Standard;
               theShape1 : Shape from TopoDS;
               theShape2 : Shape from TopoDS;
@@ -122,3 +52,70 @@ is
 
 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
+     -- implemented new algorithm is intended to replace the Old
+     -- Boolean Operations algorithm in the BRepAlgoAPI package.
+     -- The New algorithm is free of a large number of weak spots
+     -- and limitations characteristics of the Old algorithm. 
+     -- It is more powerful and flexible. 
+     -- It can process arguments the Old algorithm was not adapted for.
+     -- The new algorithm is based on a new approach to operations
+     -- with interfered shapes. The advantages of the new algorithm
+     -- include an ability to treat arguments that have shared
+     -- entities. It can properly process two solids with shared
+     -- faces (in terms of TopoDS_Shape::IsSame()), two
+     -- faces that have shared edges and so on. Now the New Boolean
+     -- Operation algorithm can treat a wide range of shapes while the
+     -- Old one fails on them.
+     -- A generalization of treatment of same-domain faces
+     -- was included into the New algorithm. Two faces that share
+     -- the same domain are processed according to the common rule
+     -- even if the underlying surfaces are of different types. This
+     -- allows to execute Boolean Operations properly for the same
+     -- domain faces. It also concerns solids and shells that have the
+     -- same domain faces. It is quite frequent when two faces share
+     -- the same domain. And the New algorithm successfully copes
+     -- with it in contrast to the Old one.
+     --  Generalization oftreatment of degenerated edges
+     -- gives a possibility to process them properly. Although there
+     -- are still some difficulties with processing faces in areas close
+     -- to degenerated edges.
+     --  Now the processing of arguments having internal sub-shapes gives
+     -- a correct result. Internal sub-shape means a sub-shape of a
+     -- shape with the orientation TopAbs_INTERNAL and is located
+     -- inside the shape boundaries. The New algorithm processes faces
+     -- with internal edges properly. The new API of the Boolean
+     -- Operations (in addition to the old API) allows to reuse the
+     -- already computed interference between arguments in different
+     -- types of Boolean Operations. It is possible to use once computed
+     -- interference in FUSE, CUT and COMMON operations on given
+     -- arguments. So there is no need to re-compute the interference
+     -- between the arguments. It allows to reduce time for more than one
+     -- operation on given arguments.
+     --   The shape type of a Boolean Operation result and types of the arguments:
+     -- -      For arguments with the same shape type (e.g. SOLID /
+     --   SOLID) the type of the resulting shape will be a
+     --   COMPOUND, containing shapes of this type;
+     -- -      For arguments with different shape types (e.g.
+     --   SHELL / SOLID) the type of the resulting shape will be a
+     --   COMPOUND, containing shapes of the type that is the same as
+     --   that of the low type of the argument. Example: For
+     --   SHELL/SOLID the result is a COMPOUND of SHELLs. 
+     -- -      For arguments with different shape types some of
+     --   Boolean Operations can not be done using the default
+     --   implementation, because of a non-manifold type of the
+     --   result. Example: the FUSE operation for SHELL and SOLID
+     --   can not be done, but the CUT operation can be done, where
+     --   SHELL is the object and SOLID is the tool.
+     -- It is possible to perform Boolean Operations on arguments
+     -- of the COMPOUND shape type. In this case each compound must not
+     -- be heterogeneous, i.e. it must contain equidimensional shapes
+     -- (EDGEs or/and WIREs, FACEs or/and SHELLs, SOLIDs). SOLIDs
+     -- inside the COMPOUND must not contact (intersect or touch)
+     -- 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.
diff --git a/src/BRepAlgoAPI/BRepAlgoAPI_Algo.cdl b/src/BRepAlgoAPI/BRepAlgoAPI_Algo.cdl
new file mode 100644 (file)
index 0000000..77e4f92
--- /dev/null
@@ -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;
diff --git a/src/BRepAlgoAPI/BRepAlgoAPI_Algo.cxx b/src/BRepAlgoAPI/BRepAlgoAPI_Algo.cxx
new file mode 100644 (file)
index 0000000..a48f78b
--- /dev/null
@@ -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
index b2208d4..43fbd29 100644 (file)
 -- 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).
@@ -33,91 +29,86 @@ deferred class BooleanOperation from BRepAlgoAPI
   
 uses
 
-    Shape       from TopoDS,
+    Shape from TopoDS, 
+    DataMapOfShapeShape from TopTools, 
     ListOfShape from TopTools,
-    Operation   from BOPAlgo,  
-    Builder    from BOPAlgo,
-    PBuilder    from BOPAlgo,
-    PaveFiller  from BOPAlgo, 
-    PPaveFiller from BOPAlgo,
-    DataMapOfIntegerListOfShape  from  TopTools, 
-    DataMapOfIntegerShape  from  TopTools,
-    DataMapOfShapeShape  from  TopTools 
+    Operation   from BOPAlgo,
+    PaveFiller from BOPAlgo
     
-is
+is 
+    Initialize
+        returns BooleanOperation from BRepAlgoAPI; 
 
     Initialize (S1 :Shape from TopoDS;  
-            S2 :Shape from TopoDS; 
-          anOperation:Operation from BOPAlgo);
+                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;               
-            anOperation:Operation from BOPAlgo); 
+                S2   :Shape from TopoDS; 
+                aPF  :PaveFiller from BOPAlgo;               
+                anOperation:Operation from BOPAlgo); 
      ---Purpose: Prepares the operations for S1 and S2.
 
-    SetOperation (me:out; 
-            anOp:  Operation from BOPAlgo); 
-    ---Purpose:  Sets the type of Boolean operation to perform      
-    ---          It can be BOPAlgo_SECTION 
-    ---                    BOPAlgo_COMMON 
-    ---                    BOPAlgo_FUSE 
-    ---                    BOPAlgo_CUT 
-    ---                    BOPAlgo_CUT21 
-    --- 
-  
-
-    Build  (me:out) 
-        is redefined virtual; 
-    ---Purpose: Provides the algorithm of Boolean Operations
-    -- -      Filling interference Data Structure (if it is necessary)
-    -- -      Building the result of the operation.
+   
     
+    SetShape1(me:out; 
+            S:Shape from TopoDS); 
+
+    SetShape2(me:out; 
+            S:Shape from TopoDS);  
     Shape1(me)   
         returns Shape from TopoDS 
-        is static;
+        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      
+    ---          It can be BOPAlgo_SECTION 
+    ---                    BOPAlgo_COMMON 
+    ---                    BOPAlgo_FUSE 
+    ---                    BOPAlgo_CUT 
+    ---                    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; 
+    ---Purpose: Provides the algorithm of Boolean Operations
+    -- -      Filling interference Data Structure (if it is necessary)
+    -- -      Building the result of the operation. 
+     
+    BuilderCanWork(me)  
+        returns Boolean from Standard;  
     FuseEdges(me)   
-        returns  Boolean  from  Standard;
-    ---Purpose: Returns the flag of edge refining
+        returns Boolean from Standard;
+    ---Purpose: Returns the flag of edge refining  
      
     RefineEdges(me:out);
     ---Purpose: Fuse C1 edges
-
-    PrepareFiller(me:out) 
-        returns Boolean from Standard 
-        is protected;   
-  
-    ---Category: Querying
-    BuilderCanWork(me)  
-        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
-
+     
+     SectionEdges (me:  in  out)  
+        returns ListOfShape from TopTools;    
+    --- Purpose: Returns a list of section edges.
+    -- The edges represent the result of intersection between arguments of
+    -- Boolean Operation. They are computed during operation execution.
+    ---C++:  return const &  
+         
     Modified (me: in out;  
             aS : Shape from TopoDS) 
         returns ListOfShape from TopTools
@@ -157,39 +148,34 @@ is
         is virtual;
     ---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();}" 
-     
-    SectionEdges (me:  in  out)  
-        returns ListOfShape from TopTools;    
-    --- Purpose: Returns a list of section edges.
-    -- The edges represent the result of intersection between arguments of
-    -- Boolean Operation. They are computed during operation execution.
-    ---C++:  return const &  
-
+    --  
+    -- protected 
+    --    
+    PrepareFiller(me:out) 
+        returns Boolean from Standard 
+        is protected;      
+       
     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 &
-
+    
 fields
-    myS1             : Shape from TopoDS        is protected;
-    myS2             : Shape from TopoDS        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;   
-
+    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;  
+     
     --    for  edge  refiner
-    myFuseEdges      : Boolean  from  Standard ; 
-    myModifFaces     : DataMapOfShapeShape  from  TopTools;   
-    myEdgeMap        : DataMapOfShapeShape  from  TopTools;
+    myFuseEdges      : Boolean from Standard ; 
+    myModifFaces     : DataMapOfShapeShape from TopTools;   
+    myEdgeMap        : DataMapOfShapeShape from TopTools; 
     
 end BooleanOperation;
 
index 28cfa30..24a9841 100644 (file)
 
 #include <BRepAlgoAPI_BooleanOperation.ixx>
 
-#include <BRepAlgoAPI.hxx>
-#include <BRepAlgoAPI_Check.hxx>
-
-#include <BRepLib_FuseEdges.hxx>
 #include <TopExp.hxx>
-#include <TopTools_MapOfShape.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, 
-                                                             const TopoDS_Shape& aS2,
-                                                             const BOPAlgo_PaveFiller& aDSFiller,
-                                                             const BOPAlgo_Operation anOp)
+BRepAlgoAPI_BooleanOperation::BRepAlgoAPI_BooleanOperation
+  (const TopoDS_Shape& aS1, 
+   const TopoDS_Shape& aS2,
+   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*)&aDSFiller;
-  }
+  myDSFiller=(BOPAlgo_PaveFiller*)&aPF;
 }
 //=======================================================================
-//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
-//purpose  : 
-//=======================================================================
-  Standard_Integer BRepAlgoAPI_BooleanOperation::ErrorStatus()const
-{
-  return myErrorStatus;    
-}
-//=======================================================================
-//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
+//function : FuseEdges
 //purpose  : 
 //=======================================================================
-  Standard_Boolean BRepAlgoAPI_BooleanOperation::IsDeleted(const TopoDS_Shape& aS) 
+Standard_Boolean BRepAlgoAPI_BooleanOperation::FuseEdges ()const
 {
-  Standard_Boolean bDeleted = Standard_True; 
-  if (myBuilder != NULL) {
-    bDeleted=myBuilder->IsDeleted(aS);
-  }
-  return bDeleted; 
+  return myFuseEdges;
 }
-
 //=======================================================================
 //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,115 +305,11 @@ const TopTools_ListOfShape& BRepAlgoAPI_BooleanOperation::Modified(const TopoDS_
   }
 }
 
-//
-//=======================================================================
-//function : SectionEdges
-//purpose  : 
-//=======================================================================
-const  TopTools_ListOfShape& BRepAlgoAPI_BooleanOperation::SectionEdges()
-{
-  if (myBuilder==NULL) {
-    myGenerated.Clear();
-    return myGenerated;
-  }
-  //
-  Standard_Integer aNb, i, j, aNbCurves, nE;
-  BOPDS_ListIteratorOfListOfPaveBlock anIt;
-  //
-  const BOPDS_PDS& pDS = myDSFiller->PDS();
-  BOPDS_VectorOfInterfFF& aFFs=pDS->InterfFF();
-  myGenerated.Clear();
-  //
-  aNb=aFFs.Extent();
-  for (i = 0; i < aNb; i++) {
-    BOPDS_InterfFF& aFFi=aFFs(i);
-    const BOPDS_VectorOfCurve& aSeqOfCurve=aFFi.Curves();
-    //
-    aNbCurves=aSeqOfCurve.Extent();
-    for (j=0; j<aNbCurves; j++) {
-      const BOPDS_Curve& aCurve=aSeqOfCurve(j);
-      const BOPDS_ListOfPaveBlock& aSectEdges = aCurve.PaveBlocks();
-      //
-      anIt.Initialize(aSectEdges);
-      for(; anIt.More(); anIt.Next()) {
-        const Handle(BOPDS_PaveBlock)& aPB = anIt.Value();
-        nE = aPB->Edge();
-        const TopoDS_Shape& aE = pDS->Shape(nE);
-        myGenerated.Append(aE);
-      }
-    }
-  }
-  //
-  if(myFuseEdges) {
-    TopTools_ListOfShape theLS;
-    theLS.Assign(myGenerated);
-    //
-    RefinedList(theLS);
-  }
-  //
-  return myGenerated;
-}
-
-// ================================================================================================
-// function: Generated
-// purpose:
-// ================================================================================================
-const TopTools_ListOfShape& BRepAlgoAPI_BooleanOperation::Generated(const TopoDS_Shape& S) 
-{
-  if (myBuilder==NULL) {
-    myGenerated.Clear();
-    return myGenerated;
-  }
-  //
-  if(myFuseEdges) {
-    const TopTools_ListOfShape& aL = myBuilder->Generated(S);
-    return RefinedList(aL);
-  }
-  
-  return myBuilder->Generated(S);
-}
-
-// ================================================================================================
-// function: HasModified
-// purpose:
-// ================================================================================================
-Standard_Boolean BRepAlgoAPI_BooleanOperation::HasModified() const
-{
-  if (myBuilder==NULL) {
-    return Standard_False;
-  }
-  return myBuilder->HasModified();
-}
-
-// ================================================================================================
-// function: HasGenerated
-// purpose:
-// ================================================================================================
-Standard_Boolean BRepAlgoAPI_BooleanOperation::HasGenerated() const
-{
-  if (myBuilder==NULL) {
-    return Standard_False;
-  }
-  return myBuilder->HasGenerated();
-}
-
-// ================================================================================================
-// function: HasDeleted
-// purpose:
-// ================================================================================================
-Standard_Boolean BRepAlgoAPI_BooleanOperation::HasDeleted() const
-{
-  if (myBuilder==NULL) {
-    return Standard_False;
-  }
-  return myBuilder->HasDeleted();
-}
 //=======================================================================
 //function : RefineEdges
 //purpose  : 
 //=======================================================================
-
-  void BRepAlgoAPI_BooleanOperation::RefineEdges ()
+void BRepAlgoAPI_BooleanOperation::RefineEdges ()
 {
   if(myFuseEdges) return; //Edges have been refined yet
 
@@ -466,13 +351,12 @@ Standard_Boolean BRepAlgoAPI_BooleanOperation::HasDeleted() const
     }
   }
 }
-
 //=======================================================================
 //function : RefinedList
 //purpose  : 
 //=======================================================================
-const TopTools_ListOfShape& 
-  BRepAlgoAPI_BooleanOperation::RefinedList(const TopTools_ListOfShape& theL) 
+const TopTools_ListOfShape& BRepAlgoAPI_BooleanOperation::RefinedList
+  (const TopTools_ListOfShape& theL) 
 {
   myGenerated.Clear();
   TopTools_MapOfShape aMap;
@@ -509,3 +393,139 @@ const TopTools_ListOfShape&
   return myGenerated;
 
 }
+//=======================================================================
+//function : SectionEdges
+//purpose  : 
+//=======================================================================
+const TopTools_ListOfShape& BRepAlgoAPI_BooleanOperation::SectionEdges()
+{
+  if (myBuilder==NULL) {
+    myGenerated.Clear();
+    return myGenerated;
+  }
+  //
+  Standard_Integer aNb, i, j, aNbCurves, nE;
+  BOPDS_ListIteratorOfListOfPaveBlock anIt;
+  //
+  const BOPDS_PDS& pDS = myDSFiller->PDS();
+  BOPDS_VectorOfInterfFF& aFFs=pDS->InterfFF();
+  myGenerated.Clear();
+  //
+  aNb=aFFs.Extent();
+  for (i = 0; i < aNb; i++) {
+    BOPDS_InterfFF& aFFi=aFFs(i);
+    const BOPDS_VectorOfCurve& aSeqOfCurve=aFFi.Curves();
+    //
+    aNbCurves=aSeqOfCurve.Extent();
+    for (j=0; j<aNbCurves; j++) {
+      const BOPDS_Curve& aCurve=aSeqOfCurve(j);
+      const BOPDS_ListOfPaveBlock& aSectEdges = aCurve.PaveBlocks();
+      //
+      anIt.Initialize(aSectEdges);
+      for(; anIt.More(); anIt.Next()) {
+        const Handle(BOPDS_PaveBlock)& aPB = anIt.Value();
+        nE = aPB->Edge();
+        const TopoDS_Shape& aE = pDS->Shape(nE);
+        myGenerated.Append(aE);
+      }
+    }
+  }
+  //
+  if(myFuseEdges) {
+    TopTools_ListOfShape theLS;
+    theLS.Assign(myGenerated);
+    //
+    RefinedList(theLS);
+  }
+  //
+  return myGenerated;
+}
+//=======================================================================
+//function : Generated
+//purpose  : 
+//=======================================================================
+const TopTools_ListOfShape& BRepAlgoAPI_BooleanOperation::Generated
+  (const TopoDS_Shape& S) 
+{
+  if (myBuilder==NULL) {
+    myGenerated.Clear();
+    return myGenerated;
+  }
+  //
+  if(myFuseEdges) {
+    const TopTools_ListOfShape& aL = myBuilder->Generated(S);
+    return RefinedList(aL);
+  }
+  
+  return myBuilder->Generated(S);
+}
+
+//=======================================================================
+//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 : HasModified
+//purpose  : 
+//=======================================================================
+Standard_Boolean BRepAlgoAPI_BooleanOperation::HasModified() const
+{
+  if (myBuilder==NULL) {
+    return Standard_False;
+  }
+  return myBuilder->HasModified();
+}
+//=======================================================================
+//function : HasGenerated
+//purpose  : 
+//=======================================================================
+Standard_Boolean BRepAlgoAPI_BooleanOperation::HasGenerated() const
+{
+  if (myBuilder==NULL) {
+    return Standard_False;
+  }
+  return myBuilder->HasGenerated();
+}
+//=======================================================================
+//function : HasDeleted
+//purpose  : 
+//=======================================================================
+Standard_Boolean BRepAlgoAPI_BooleanOperation::HasDeleted() const
+{
+  if (myBuilder==NULL) {
+    return Standard_False;
+  }
+  return myBuilder->HasDeleted();
+}
diff --git a/src/BRepAlgoAPI/BRepAlgoAPI_BuilderAlgo.cdl b/src/BRepAlgoAPI/BRepAlgoAPI_BuilderAlgo.cdl
new file mode 100644 (file)
index 0000000..c5a1b53
--- /dev/null
@@ -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;
diff --git a/src/BRepAlgoAPI/BRepAlgoAPI_BuilderAlgo.cxx b/src/BRepAlgoAPI/BRepAlgoAPI_BuilderAlgo.cxx
new file mode 100644 (file)
index 0000000..6eee113
--- /dev/null
@@ -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;
+}
index d414e0c..6da4f01 100644 (file)
@@ -13,7 +13,8 @@
 -- Alternatively, this file may be used under the terms of Open CASCADE
 -- commercial license or contractual agreement.
 
-class Check from BRepAlgoAPI
+class Check from BRepAlgoAPI 
+  inherits Algo from BRepAlgoAPI
     ---Purpose:  
     -- The class Check provides a diagnostic tool for checking  
     -- single shape or couple of shapes. 
@@ -115,11 +116,20 @@ is
       returns ListOfCheckResult from BOPAlgo;  
     ---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;
+  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;
 
index 65d6287..4c558a1 100644 (file)
 //function : BRepAlgoAPI_Check
 //purpose  : 
 //=======================================================================
-  BRepAlgoAPI_Check::BRepAlgoAPI_Check()
-: myAnalyzer(NULL)
+BRepAlgoAPI_Check::BRepAlgoAPI_Check()
+: 
+  BRepAlgoAPI_Algo(),
+  myAnalyzer(NULL),
+  myFuzzyValue(0.)
 {
 }
 
 //function : BRepAlgoAPI_Check
 //purpose  : 
 //=======================================================================
-  BRepAlgoAPI_Check::BRepAlgoAPI_Check(const TopoDS_Shape& theS,
-                                       const Standard_Boolean bTestSE,
-                                       const Standard_Boolean bTestSI)
+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);
   //
 //function : BRepAlgoAPI_Check
 //purpose  : 
 //=======================================================================
-  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_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;
 }
 
 //=======================================================================
+//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,
-                                  const Standard_Boolean bTestSE,
-                                  const Standard_Boolean bTestSI)
+void BRepAlgoAPI_Check::SetData(const TopoDS_Shape& theS,
+                                const Standard_Boolean bTestSE,
+                                const Standard_Boolean bTestSI)
 {
   Init(theS, TopoDS_Shape(), BOPAlgo_UNKNOWN, bTestSE, bTestSI);
 }
 //function : SetData
 //purpose  : 
 //=======================================================================
-  void BRepAlgoAPI_Check::SetData(const TopoDS_Shape& theS1,
-                                  const TopoDS_Shape& theS2,
-                                  const BOPAlgo_Operation theOp,
-                                  const Standard_Boolean bTestSE,
-                                  const Standard_Boolean bTestSI)
+void BRepAlgoAPI_Check::SetData(const TopoDS_Shape& theS1,
+                                const TopoDS_Shape& theS2,
+                                const BOPAlgo_Operation theOp,
+                                const Standard_Boolean bTestSE,
+                                const Standard_Boolean bTestSI)
 {
   Init(theS1, theS2, theOp, bTestSE, bTestSI);
 }
-
-
 //=======================================================================
 //function : Init
 //purpose  : 
 //=======================================================================
-  void BRepAlgoAPI_Check::Init(const TopoDS_Shape& theS1,
-                               const TopoDS_Shape& theS2,
-                               const BOPAlgo_Operation theOp,
-                               const Standard_Boolean bTestSE,
-                               const Standard_Boolean bTestSI)
+void BRepAlgoAPI_Check::Init(const TopoDS_Shape& theS1,
+                             const TopoDS_Shape& theS2,
+                             const BOPAlgo_Operation theOp,
+                             const Standard_Boolean bTestSE,
+                             const Standard_Boolean bTestSI)
 {
   myResult.Clear();
   myS1 = theS1;
   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;
 }
 //function : IsValid
 //purpose  : 
 //=======================================================================
-  Standard_Boolean BRepAlgoAPI_Check::IsValid()
+Standard_Boolean BRepAlgoAPI_Check::IsValid()
 {
   return myResult.IsEmpty();
 }
 //function : Perform
 //purpose  : 
 //=======================================================================
-  void BRepAlgoAPI_Check::Perform()
+void BRepAlgoAPI_Check::Perform()
 {
   Standard_Boolean isS1, isS2;
   //incompatibility of shape types, small edges and self-interference
     myResult.Append(aRes);
   }
 }
-
-
index 5ae903f..3e221a6 100644 (file)
 -- 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).
-       --  The class Common provides a framework for:
-       -- -           Defining the construction of a common shape;
-       -- -           Implementing the   building algorithm
-       -- -           Consulting the result.
+ ---Purpose: The class Common provides a
+     -- Boolean common operation on a pair of arguments (Boolean Intersection).
+     --  The class Common provides a framework for:
+     -- -           Defining the construction of a common shape;
+     -- -           Implementing the   building algorithm
+     -- -           Consulting the result.
 
 uses
     Shape from TopoDS, 
     PaveFiller from BOPAlgo
 
-is
+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 .
+     returns Common from BRepAlgoAPI;  
+    ---Purpose: Constructs a common part for shapes aS1 and aS2 .
  
     Create (S1,S2 : Shape from TopoDS; 
-           aDSF:PaveFiller from BOPAlgo)  
-       returns Common from BRepAlgoAPI;
+         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
+
index 70d34f6..587cb94 100644 (file)
 //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  : 
+//=======================================================================
   BRepAlgoAPI_Common::BRepAlgoAPI_Common(const TopoDS_Shape& S1, 
                                          const TopoDS_Shape& S2)
 : BRepAlgoAPI_BooleanOperation(S1, S2, BOPAlgo_COMMON)
index 7540145..89e7772 100644 (file)
 -- 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
-       ---Purpose:  The class Cut provides a Boolean
-       -- cut operation on a pair of arguments (Boolean Subtraction).
-       -- The class Cut provides a framework for:
-       --   -      Defining the construction of a cut shape
-       --   -      Implementing the building algorithm
-       --   -      Consulting the result
+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:
+     --   -      Defining the construction of a cut shape
+     --   -      Implementing the building algorithm
+     --   -      Consulting the result
 
 uses
     Shape from TopoDS,
     PaveFiller from BOPAlgo
 
-is
+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
-       -- resulting shape is a new shape produced by the cut operation.
-       
+        returns Cut from BRepAlgoAPI;  
+    ---Purpose: Shape aS2 cuts shape aS1. The
+     -- resulting shape is a new shape produced by the cut operation.
 
     Create (S1,S2 : Shape from TopoDS; 
-           aDSF  : PaveFiller  from BOPAlgo; 
-           bFWD  : Boolean from Standard=Standard_True)  
-       returns Cut from BRepAlgoAPI;    
-       --- Purpose: Constructs a new shape cut from
-       -- shape aS1 by shape aS2 using aDSFiller (see
-       -- BRepAlgoAPI_BooleanOperation Constructor).
+            aDSF  : PaveFiller  from BOPAlgo; 
+            bFWD  : Boolean from Standard=Standard_True)  
+        returns Cut from BRepAlgoAPI;  
+     --- Purpose: Constructs a new shape cut from
+     -- shape aS1 by shape aS2 using aDSFiller (see
+     -- BRepAlgoAPI_BooleanOperation Constructor).
         
 end Cut;
index 665517f..5870c1e 100644 (file)
 //function : BRepAlgoAPI_Cut
 //purpose  : 
 //=======================================================================
-  BRepAlgoAPI_Cut::BRepAlgoAPI_Cut(const TopoDS_Shape& S1, 
-                                   const TopoDS_Shape& S2)
-: BRepAlgoAPI_BooleanOperation(S1, S2, BOPAlgo_CUT)
+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* pBO=
     (BRepAlgoAPI_BooleanOperation*) (void*) this;
 //function : BRepAlgoAPI_Cut
 //purpose  : 
 //=======================================================================
-  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_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* pBO=
     (BRepAlgoAPI_BooleanOperation*) (void*) this;
index dcd56a2..e775745 100644 (file)
 
 class Fuse from BRepAlgoAPI inherits BooleanOperation from BRepAlgoAPI
 
-       ---Purpose:  The class Fuse provides a
-       -- Boolean fusion operation on a pair of arguments (Boolean Union).
-       -- The class Fuse provides a framework for:
-       --   -       Defining the construction of a fused shape;
-       --   -       Implementing the building algorithm
-       --   -       Consulting the result.
+ ---Purpose:  The class Fuse provides a
+     -- Boolean fusion operation on a pair of arguments (Boolean Union).
+     -- The class Fuse provides a framework for:
+     --   -       Defining the construction of a fused shape;
+     --   -       Implementing the building algorithm
+     --   -       Consulting the result.
 
 uses
     Shape from TopoDS, 
     PaveFiller from BOPAlgo
 
-is
+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.
-        
+        returns Fuse from BRepAlgoAPI;  
+    ---Purpose: Constructs a fuse of shapes aS1 and aS2.
+  
     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. 
+            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;
index bca9efa..c3dfeb3 100644 (file)
 //function : BRepAlgoAPI_Fuse
 //purpose  : 
 //=======================================================================
-  BRepAlgoAPI_Fuse::BRepAlgoAPI_Fuse(const TopoDS_Shape& S1, 
-                                     const TopoDS_Shape& S2)
-: BRepAlgoAPI_BooleanOperation(S1, S2, BOPAlgo_FUSE)
+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* pBO=
     (BRepAlgoAPI_BooleanOperation*) (void*) this;
 //function : BRepAlgoAPI_Fuse
 //purpose  : 
 //=======================================================================
-  BRepAlgoAPI_Fuse::BRepAlgoAPI_Fuse(const TopoDS_Shape& S1, 
-                                     const TopoDS_Shape& S2,
-                                     const BOPAlgo_PaveFiller& aDSF)
-: BRepAlgoAPI_BooleanOperation(S1, S2, aDSF, BOPAlgo_FUSE)
+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* pBO=
     (BRepAlgoAPI_BooleanOperation*) (void*) this;
index 98ec42e..4ec3712 100644 (file)
 
 -- 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.
-       -- Geometries are converted to faces
-       -- When a geometry has been converted to
-       -- topology the created shape can be found using
-       -- the methods Shape1 and Shape2 inherited from the class BooleanOperation.
-       -- The result (Shape() method) is a compound containing 
-       -- edges built on intersection curves.
-       -- By default, the section is performed immediatly in 
-       -- class constructors, with default values :
-       -- - geometries built are NOT approximated.
-       -- - PCurves are NOT computed on both parts.
-       -- Example : giving two shapes S1,S2 accessing faces,
-       -- let compute the section edges R on S1,S2, 
-       -- performing approximation on new curves,
-       -- performing PCurve on part 1 but not on part 2 :
-       -- Standard_Boolean PerformNow = Standard_False;
-       -- BRepBoolAPI_Section S(S1,S2,PerformNow);
-       -- S.ComputePCurveOn1(Standard_True);
-       -- S.Approximation(Standard_True);
-       -- S.Build();
-       -- TopoDS_Shape R = S.Shape();
-       -- On Null Shapes of geometries, NotDone() is called. 
+     ---Purpose: Computes the intersection of two shapes or geometries.
+     -- Geometries can be surfaces of planes.
+     -- Geometries are converted to faces
+     -- When a geometry has been converted to
+     -- topology the created shape can be found using
+     -- the methods Shape1 and Shape2 inherited from the class BooleanOperation.
+     -- The result (Shape() method) is a compound containing 
+     -- edges built on intersection curves.
+     -- By default, the section is performed immediatly in 
+     -- class constructors, with default values :
+     -- - geometries built are NOT approximated.
+     -- - PCurves are NOT computed on both parts.
+     -- Example : giving two shapes S1,S2 accessing faces,
+     -- let compute the section edges R on S1,S2, 
+     -- performing approximation on new curves,
+     -- performing PCurve on part 1 but not on part 2 :
+     -- Standard_Boolean PerformNow = Standard_False;
+     -- BRepBoolAPI_Section S(S1,S2,PerformNow);
+     -- S.ComputePCurveOn1(Standard_True);
+     -- S.Approximation(Standard_True);
+     -- S.Build();
+     -- TopoDS_Shape R = S.Shape();
+     -- On Null Shapes of geometries, NotDone() is called. 
 
 uses
     Pln   from gp,
@@ -51,262 +52,289 @@ uses
     ListOfShape from TopTools
     
 is
-        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 
+        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;
+    
 
     Create(Sh1,Sh2 : Shape from TopoDS;
-          PerformNow : Boolean = Standard_True)
-       ---Purpose: see upper
-       ---Level: Public
-       returns Section from BRepAlgoAPI;
-
-    Create(Sh : Shape from TopoDS; Pl : Pln from gp;
-          PerformNow : Boolean = Standard_True)
-       ---Purpose: see upper
-       ---Level: Public
-       returns Section from BRepAlgoAPI;
+            PerformNow : Boolean = Standard_True) 
+        returns Section from BRepAlgoAPI;
+    ---Purpose: see upper
+    ---Level: Public
+     
 
-    Create(Sh : Shape from TopoDS; Sf : Surface from Geom;
-          PerformNow : Boolean = Standard_True)
-       ---Purpose: see upper
-       ---Level: Public
-       returns Section from BRepAlgoAPI;
+    Create(Sh : Shape from TopoDS;  
+            Pl : Pln from gp;
+            PerformNow : Boolean = Standard_True) 
+        returns Section from BRepAlgoAPI;
+     ---Purpose: see upper
+     ---Level: Public
+     
 
-    Create(Sf : Surface from Geom; Sh : Shape from TopoDS;
-          PerformNow : Boolean = Standard_True)
-       ---Purpose: see upper
-       ---Level: Public
-       returns Section from BRepAlgoAPI;
+    Create(Sh : Shape from TopoDS;  
+            Sf : Surface from Geom;
+            PerformNow : Boolean = Standard_True) 
+        returns Section from BRepAlgoAPI;
+     ---Purpose: see upper
+     ---Level: Public
+     
 
-    Create(Sf1 : Surface from Geom; Sf2 : Surface from Geom;
-       PerformNow : Boolean = Standard_True)
-       ---Purpose: This and the above classes construct a framework for
-       -- computing the section lines of:
-       -- -       two shapes Sh1 and Sh2, or
-       -- -       shape Sh and plane Pl,  or
-       -- -       shape Sh and surface Sf, or
-       -- -       surface Sf and shape Sh, or
-       -- -       two surfaces Sf1 and Sf2,
-       --   and builds a result if PerformNow equals true, its
-       -- default value. If PerformNow equals false, the intersection
-       -- will be computed later by the function Build.
-       --  The constructed shape will be returned by the function Shape.
-       -- This is a compound object composed of edges. These
-       -- intersection edges may be built:
-       -- -      on new intersection lines, or
-       -- -      on coincident portions of edges in the two intersected    shapes.
-       --   These intersection edges are independent: they are not
-       -- chained or grouped in wires. If no intersection edge exists, the
-       -- result is an empty compound object.
-       -- Note that other objects than TopoDS_Shape shapes involved in
-       -- these syntaxes are converted into faces or shells before
-       -- performing the computation of the intersection. A shape
-       -- resulting from this conversion can be retrieved with the
-       -- function Shape1 or Shape2.
-       -- Parametric 2D curves on intersection edges
-       -- No parametric 2D curve (pcurve) is defined for each elementary
-       -- edge of the result. To attach such parametric curves to the
-       -- constructed edges you may use a constructor with the PerformNow
-       -- flag equal to false; then you use:
-       -- -      the function ComputePCurveOn1 to ask for
-       --    the additional computation of a pcurve in the parametric
-       --    space of the first shape,
-       -- -      the function ComputePCurveOn2 to ask for
-       --    the additional computation of a pcurve in the parametric
-       --    space of the second shape, in the end,
-       -- -      the function Build to construct the result.
-       --   Approximation of intersection edges
-       --   The underlying 3D geometry attached to each elementary edge
-       -- of the result is:
-       -- -       analytic where possible, provided the corresponding
-       --    geometry corresponds to a type of analytic curve
-       --    defined in the Geom package; for example, the intersection
-       --    of a cylindrical shape with a plane gives an ellipse or a    circle;
-       -- -       or elsewhere, given as a succession of points grouped
-       --    together in a BSpline curve of degree 1.
-       -- If you prefer to have an attached 3D geometry which is a
-       -- BSpline approximation of the computed set of points on
-       -- computed elementary intersection edges whose underlying geometry
-       -- is not analytic, you may use a constructor with the PerformNow
-       -- flag equal to false. Then you use:
-       -- -      the function Approximation to ask for this
-       --    computation option, and
-       -- -      the function Build to construct the result.
-       -- -      Note that as a result, approximations will only be
-       --    computed on edges built on new intersection lines.
-       -- -      Example
-       -- You may also combine these computation options. In the following example:
-       -- - each elementary edge of the computed intersection,
-       --   built on a new intersection line, which does not
-       --  correspond to an analytic Geom curve, will be approximated by
-       --   a BSpline curve whose degree is not greater than 8.
-       -- - each elementary edge built on a new intersection line, will have:
-       -- - a pcurve in the parametric space of the intersected face of shape S1,
-       -- - no pcurve in the parametric space of the intersected face of shape S2.
-       --       // TopoDS_Shape S1 = ... , S2 = ... ;
-       -- Standard_Boolean PerformNow = Standard_False;
-       -- BRepAlgoAPI_Section S ( S1, S2, PerformNow );
-       -- S.ComputePCurveOn1 (Standard_True);
-       -- S.Approximation (Standard_True);
-       -- S.Build();
-       -- TopoDS_Shape R = S.Shape();
-       returns Section from BRepAlgoAPI;
+    Create(Sf : Surface from Geom;  
+            Sh : Shape from TopoDS;
+            PerformNow : Boolean = Standard_True) 
+        returns Section from BRepAlgoAPI;
+     ---Purpose: see upper
+     ---Level: Public
+    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
+     -- -       shape Sh and plane Pl,  or
+     -- -       shape Sh and surface Sf, or
+     -- -       surface Sf and shape Sh, or
+     -- -       two surfaces Sf1 and Sf2,
+     --   and builds a result if PerformNow equals true, its
+     -- default value. If PerformNow equals false, the intersection
+     -- will be computed later by the function Build.
+     --  The constructed shape will be returned by the function Shape.
+     -- This is a compound object composed of edges. These
+     -- intersection edges may be built:
+     -- -      on new intersection lines, or
+     -- -      on coincident portions of edges in the two intersected    shapes.
+     --   These intersection edges are independent: they are not
+     -- chained or grouped in wires. If no intersection edge exists, the
+     -- result is an empty compound object.
+     -- Note that other objects than TopoDS_Shape shapes involved in
+     -- these syntaxes are converted into faces or shells before
+     -- performing the computation of the intersection. A shape
+     -- resulting from this conversion can be retrieved with the
+     -- function Shape1 or Shape2.
+     -- Parametric 2D curves on intersection edges
+     -- No parametric 2D curve (pcurve) is defined for each elementary
+     -- edge of the result. To attach such parametric curves to the
+     -- constructed edges you may use a constructor with the PerformNow
+     -- flag equal to false; then you use:
+     -- -      the function ComputePCurveOn1 to ask for
+     --    the additional computation of a pcurve in the parametric
+     --    space of the first shape,
+     -- -      the function ComputePCurveOn2 to ask for
+     --    the additional computation of a pcurve in the parametric
+     --    space of the second shape, in the end,
+     -- -      the function Build to construct the result.
+     --   Approximation of intersection edges
+     --   The underlying 3D geometry attached to each elementary edge
+     -- of the result is:
+     -- -       analytic where possible, provided the corresponding
+     --    geometry corresponds to a type of analytic curve
+     --    defined in the Geom package; for example, the intersection
+     --    of a cylindrical shape with a plane gives an ellipse or a    circle;
+     -- -       or elsewhere, given as a succession of points grouped
+     --    together in a BSpline curve of degree 1.
+     -- If you prefer to have an attached 3D geometry which is a
+     -- BSpline approximation of the computed set of points on
+     -- computed elementary intersection edges whose underlying geometry
+     -- is not analytic, you may use a constructor with the PerformNow
+     -- flag equal to false. Then you use:
+     -- -      the function Approximation to ask for this
+     --    computation option, and
+     -- -      the function Build to construct the result.
+     -- -      Note that as a result, approximations will only be
+     --    computed on edges built on new intersection lines.
+     -- -      Example
+     -- You may also combine these computation options. In the following example:
+     -- - each elementary edge of the computed intersection,
+     --   built on a new intersection line, which does not
+     --  correspond to an analytic Geom curve, will be approximated by
+     --   a BSpline curve whose degree is not greater than 8.
+     -- - each elementary edge built on a new intersection line, will have:
+     -- - a pcurve in the parametric space of the intersected face of shape S1,
+     -- - no pcurve in the parametric space of the intersected face of shape S2.
+     --       // TopoDS_Shape S1 = ... , S2 = ... ;
+     -- Standard_Boolean PerformNow = Standard_False;
+     -- BRepAlgoAPI_Section S ( S1, S2, PerformNow );
+     -- S.ComputePCurveOn1 (Standard_True);
+     -- S.Approximation (Standard_True);
+     -- S.Build();
+     -- TopoDS_Shape R = S.Shape();
 
-    Init1(me : out;S1 : Shape from TopoDS);
-       ---Purpose: initialize first part
-       ---Level: Public
+    Init1(me : out; 
+            S1 : Shape from TopoDS);
+     ---Purpose: initialize first part
+     ---Level: Public
  
-    Init1(me : out;Pl : Pln from gp);
-       ---Purpose: initialize first part
-       ---Level: Public
+    Init1(me : out; 
+            Pl : Pln from gp);
+     ---Purpose: initialize first part
+     ---Level: Public
  
-    Init1(me : out;Sf : Surface from Geom);
-       ---Purpose: initialize first part
-       ---Level: Public
+    Init1(me : out; 
+            Sf : Surface from Geom);
+     ---Purpose: initialize first part
+     ---Level: Public
  
-    Init2(me : out;S2 : Shape from TopoDS);
-       ---Purpose: initialize second part
-       ---Level: Public
+    Init2(me : out; 
+            S2 : Shape from TopoDS);
+     ---Purpose: initialize second part
+     ---Level: Public
  
-    Init2(me : out;Pl : Pln from gp);
-       ---Purpose: initialize second part
-       ---Level: Public
+    Init2(me : out; 
+            Pl : Pln from gp);
+     ---Purpose: initialize second part
+     ---Level: Public
  
-    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.
+    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);
-       ---Level: Public
-       ---Purpose: Defines an option for computation
-       -- of further intersections. This computation will be performed by
-       -- the function Build in this framework.
-       -- By default, the underlying 3D geometry attached to each
-       -- elementary edge of the result of a computed intersection is:
-       -- - analytic where possible, provided the corresponding
-       --    geometry corresponds to a type of analytic curve defined in
-       --    the Geom package; for example the intersection of a
-       --    cylindrical shape with a plane gives an ellipse or a circle;
-       -- -      or elsewhere, given as a succession of points grouped
-       -- together in a BSpline curve of degree 1. If Approx equals
-       -- true, when further computations are performed in this framework
-       -- with the function Build, these edges will have an attached 3D
-       --    geometry which is a BSpline approximation of the computed
-       --    set of points.
-       --   Note that as a result, approximations will be computed
-       -- on edges built only on new intersection lines.
+    Approximation(me : out; 
+        B : Boolean from Standard);
+     ---Level: Public
+     ---Purpose: Defines an option for computation
+     -- of further intersections. This computation will be performed by
+     -- the function Build in this framework.
+     -- By default, the underlying 3D geometry attached to each
+     -- elementary edge of the result of a computed intersection is:
+     -- - analytic where possible, provided the corresponding
+     --    geometry corresponds to a type of analytic curve defined in
+     --    the Geom package; for example the intersection of a
+     --    cylindrical shape with a plane gives an ellipse or a circle;
+     -- -      or elsewhere, given as a succession of points grouped
+     -- together in a BSpline curve of degree 1. If Approx equals
+     -- true, when further computations are performed in this framework
+     -- with the function Build, these edges will have an attached 3D
+     --    geometry which is a BSpline approximation of the computed
+     --    set of points.
+     --   Note that as a result, approximations will be computed
+     -- on edges built only on new intersection lines.
  
-    ComputePCurveOn1(me : out;B : Boolean);
-       ---Level: Public
-       ---Purpose: 
-       -- Indicates if the Pcurve must be (or not) performed on first part. 
+    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);
-       ---Level: Public
-       ---Purpose: Define options for the computation of further
-       -- intersections, which will be performed by the function Build
-       -- in this framework.
-       -- By default, no parametric 2D curve (pcurve) is defined for the
-       -- elementary edges of the result. If ComputePCurve1 equals true,
-       -- further computations performed in this framework with the function
-       -- Build will attach an additional pcurve in the parametric space of
-       -- the first shape to the constructed edges.
-       -- If ComputePCurve2 equals true, the additional pcurve will be
-       -- attached to the constructed edges in the parametric space of the
-       -- second shape.
-       -- These two functions may be used together.
+    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
+     -- in this framework.
+     -- By default, no parametric 2D curve (pcurve) is defined for the
+     -- elementary edges of the result. If ComputePCurve1 equals true,
+     -- further computations performed in this framework with the function
+     -- Build will attach an additional pcurve in the parametric space of
+     -- the first shape to the constructed edges.
+     -- If ComputePCurve2 equals true, the additional pcurve will be
+     -- attached to the constructed edges in the parametric space of the
+     -- second shape.
+     -- These two functions may be used together.
  
-    Build(me : in out)
-       ---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
-       -- Init2 functions.
-       -- The constructed shape will be returned by the function Shape.
-       -- This is a compound object composed of edges. These
-       -- intersection edges may be built:
-       -- -      on new intersection lines, or
-       -- -      on coincident portions of edges in the two intersected shapes.
-       -- These intersection edges are independent: they are not chained
-       -- or grouped into wires.
-       -- If no intersection edge exists, the result is an empty compound object.
-       -- The shapes involved in the construction of section lines can
-       -- be retrieved with the function Shape1 or Shape2. Note that other
-       -- objects than TopoDS_Shape shapes given as arguments at the
-       -- construction time of this framework, or to the Init1 or
-       -- Init2 function, are converted into faces or shells before
-       -- performing the computation of the intersection.
-       -- Parametric 2D curves on intersection edges
-       -- No parametric 2D curve (pcurve) is defined for the elementary
-       -- edges of the result. To attach parametric curves like this to
-       -- the constructed edges you have to use:
-       -- -      the function
-       -- ComputePCurveOn1 to ask for the additional computation of a
-       -- pcurve in the parametric space of the first shape,
-       -- -      the function
-       --    ComputePCurveOn2 to ask for the additional computation of a
-       --    pcurve in the parametric space of the second shape.
-       -- This must be done before calling this function.
-       --   Approximation of intersection edges
-       -- The underlying 3D geometry attached to each elementary edge of the result is:
-       -- -      analytic (where possible) provided the corresponding
-       -- geometry corresponds to a type of analytic curve defined in
-       --    the Geom package; for example, the intersection of a
-       --    cylindrical shape with a plane gives an ellipse or a circle;    or
-       -- -      elsewhere, given as a succession of points grouped
-       --    together in a BSpline curve of degree 1.
-       --   If, on computed elementary intersection edges whose
-       -- underlying geometry is not analytic, you prefer to have an
-       -- attached 3D geometry which is a Bspline approximation of the
-       -- computed set of points, you have to use the function Approximation
-       -- 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;
+    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
+     -- Init2 functions.
+     -- The constructed shape will be returned by the function Shape.
+     -- This is a compound object composed of edges. These
+     -- intersection edges may be built:
+     -- -      on new intersection lines, or
+     -- -      on coincident portions of edges in the two intersected shapes.
+     -- These intersection edges are independent: they are not chained
+     -- or grouped into wires.
+     -- If no intersection edge exists, the result is an empty compound object.
+     -- The shapes involved in the construction of section lines can
+     -- be retrieved with the function Shape1 or Shape2. Note that other
+     -- objects than TopoDS_Shape shapes given as arguments at the
+     -- construction time of this framework, or to the Init1 or
+     -- Init2 function, are converted into faces or shells before
+     -- performing the computation of the intersection.
+     -- Parametric 2D curves on intersection edges
+     -- No parametric 2D curve (pcurve) is defined for the elementary
+     -- edges of the result. To attach parametric curves like this to
+     -- the constructed edges you have to use:
+     -- -      the function
+     -- ComputePCurveOn1 to ask for the additional computation of a
+     -- pcurve in the parametric space of the first shape,
+     -- -      the function
+     --    ComputePCurveOn2 to ask for the additional computation of a
+     --    pcurve in the parametric space of the second shape.
+     -- This must be done before calling this function.
+     --   Approximation of intersection edges
+     -- The underlying 3D geometry attached to each elementary edge of the result is:
+     -- -      analytic (where possible) provided the corresponding
+     -- geometry corresponds to a type of analytic curve defined in
+     --    the Geom package; for example, the intersection of a
+     --    cylindrical shape with a plane gives an ellipse or a circle;    or
+     -- -      elsewhere, given as a succession of points grouped
+     --    together in a BSpline curve of degree 1.
+     --   If, on computed elementary intersection edges whose
+     -- underlying geometry is not analytic, you prefer to have an
+     -- attached 3D geometry which is a Bspline approximation of the
+     -- computed set of points, you have to use the function Approximation
+     -- 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.
+     
 
-    HasAncestorFaceOn1(me; E : Shape from TopoDS;
-                          F : out Shape from TopoDS)
-       returns Boolean;
-       ---Level: Public
-       ---Purpose:
-       -- get the face of the first part giving section edge <E>.
-       -- Returns True on the 3 following conditions :
-       -- 1/ <E> is an edge returned by the Shape() method. 
-       -- 2/ First part of section performed is a shape.
-       -- 3/ <E> is built on a intersection curve (i.e <E>
-       --       is not the result of common edges)
-       -- When False, F remains untouched.
+    HasAncestorFaceOn1(me;  
+            E : Shape from TopoDS;
+            F : out Shape from TopoDS)
+        returns Boolean from Standard;
+     ---Level: Public
+     ---Purpose:
+     -- get the face of the first part giving section edge <E>.
+     -- Returns True on the 3 following conditions :
+     -- 1/ <E> is an edge returned by the Shape() method. 
+     -- 2/ First part of section performed is a shape.
+     -- 3/ <E> is built on a intersection curve (i.e <E>
+     --   is not the result of common edges)
+     -- When False, F remains untouched.
 
-    HasAncestorFaceOn2(me; E : Shape from TopoDS;
-                          F : out Shape from TopoDS)
-       returns Boolean;
-       ---Purpose:  Identifies the ancestor faces of
-       -- the intersection edge E resulting from the last
-       -- computation performed in this framework, that is, the faces of
-       -- the two original shapes on which the edge E lies:
-       -- -      HasAncestorFaceOn1 gives the ancestor face in the first shape, and
-       -- -      HasAncestorFaceOn2 gives the ancestor face in the second shape.
-       --   These functions return true if an ancestor face F is found, or false if not.
-       --   An ancestor face is identifiable for the edge E if the following
-       -- conditions are satisfied:
-       -- -  the first part on which this algorithm performed its
-       --    last computation is a shape, that is, it was not given as
-       -- a surface or a plane at the time of construction of this
-       -- algorithm or at a later time by the Init1 function,
-       -- - E is one of the elementary edges built by the
-       -- last computation of this section algorithm.
-       -- To use these functions properly, you have to test the returned
-       -- Boolean value before using the ancestor face: F is significant
-       -- only if the returned Boolean value equals true.
+    HasAncestorFaceOn2(me;  
+            E : Shape from TopoDS;
+            F : out Shape from TopoDS)
+        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
+     -- the two original shapes on which the edge E lies:
+     -- -      HasAncestorFaceOn1 gives the ancestor face in the first shape, and
+     -- -      HasAncestorFaceOn2 gives the ancestor face in the second shape.
+     --   These functions return true if an ancestor face F is found, or false if not.
+     --   An ancestor face is identifiable for the edge E if the following
+     -- conditions are satisfied:
+     -- -  the first part on which this algorithm performed its
+     --    last computation is a shape, that is, it was not given as
+     -- a surface or a plane at the time of construction of this
+     -- algorithm or at a later time by the Init1 function,
+     -- - E is one of the elementary edges built by the
+     -- last computation of this section algorithm.
+     -- To use these functions properly, you have to test the returned
+     -- Boolean value before using the ancestor face: F is significant
+     -- only if the returned Boolean value equals true.
 
-    InitParameters(me: out)
-       ---Level: Private
-       is private;
+    InitParameters(me: out) 
+        is private;
+    ---Level: Private
+     
 
 fields
     myshapeisnull       : Boolean from Standard;
index b134d12..b5255d1 100644 (file)
 #include <BOPAlgo_BOP.hxx>
 #include <BOPDS_DS.hxx>
 
-static TopoDS_Shape MakeShape(const Handle(Geom_Surface)& S)
-{
-  GeomAbs_Shape c = S->Continuity();
-  if (c >= GeomAbs_C2) return BRepBuilderAPI_MakeFace(S, Precision::Confusion());
-  else return BRepBuilderAPI_MakeShell(S);
-}
+//
+static 
+  TopoDS_Shape MakeShape(const Handle(Geom_Surface)& );
 
-static Standard_Boolean HasAncestorFaces(const BOPAlgo_PPaveFiller& theDSFiller, 
-                                         const TopoDS_Shape&      E,
-                                         TopoDS_Shape&            F1,
-                                         TopoDS_Shape&            F2);
+static 
+  Standard_Boolean HasAncestorFaces(const BOPAlgo_PPaveFiller&, 
+                                    const TopoDS_Shape&,
+                                    TopoDS_Shape&,
+                                    TopoDS_Shape&);
 
 //=======================================================================
+//function : BRepAlgoAPI_Section
+//purpose  : 
+//=======================================================================
+BRepAlgoAPI_Section::BRepAlgoAPI_Section()
+:
+  BRepAlgoAPI_BooleanOperation()
+{
+  myOperation=BOPAlgo_SECTION;
+  InitParameters(); 
+}
+//=======================================================================
+//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;
+}
+//=======================================================================
 //function : Constructor
 //purpose  : 
 //=======================================================================
 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, 
-                                         const TopoDS_Shape&      aS2,
-                                         const BOPAlgo_PaveFiller& aDSF,
-                                         const Standard_Boolean   PerformNow)
-: BRepAlgoAPI_BooleanOperation(aS1, aS2, aDSF, BOPAlgo_SECTION)
+//=======================================================================
+//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)
 {
   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,
-                                         const gp_Pln&          Pl,
-                                         const Standard_Boolean PerformNow)
-: BRepAlgoAPI_BooleanOperation(Sh, MakeShape(new Geom_Plane(Pl)), BOPAlgo_SECTION)
+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)
 {
   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,
-                                               const Handle(Geom_Surface)& Sf,
-                                               const Standard_Boolean      PerformNow)
-: BRepAlgoAPI_BooleanOperation(Sh, MakeShape(Sf), BOPAlgo_SECTION)
+BRepAlgoAPI_Section::BRepAlgoAPI_Section
+  (const TopoDS_Shape&         Sh,
+   const Handle(Geom_Surface)& Sf,
+   const Standard_Boolean      PerformNow)
+: 
+  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,
-                                               const TopoDS_Shape&         Sh,
-                                               const Standard_Boolean      PerformNow)
-: BRepAlgoAPI_BooleanOperation(MakeShape(Sf), Sh, BOPAlgo_SECTION)
+BRepAlgoAPI_Section::BRepAlgoAPI_Section
+  (const Handle(Geom_Surface)& Sf,
+   const TopoDS_Shape&         Sh,
+   const Standard_Boolean      PerformNow)
+: 
+  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,
-                                               const Handle(Geom_Surface)& Sf2,
-                                               const Standard_Boolean      PerformNow)
-: BRepAlgoAPI_BooleanOperation(MakeShape(Sf1), MakeShape(Sf2), BOPAlgo_SECTION)
+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)
 {
   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,27 +413,15 @@ 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, 
+                                  const TopoDS_Shape& E,
+                                  TopoDS_Shape& F1,
+                                  TopoDS_Shape&F2) 
 {
-  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) {
-
+  
   Standard_Integer aNb, i, j, nE, nF1, nF2, aNbCurves;
   //
   const BOPDS_PDS& pDS = theDSFiller->PDS();
@@ -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);
+}
index 7d9689e..ca36fa6 100644 (file)
 
 deferred class MakeShape from BRepBuilderAPI inherits Command from BRepBuilderAPI
 
-       ---Purpose: This    is  the  root     class for     all  shape
-       --          constructions.  It stores the result.
-       --          
-       --          It  provides deferred methods to trace the history
-       --          of sub-shapes.
+ ---Purpose: This    is  the  root     class for     all  shape
+ --          constructions.  It stores the result.
+ --          
+ --          It  provides deferred methods to trace the history
+ --          of sub-shapes.
 
 uses
     Shape             from TopoDS,
@@ -34,27 +34,28 @@ uses
 raises
     NotDone           from StdFail
 
-is
+is 
     Delete(me:out) is redefined;
     ---C++: alias "Standard_EXPORT virtual ~BRepBuilderAPI_MakeShape(){Delete() ; }"
     
     Initialize;
     
     Build(me : in out)
-       ---Purpose: This is  called by  Shape().  It does  nothing but
-       --          may be redefined.
-       ---Level: Public
+    ---Purpose: This is  called by  Shape().  It does  nothing but
+    --          may be redefined.
+    ---Level: Public
     is virtual;
-       
     Shape(me) returns Shape from TopoDS
-       ---Purpose: Returns a shape built by the shape construction algorithm.
-       -- Raises exception StdFail_NotDone if the shape was not built.
-       ---C++: return const &
-       ---C++: alias "Standard_EXPORT operator TopoDS_Shape() const;"
-       ---Level: Public
-           raises
-       NotDone from StdFail
-    is static;
+    ---Purpose: Returns a shape built by the shape construction algorithm.
+    -- Raises exception StdFail_NotDone if the shape was not built.
+    ---C++: return const &
+    ---C++: alias "Standard_EXPORT operator TopoDS_Shape() const;"
+    ---Level: Public
+    raises
+    NotDone from StdFail 
+    is virtual; 
+    --is static; 
 
 
     ------------------------------------------------------------------
@@ -64,19 +65,19 @@ is
     ------------------------------------------------------------------
 
     Generated (me: in out; S : Shape from TopoDS)
-       ---Purpose: Returns the  list   of shapes generated   from the
-       --          shape <S>. 
-        ---C++: return const & 
-        ---Level: Public
+    ---Purpose: Returns the  list   of shapes generated   from the
+    --          shape <S>. 
+    ---C++: return const & 
+    ---Level: Public
     returns ListOfShape from TopTools
     is virtual;
     
 
     Modified (me: in out; S : Shape from TopoDS)
-       ---Purpose: Returns the list  of shapes modified from the shape
-       --          <S>. 
-        ---C++: return const & 
-        ---Level: Public
+    ---Purpose: Returns the list  of shapes modified from the shape
+    --          <S>. 
+    ---C++: return const & 
+    ---Level: Public
     returns ListOfShape from TopTools
     is virtual;
 
@@ -84,7 +85,7 @@ is
     IsDeleted (me: in out; S : Shape from TopoDS)
     returns Boolean
     is virtual;
-       ---Purpose: Returns true if the shape S has been deleted.
+    ---Purpose: Returns true if the shape S has been deleted.
 
     
 fields
diff --git a/tests/bugs/modalg_5/bug25477_1 b/tests/bugs/modalg_5/bug25477_1
new file mode 100644 (file)
index 0000000..f62520a
--- /dev/null
@@ -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
diff --git a/tests/bugs/modalg_5/bug25477_2 b/tests/bugs/modalg_5/bug25477_2
new file mode 100644 (file)
index 0000000..8158f3f
--- /dev/null
@@ -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