0027878: Development of the Gluing operations based on the new Boolean component
authoremv <emv@opencascade.com>
Thu, 8 Dec 2016 13:49:29 +0000 (16:49 +0300)
committerapn <apn@opencascade.com>
Thu, 8 Dec 2016 13:50:17 +0000 (16:50 +0300)
The Gluing operation is an additional option for the algorithms in the Boolean Component
such as General Fuse, Boolean operations, Section operation, Maker Volume and Cells Builder algorithms.

The Gluing options have been designed to speed up the computation of the interference among arguments of the operations on special cases,
in which the arguments may be overlapping but do not have real intersections between their sub-shapes.

This option cannot be used on the shapes having real intersections, like intersection vertex between edges,
or intersection vertex between edge and a face or intersection line between faces.

The Gluing option is an enumeration implemented in BOPAlgo_GlueEnum.hxx. There are following items in the enum:
* BOPAlgo_GlueOff - default value for the algorithms, Gluing is switched off;
* BOPAlgo_GlueShift - Glue option for shapes with partial coincidence;
* BOPAlgo_GlueFull - Glue option for shapes with full coincidence.

For setting the Gluing options for the algorithm it is just necessary to call the SetGlue(BOPAlgo_GlueEnum) method with appropriate Glue value.

For using this option in DRAW the command bglue has been implemented:
* 0 - default value, Gluing is off;
* 1 - for partial coincidence;
* 2 - for full coincidence

Elimination of the warnings.

33 files changed:
dox/user_guides/boolean_operations/boolean_operations.md
dox/user_guides/boolean_operations/images/glue_options_image001.PNG [new file with mode: 0644]
dox/user_guides/boolean_operations/images/glue_options_image002.PNG [new file with mode: 0644]
dox/user_guides/boolean_operations/images/glue_options_image003.PNG [new file with mode: 0644]
dox/user_guides/boolean_operations/images/glue_options_image004.PNG [new file with mode: 0644]
dox/user_guides/boolean_operations/images/glue_options_image005.PNG [new file with mode: 0644]
src/BOPAlgo/BOPAlgo_BOP.cxx
src/BOPAlgo/BOPAlgo_Builder.cxx
src/BOPAlgo/BOPAlgo_Builder.hxx
src/BOPAlgo/BOPAlgo_GlueEnum.hxx [new file with mode: 0644]
src/BOPAlgo/BOPAlgo_MakerVolume.cxx
src/BOPAlgo/BOPAlgo_PaveFiller.cxx
src/BOPAlgo/BOPAlgo_PaveFiller.hxx
src/BOPAlgo/BOPAlgo_PaveFiller_4.cxx
src/BOPAlgo/BOPAlgo_PaveFiller_5.cxx
src/BOPAlgo/BOPAlgo_PaveFiller_6.cxx
src/BOPAlgo/FILES
src/BOPTest/BOPTest_APICommands.cxx
src/BOPTest/BOPTest_BOPCommands.cxx
src/BOPTest/BOPTest_CellsCommands.cxx
src/BOPTest/BOPTest_Objects.cxx
src/BOPTest/BOPTest_Objects.hxx
src/BOPTest/BOPTest_OptionCommands.cxx
src/BOPTest/BOPTest_PartitionCommands.cxx
src/BRepAlgoAPI/BRepAlgoAPI_BooleanOperation.cxx
src/BRepAlgoAPI/BRepAlgoAPI_BuilderAlgo.cxx
src/BRepAlgoAPI/BRepAlgoAPI_BuilderAlgo.hxx
tests/bugs/modalg_6/bug27878_1 [new file with mode: 0644]
tests/bugs/modalg_6/bug27878_2 [new file with mode: 0644]
tests/bugs/modalg_6/bug27878_3 [new file with mode: 0644]
tests/bugs/modalg_6/bug27878_4 [new file with mode: 0644]
tests/bugs/modalg_6/bug27878_5 [new file with mode: 0644]
tests/bugs/modalg_6/bug27878_6 [new file with mode: 0644]

index 356ef59..590332e 100644 (file)
@@ -2100,10 +2100,10 @@ With the Fuzzy option it is possible to get the expected result -- it is just ne
 
 Fuzzy option is included in interface of Intersection Part (class *BOPAlgo_PaveFiller*) and application programming interface (class  *BRepAlgoAPI_BooleanOperation*)
 
-@subsection occt_algorithms_11a_2 Examples
+@subsubsection occt_algorithms_11a_1_1 Examples
 The following examples demonstrate the advantages of usage Fuzzy option operations over the Basic Operations in typical situations.
 
-@subsubsection occt_algorithms_11a_1_1 Case 1
+#### Case 1
 
 In this example the cylinder (shown in yellow and transparent) is subtracted from the box (shown in red). The cylinder is shifted by  5e<sup>-5</sup> relatively to the box along its axis (the distance between rear faces of the box and cylinder is 5e<sup>-5</sup>).
 
@@ -2117,7 +2117,7 @@ The following results are obtained using Basic Operations and the Fuzzy ones wit
 
 In this example Fuzzy option allows eliminating a very thin part of the result shape produced by Basic algorithm due to misalignment of rear faces of the box and the cylinder. 
 
-@subsubsection occt_algorithms_11a_1_2 Case 2
+#### Case 2
 
 In this example two boxes are fused. One of them has dimensions 10*10*10, and the other is 10*10.000001*10.000001 and adjacent to the first one. There is no gap in this case as the surfaces of the neighboring faces coincide, but one box is slightly greater than the other. 
 
@@ -2131,7 +2131,7 @@ The following results are obtained using Basic Operations and the Fuzzy ones wit
 
 In this example Fuzzy option allows eliminating an extremely narrow face in the result produced by Basic operation.
 
-@subsubsection occt_algorithms_11a_1_3 Case 3
+#### Case 3
 
 In this example the small planar face (shown in orange) is subtracted from the big one (shown in yellow). There is a gap 1e<sup>-5</sup> between the edges of these faces.
 
@@ -2145,7 +2145,7 @@ The following results are obtained using Basic Operations and the Fuzzy ones wit
 
 In this example Fuzzy options eliminated a pin-like protrusion resulting from the gap between edges of the argument faces.
 
-@subsubsection occt_algorithms_11a_1_4 Case 4
+#### Case 4
 
 In this example the small edge is subtracted from the big one. The edges are overlapping not precisely, with max deviation between them equal to 5.28004e<sup>-5</sup>. We will use 6e<sup>-5</sup> value for Fuzzy option.
 
@@ -2159,6 +2159,71 @@ The following results are obtained using Basic Operations and the Fuzzy ones wit
 
 This example stresses not only the validity, but also the performance issue. The usage of Fuzzy option with the appropriate value allows processing the case much faster than with the pure Basic operation. The performance gain for the case is 45 (Processor: Intel(R) Core(TM) i5-3450 CPU @ 3.10 GHz).
 
+@subsection occt_algorithms_11a_2 Gluing Operation
+
+The Gluing operation is the option of the Basic Operations, such as General Fuse, Boolean and Section operations.
+It has been designed to speed up the computation of the interferences among arguments of the operations on special cases, in which the arguments may be overlapping but do not have real intersections between their sub-shapes.
+
+This option cannot be used on the shapes having real intersections, like intersection vertex between edges, or intersection vertex between edge and a face or intersection line between faces:
+@figure{/user_guides/boolean_operations/images/glue_options_image002.png, "Intersecting faces"}
+
+There are two possibilities of overlapping shapes:
+* The shapes can be partially coinciding - the faces do not have intersection curves, but overlapping. The faces of such arguments will be split during the operation. The following picture illustrates such shapes:
+@figure{/user_guides/boolean_operations/images/glue_options_image001.png, "Partially coinciding faces"}
+* The shapes can be fully coinciding - there should be no partial overlapping of the faces, thus no intersection of type EDGE/FACE at all. In such cases the faces will not be split during the operation
+@figure{/user_guides/boolean_operations/images/glue_options_image003.png, "Full coinciding faces of the boxes"}
+
+Thus, there are two possible options - for full and partial coincidence of the shapes.
+
+Even though there are no real intersections on such cases without Gluing options the algorithm will still intersect the sub-shapes of the arguments with interfering bounding boxes.
+
+The performance improvement in gluing mode is achieved by excluding the most time consuming computations and in some case can go up to 90%:
+* Exclude computation of FACE/FACE intersections for partial coincidence;
+* Exclude computation of VERTEX/FACE, EDGE/FACE and FACE/FACE intersections for full coincidence.
+
+By setting the Gluing option for the operation user should guarantee that the arguments are really coinciding. The algorithm does not check this itself. Setting inappropriate option for the operation is likely to lead to incorrect result.
+
+@subsubsection occt_algorithms_11a_2_1 Usage
+
+The Gluing option is an enumeration implemented in BOPAlgo_GlueEnum.hxx:
+* BOPAlgo_GlueOff - default value for the algorithms, Gluing is switched off;
+* BOPAlgo_GlueShift - Glue option for shapes with partial coincidence;
+* BOPAlgo_GlueFull - Glue option for shapes with full coincidence.
+
+#### API level
+For setting the Gluing options for the algorithm it is just necessary to call the SetGlue(const BOPAlgo_Glue) method with appropriate value:
+~~~~
+BOPAlgo_Builder aGF;
+//
+....
+// setting the gluing option to speed up intersection of the arguments
+aGF.SetGlue(BOPAlgo_GlueShift)
+//
+....
+~~~~
+
+#### TCL level
+For setting the Gluing options in DRAW it is necessary to call the <i>bglue</i> command with appropriate value:
+* 0 - default value, Gluing is off;
+* 1 - for partial coincidence;
+* 2 - for full coincidence
+
+~~~~
+bglue 1
+~~~~
+
+@subsubsection occt_algorithms_11a_2_2 Examples
+#### Case1 - Fusing the 64 bspline boxes into one solid
+@figure{/user_guides/boolean_operations/images/glue_options_image004.png, "BSpline Boxes with partial coincidence"}
+
+Performance improvement from using the GlueShift option in this case is about 70 percent.
+
+#### Case2 - Sewing faces of the shape after reading from IGES
+@figure{/user_guides/boolean_operations/images/glue_options_image005.png, "Faces with coinciding but not shared edges"}
+
+Performance improvement in this case is also about 70 percent.
+
+
 @section occt_algorithms_11b Usage 
 
 The chapter contains some examples of the OCCT Boolean Component usage. The usage is possible on two levels: C++ and Tcl. 
diff --git a/dox/user_guides/boolean_operations/images/glue_options_image001.PNG b/dox/user_guides/boolean_operations/images/glue_options_image001.PNG
new file mode 100644 (file)
index 0000000..a8287ef
Binary files /dev/null and b/dox/user_guides/boolean_operations/images/glue_options_image001.PNG differ
diff --git a/dox/user_guides/boolean_operations/images/glue_options_image002.PNG b/dox/user_guides/boolean_operations/images/glue_options_image002.PNG
new file mode 100644 (file)
index 0000000..584e9a7
Binary files /dev/null and b/dox/user_guides/boolean_operations/images/glue_options_image002.PNG differ
diff --git a/dox/user_guides/boolean_operations/images/glue_options_image003.PNG b/dox/user_guides/boolean_operations/images/glue_options_image003.PNG
new file mode 100644 (file)
index 0000000..0581cdd
Binary files /dev/null and b/dox/user_guides/boolean_operations/images/glue_options_image003.PNG differ
diff --git a/dox/user_guides/boolean_operations/images/glue_options_image004.PNG b/dox/user_guides/boolean_operations/images/glue_options_image004.PNG
new file mode 100644 (file)
index 0000000..e6924e2
Binary files /dev/null and b/dox/user_guides/boolean_operations/images/glue_options_image004.PNG differ
diff --git a/dox/user_guides/boolean_operations/images/glue_options_image005.PNG b/dox/user_guides/boolean_operations/images/glue_options_image005.PNG
new file mode 100644 (file)
index 0000000..0e74a66
Binary files /dev/null and b/dox/user_guides/boolean_operations/images/glue_options_image005.PNG differ
index aec1a45..9328771 100644 (file)
@@ -376,6 +376,7 @@ void BOPAlgo_BOP::Perform()
   pPF->SetProgressIndicator(myProgressIndicator);
   pPF->SetFuzzyValue(myFuzzyValue);
   pPF->SetNonDestructive(myNonDestructive);
+  pPF->SetGlue(myGlue);
   //
   pPF->Perform();
   //
index 59e909c..598c5c9 100644 (file)
@@ -51,7 +51,8 @@ BOPAlgo_Builder::BOPAlgo_Builder()
   myShapesSD(100, myAllocator),
   mySplits(100, myAllocator),
   myOrigins(100, myAllocator),
-  myNonDestructive(Standard_False)
+  myNonDestructive(Standard_False),
+  myGlue(BOPAlgo_GlueOff)
 {
 }
 //=======================================================================
@@ -71,7 +72,8 @@ BOPAlgo_Builder::BOPAlgo_Builder
   myShapesSD(100, myAllocator),
   mySplits(100, myAllocator),
   myOrigins(100, myAllocator),
-  myNonDestructive(Standard_False)
+  myNonDestructive(Standard_False),
+  myGlue(BOPAlgo_GlueOff)
 {
 }
 //=======================================================================
@@ -200,6 +202,22 @@ Standard_Boolean BOPAlgo_Builder::NonDestructive() const
   return myNonDestructive;
 }
 //=======================================================================
+//function : SetGlue
+//purpose  : 
+//=======================================================================
+void BOPAlgo_Builder::SetGlue(const BOPAlgo_GlueEnum theGlue)
+{
+  myGlue=theGlue;
+}
+//=======================================================================
+//function : Glue
+//purpose  : 
+//=======================================================================
+BOPAlgo_GlueEnum BOPAlgo_Builder::Glue() const 
+{
+  return myGlue;
+}
+//=======================================================================
 // function: CheckData
 // purpose: 
 //=======================================================================
@@ -268,6 +286,7 @@ void BOPAlgo_Builder::Perform()
   pPF->SetProgressIndicator(myProgressIndicator);
   pPF->SetFuzzyValue(myFuzzyValue);
   pPF->SetNonDestructive(myNonDestructive);
+  pPF->SetGlue(myGlue);
   //
   pPF->Perform();
   //
@@ -283,6 +302,7 @@ void BOPAlgo_Builder::PerformWithFiller(const BOPAlgo_PaveFiller& theFiller)
   myEntryPoint=0;
   myNonDestructive = theFiller.NonDestructive();
   myFuzzyValue = theFiller.FuzzyValue();
+  myGlue = theFiller.Glue();
   PerformInternal(theFiller);
 }
 //=======================================================================
index 238aa17..0323b85 100644 (file)
@@ -25,6 +25,7 @@
 #include <BOPCol_ListOfShape.hxx>
 #include <BOPCol_MapOfShape.hxx>
 #include <BOPAlgo_PPaveFiller.hxx>
+#include <BOPAlgo_GlueEnum.hxx>
 #include <BOPDS_PDS.hxx>
 #include <Standard_Integer.hxx>
 #include <BOPCol_DataMapOfShapeListOfShape.hxx>
@@ -107,6 +108,11 @@ Standard_EXPORT virtual ~BOPAlgo_Builder();
   //! a copy of a sub-shape is created in the result if it is needed to be updated.
   Standard_EXPORT Standard_Boolean NonDestructive() const;
 
+  //! Sets the glue option for the algorithm
+  Standard_EXPORT void SetGlue(const BOPAlgo_GlueEnum theGlue);
+  
+  //! Returns the glue option of the algorithm
+  Standard_EXPORT BOPAlgo_GlueEnum Glue() const;
 
 protected:
 
@@ -167,6 +173,7 @@ protected:
   BOPCol_DataMapOfShapeListOfShape mySplits;
   BOPCol_DataMapOfShapeShape myOrigins;
   Standard_Boolean myNonDestructive;
+  BOPAlgo_GlueEnum myGlue;
 
 private:
 
diff --git a/src/BOPAlgo/BOPAlgo_GlueEnum.hxx b/src/BOPAlgo/BOPAlgo_GlueEnum.hxx
new file mode 100644 (file)
index 0000000..740e32f
--- /dev/null
@@ -0,0 +1,64 @@
+// Created by: Eugeny MALTCHIKOV
+// Copyright (c) 2016 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 _BOPAlgo_GlueEnum_HeaderFile
+#define _BOPAlgo_GlueEnum_HeaderFile
+
+//! The Enumeration describes an additional option for the algorithms
+//! in the Boolean Component such as General Fuse, Boolean operations,
+//! Section operation, Maker Volume and Cells Builder algorithms.
+//!
+//! The Gluing options have been designed to speed up the computation
+//! of the interference among arguments of the operations on special cases,
+//! in which the arguments may be overlapping but do not have real intersections
+//! between their sub-shapes.
+//!
+//! This option cannot be used on the shapes having real intersections,
+//! like intersection vertex between edges, or intersection vertex between
+//! edge and a face or intersection line between faces.
+//!
+//! There are two possibilities of overlapping shapes:
+//! 1. The shapes can be partially coinciding - the faces do not have
+//!    intersection curves, but overlapping. The faces of such arguments will
+//!    be split during the operation;
+//! 2. The shapes can be fully coinciding - there should be no partial
+//!    overlapping of the faces, thus no intersection of type EDGE/FACE at all.
+//!    In such cases the faces will not be split during the operation.
+//!
+//! Even though there are no real intersections on such cases without Gluing options the algorithm
+//! will still intersect the sub-shapes of the arguments with interfering bounding boxes.
+//!
+//! The performance improvement in gluing mode is achieved by excluding
+//! the most time consuming computations according to the given Gluing parameter:
+//! 1. Computation of FACE/FACE intersections for partial coincidence;
+//! 2. And computation of VERTEX/FACE, EDGE/FACE and FACE/FACE intersections for full coincidence.
+//! 
+//! By setting the Gluing option for the operation user should guarantee
+//! that the arguments are really coinciding. The algorithms do not check this itself.
+//! Setting inappropriate option for the operation is likely to lead to incorrect result.
+//!
+//! There are following items in the enumeration:
+//! BOPAlgo_GlueOff - default value for the algorithms, Gluing is switched off;
+//! BOPAlgo_GlueShift - Glue option for shapes with partial coincidence;
+//! BOPAlgo_GlueFull - Glue option for shapes with full coincidence.
+//!
+
+enum BOPAlgo_GlueEnum
+{
+  BOPAlgo_GlueOff,
+  BOPAlgo_GlueShift,
+  BOPAlgo_GlueFull
+};
+
+#endif // _BOPAlgo_GlueEnum_HeaderFile
index 6980848..a7639cc 100644 (file)
@@ -101,6 +101,7 @@ void BOPAlgo_MakerVolume::Perform()
   pPF->SetProgressIndicator(myProgressIndicator);
   pPF->SetFuzzyValue(myFuzzyValue);
   pPF->SetNonDestructive(myNonDestructive);
+  pPF->SetGlue(myGlue);
   pPF->Perform();
   //
   myEntryPoint = 1;
index c24d12e..2e10665 100644 (file)
@@ -43,6 +43,7 @@ BOPAlgo_PaveFiller::BOPAlgo_PaveFiller()
   myIterator=NULL;
   myNonDestructive=Standard_False;
   myIsPrimary=Standard_True;
+  myGlue=BOPAlgo_GlueOff;
 }
 //=======================================================================
 //function : 
@@ -57,6 +58,7 @@ BOPAlgo_PaveFiller::BOPAlgo_PaveFiller
   myIterator=NULL;
   myNonDestructive=Standard_False;
   myIsPrimary=Standard_True;
+  myGlue=BOPAlgo_GlueOff;
 }
 //=======================================================================
 //function : ~
@@ -83,6 +85,22 @@ Standard_Boolean BOPAlgo_PaveFiller::NonDestructive()const
   return myNonDestructive;
 }
 //=======================================================================
+//function : SetGlue
+//purpose  : 
+//=======================================================================
+void BOPAlgo_PaveFiller::SetGlue(const BOPAlgo_GlueEnum theGlue)
+{
+  myGlue=theGlue;
+}
+//=======================================================================
+//function : Glue
+//purpose  : 
+//=======================================================================
+BOPAlgo_GlueEnum BOPAlgo_PaveFiller::Glue() const 
+{
+  return myGlue;
+}
+//=======================================================================
 //function : SetIsPrimary
 //purpose  : 
 //=======================================================================
@@ -294,6 +312,10 @@ void BOPAlgo_PaveFiller::PerformInternal()
   if (myErrorStatus) {
     return; 
   }
+  //
+  if (myGlue != BOPAlgo_GlueOff) {
+    return;
+  }
   // 03
   PerformVZ();
   if (myErrorStatus) {
index f9b5407..8d5675e 100644 (file)
@@ -48,6 +48,7 @@
 #include <BOPDS_VectorOfCurve.hxx>
 #include <BOPCol_IndexedDataMapOfShapeInteger.hxx>
 #include <BOPCol_IndexedDataMapOfShapeListOfShape.hxx>
+#include <BOPAlgo_GlueEnum.hxx>
 class IntTools_Context;
 class BOPDS_DS;
 class BOPAlgo_SectionAttribute;
@@ -101,6 +102,14 @@ public:
   
   
 
+  //! Sets the glue option for the algorithm
+  Standard_EXPORT void SetGlue(const BOPAlgo_GlueEnum theGlue);
+  
+  //! Returns the glue option of the algorithm
+  Standard_EXPORT BOPAlgo_GlueEnum Glue() const;
+
+
+
 protected:
 
   typedef NCollection_DataMap
@@ -395,6 +404,7 @@ protected:
   BOPAlgo_SectionAttribute mySectionAttribute;
   Standard_Boolean myNonDestructive;
   Standard_Boolean myIsPrimary;
+  BOPAlgo_GlueEnum myGlue;
 
 
 private:
index 356a43b..f9dce5e 100644 (file)
@@ -142,96 +142,109 @@ typedef BOPCol_ContextCnt
 //=======================================================================
 void BOPAlgo_PaveFiller::PerformVF()
 {
-  Standard_Boolean bJustAdd;
-  Standard_Integer iSize, nV, nF, nVSD, iFlag, nVx, aNbVF, k;
-  Standard_Real aT1, aT2;
-  BOPAlgo_VectorOfVertexFace aVVF; 
-  //
   myErrorStatus=0;
   //
   myIterator->Initialize(TopAbs_VERTEX, TopAbs_FACE);
-  iSize=myIterator->ExpectedLength();
-  if (iSize) {
-    //
-    BOPDS_VectorOfInterfVF& aVFs=myDS->InterfVF();
-    aVFs.SetIncrement(iSize);
-    //
+  Standard_Integer iSize = myIterator->ExpectedLength();
+  //
+  Standard_Boolean bJustAdd;
+  Standard_Integer nV, nF;
+  //
+  if (myGlue == BOPAlgo_GlueFull) {
+    // there is no need to intersect vertices with faces in this mode
+    // just initialize FaceInfo for all faces
     for (; myIterator->More(); myIterator->Next()) {
       myIterator->Value(nV, nF, bJustAdd);
-      if(bJustAdd) {
-        continue;
-      }
-      //
-      if (myDS->IsSubShape(nV, nF)) {
-        continue;
-      }
-      //
-      if (myDS->HasInterfShapeSubShapes(nV, nF)) {
+      if (!bJustAdd && !myDS->IsSubShape(nV, nF)) {
         myDS->ChangeFaceInfo(nF);
-        continue;
       }
-      //
-      nVx=nV;
-      if (myDS->HasShapeSD(nV, nVSD)) {
-        nVx=nVSD;
-      }
-      //
-      myDS->ChangeFaceInfo(nF);// !
-      //
-      const TopoDS_Vertex& aV=(*(TopoDS_Vertex *)(&myDS->Shape(nVx))); 
-      const TopoDS_Face& aF=(*(TopoDS_Face *)(&myDS->Shape(nF))); 
-      //
-      BOPAlgo_VertexFace& aVertexFace=aVVF.Append1();
-      //
-      aVertexFace.SetIndices(nV, nF);
-      aVertexFace.SetVertex(aV);
-      aVertexFace.SetFace(aF);
-      aVertexFace.SetFuzzyValue(myFuzzyValue);
-      aVertexFace.SetProgressIndicator(myProgressIndicator);
-    }//for (; myIterator->More(); myIterator->Next()) {
-    //
-    aNbVF=aVVF.Extent();
-    //================================================================
-    BOPAlgo_VertexFaceCnt::Perform(myRunParallel, aVVF, myContext);
-    //================================================================
-    //
-    for (k=0; k < aNbVF; ++k) {
-      const BOPAlgo_VertexFace& aVertexFace=aVVF(k);
-      // 
-      iFlag=aVertexFace.Flag();
-      if (iFlag) {
-        continue;
-      }
-      //
-      aVertexFace.Indices(nV, nF);
-      aVertexFace.Parameters(aT1, aT2);
-      // 1
-      BOPDS_InterfVF& aVF=aVFs.Append1();
-      aVF.SetIndices(nV, nF);
-      aVF.SetUV(aT1, aT2);
-      // 2
-      myDS->AddInterf(nV, nF);
-      //
-      // 3 update vertex V/F if necessary
-      Standard_Real aTolVNew = aVertexFace.VertexNewTolerance();
-      nVx=UpdateVertex(nV, aTolVNew);
-      //
-      // 4
-      if (myDS->IsNewShape(nVx)) {
-        aVF.SetIndexNew(nVx);
-      }
-      // 5 update FaceInfo
-      BOPDS_FaceInfo& aFI=myDS->ChangeFaceInfo(nF);
-      BOPCol_MapOfInteger& aMVIn=aFI.ChangeVerticesIn();
-      aMVIn.Add(nVx);
-    }//for (k=0; k < aNbVF; ++k) {
-  }// if (iSize) {
-  else {
-    iSize=10;
-    BOPDS_VectorOfInterfVF& aVFs=myDS->InterfVF();
+    }
+    return;
+  }
+  //
+  BOPDS_VectorOfInterfVF& aVFs = myDS->InterfVF();
+  if (!iSize) {
+    iSize = 10;
     aVFs.SetIncrement(iSize);
+    //
+    TreatVerticesEE();
+    return;
   }
   //
+  Standard_Integer nVSD, iFlag, nVx, aNbVF, k;
+  Standard_Real aT1, aT2;
+  BOPAlgo_VectorOfVertexFace aVVF; 
+  //
+  aVFs.SetIncrement(iSize);
+  //
+  for (; myIterator->More(); myIterator->Next()) {
+    myIterator->Value(nV, nF, bJustAdd);
+    if(bJustAdd) {
+      continue;
+    }
+    //
+    if (myDS->IsSubShape(nV, nF)) {
+      continue;
+    }
+    //
+    myDS->ChangeFaceInfo(nF);
+    if (myDS->HasInterfShapeSubShapes(nV, nF)) {
+      continue;
+    }
+    //
+    nVx=nV;
+    if (myDS->HasShapeSD(nV, nVSD)) {
+      nVx=nVSD;
+    }
+    //
+    const TopoDS_Vertex& aV=(*(TopoDS_Vertex *)(&myDS->Shape(nVx))); 
+    const TopoDS_Face& aF=(*(TopoDS_Face *)(&myDS->Shape(nF))); 
+    //
+    BOPAlgo_VertexFace& aVertexFace=aVVF.Append1();
+    //
+    aVertexFace.SetIndices(nV, nF);
+    aVertexFace.SetVertex(aV);
+    aVertexFace.SetFace(aF);
+    aVertexFace.SetFuzzyValue(myFuzzyValue);
+    aVertexFace.SetProgressIndicator(myProgressIndicator);
+  }//for (; myIterator->More(); myIterator->Next()) {
+  //
+  aNbVF=aVVF.Extent();
+  //================================================================
+  BOPAlgo_VertexFaceCnt::Perform(myRunParallel, aVVF, myContext);
+  //================================================================
+  //
+  for (k=0; k < aNbVF; ++k) {
+    const BOPAlgo_VertexFace& aVertexFace=aVVF(k);
+    // 
+    iFlag=aVertexFace.Flag();
+    if (iFlag) {
+      continue;
+    }
+    //
+    aVertexFace.Indices(nV, nF);
+    aVertexFace.Parameters(aT1, aT2);
+    // 1
+    BOPDS_InterfVF& aVF=aVFs.Append1();
+    aVF.SetIndices(nV, nF);
+    aVF.SetUV(aT1, aT2);
+    // 2
+    myDS->AddInterf(nV, nF);
+    //
+    // 3 update vertex V/F if necessary
+    Standard_Real aTolVNew = aVertexFace.VertexNewTolerance();
+    nVx=UpdateVertex(nV, aTolVNew);
+    //
+    // 4
+    if (myDS->IsNewShape(nVx)) {
+      aVF.SetIndexNew(nVx);
+    }
+    // 5 update FaceInfo
+    BOPDS_FaceInfo& aFI=myDS->ChangeFaceInfo(nF);
+    BOPCol_MapOfInteger& aMVIn=aFI.ChangeVerticesIn();
+    aMVIn.Add(nVx);
+  }//for (k=0; k < aNbVF; ++k) {
+  //
   TreatVerticesEE();
 }
 //=======================================================================
index 5cc8ed0..eafa196 100644 (file)
@@ -139,22 +139,35 @@ typedef BOPCol_ContextCnt
 //=======================================================================
 void BOPAlgo_PaveFiller::PerformEF()
 {
-  Standard_Integer iSize;
-  //
   myErrorStatus=0;
   //
   FillShrunkData(TopAbs_EDGE, TopAbs_FACE);
   //
   myIterator->Initialize(TopAbs_EDGE, TopAbs_FACE);
-  iSize=myIterator->ExpectedLength();
+  Standard_Integer iSize = myIterator->ExpectedLength();
   if (!iSize) {
     return; 
   }
   //
-  Standard_Boolean bJustAdd, bV[2], bIsPBSplittable;
+  Standard_Boolean bJustAdd;
+  Standard_Integer nE, nF;
+  //
+  if (myGlue == BOPAlgo_GlueFull) {
+    // there is no need to intersect edges with faces in this mode
+    // just initialize FaceInfo for faces
+    for (; myIterator->More(); myIterator->Next()) {
+      myIterator->Value(nE, nF, bJustAdd);
+      if (!bJustAdd && !myDS->ShapeInfo(nE).HasFlag()) {
+        myDS->ChangeFaceInfo(nF);
+      }
+    }
+    return;
+  }
+  //
+  Standard_Boolean bV[2], bIsPBSplittable;
   Standard_Boolean bV1, bV2, bExpressCompute;
   Standard_Integer nV1, nV2;
-  Standard_Integer nE, nF, aDiscretize, i, aNbCPrts, iX, nV[2];
+  Standard_Integer aDiscretize, i, aNbCPrts, iX, nV[2];
   Standard_Integer aNbEdgeFace, k;
   Standard_Real aTolE, aTolF, aTS1, aTS2, aT1, aT2, aDeflection;
   Handle(NCollection_BaseAllocator) aAllocator;
index 38b7be5..4893969 100644 (file)
@@ -237,22 +237,34 @@ void BOPAlgo_PaveFiller::PerformFF()
     //
     ToleranceFF(aBAS1, aBAS2, aTolFF); 
     //
-    BOPAlgo_FaceFace& aFaceFace=aVFaceFace.Append1();
-    //
-    aFaceFace.SetIndices(nF1, nF2);
-    aFaceFace.SetFaces(aF1, aF2);
-    aFaceFace.SetTolFF(aTolFF);
-    //
-    IntSurf_ListOfPntOn2S aListOfPnts;
-    GetEFPnts(nF1, nF2, aListOfPnts);
-    aNbLP = aListOfPnts.Extent();
-    if (aNbLP) {
-      aFaceFace.SetList(aListOfPnts);
+    if (myGlue == BOPAlgo_GlueOff) {
+      BOPAlgo_FaceFace& aFaceFace=aVFaceFace.Append1();
+      //
+      aFaceFace.SetIndices(nF1, nF2);
+      aFaceFace.SetFaces(aF1, aF2);
+      aFaceFace.SetTolFF(aTolFF);
+      //
+      IntSurf_ListOfPntOn2S aListOfPnts;
+      GetEFPnts(nF1, nF2, aListOfPnts);
+      aNbLP = aListOfPnts.Extent();
+      if (aNbLP) {
+        aFaceFace.SetList(aListOfPnts);
+      }
+      //
+      aFaceFace.SetParameters(bApp, bCompC2D1, bCompC2D2, aApproxTol);
+      aFaceFace.SetFuzzyValue(myFuzzyValue);
+      aFaceFace.SetProgressIndicator(myProgressIndicator);
+    }
+    else {
+      // for the Glue mode just add all interferences of that type
+      BOPDS_InterfFF& aFF = aFFs.Append1();
+      aFF.SetIndices(nF1, nF2);
+      aFF.SetTolR3D(Precision::Confusion());
+      aFF.SetTolR2D(Precision::PConfusion());
+      aFF.SetTolReal(Precision::Confusion());
+      aFF.SetTangentFaces(Standard_False);
+      aFF.Init(0, 0);
     }
-    //
-    aFaceFace.SetParameters(bApp, bCompC2D1, bCompC2D2, aApproxTol);
-    aFaceFace.SetFuzzyValue(myFuzzyValue);
-    aFaceFace.SetProgressIndicator(myProgressIndicator);
   }//for (; myIterator->More(); myIterator->Next()) {
   //
   aNbFaceFace=aVFaceFace.Extent();
@@ -359,6 +371,10 @@ void BOPAlgo_PaveFiller::PerformFF()
 //=======================================================================
 void BOPAlgo_PaveFiller::MakeBlocks()
 {
+  if (myGlue != BOPAlgo_GlueOff) {
+    return;
+  }
+  //
   Standard_Integer aNbFF;
   //
   myErrorStatus=0;
index df1bea2..b5e68de 100644 (file)
@@ -65,3 +65,4 @@ BOPAlgo_WireSplitter.lxx
 BOPAlgo_WireSplitter_1.cxx
 BOPAlgo_CellsBuilder.cxx
 BOPAlgo_CellsBuilder.hxx
+BOPAlgo_GlueEnum.hxx
\ No newline at end of file
index 2f37a81..a61adc1 100644 (file)
@@ -116,6 +116,7 @@ Standard_Integer bapibop(Draw_Interpretor& di,
   bRunParallel=BOPTest_Objects::RunParallel();
   aFuzzyValue=BOPTest_Objects::FuzzyValue();
   bNonDestructive = BOPTest_Objects::NonDestructive();
+  BOPAlgo_GlueEnum aGlue = BOPTest_Objects::Glue();
   //
   if (aOp!=BOPAlgo_CUT21) {
     pBuilder->SetArguments(aLS);
@@ -129,6 +130,7 @@ Standard_Integer bapibop(Draw_Interpretor& di,
   pBuilder->SetRunParallel(bRunParallel);
   pBuilder->SetFuzzyValue(aFuzzyValue);
   pBuilder->SetNonDestructive(bNonDestructive);
+  pBuilder->SetGlue(aGlue);
   //
   pBuilder->Build(); 
   iErr=pBuilder->ErrorStatus();
@@ -176,11 +178,13 @@ Standard_Integer bapibuild(Draw_Interpretor& di,
   bRunParallel=BOPTest_Objects::RunParallel();
   aFuzzyValue=BOPTest_Objects::FuzzyValue();
   bNonDestructive = BOPTest_Objects::NonDestructive();
+  BOPAlgo_GlueEnum aGlue = BOPTest_Objects::Glue();
   //
   aBuilder.SetArguments(aLS);
   aBuilder.SetRunParallel(bRunParallel);
   aBuilder.SetFuzzyValue(aFuzzyValue);
   aBuilder.SetNonDestructive(bNonDestructive);
+  aBuilder.SetGlue(aGlue);
   //
   aBuilder.Build(); 
   iErr=aBuilder.ErrorStatus();
index 631ce39..8b68725 100644 (file)
@@ -141,6 +141,7 @@ Standard_Integer bop(Draw_Interpretor& di,
   aTol=BOPTest_Objects::FuzzyValue();
   bRunParallel=BOPTest_Objects::RunParallel();
   bNonDestructive = BOPTest_Objects::NonDestructive();
+  BOPAlgo_GlueEnum aGlue = BOPTest_Objects::Glue();
   //
   aLC.Append(aS1);
   aLC.Append(aS2);
@@ -157,6 +158,7 @@ Standard_Integer bop(Draw_Interpretor& di,
   pPF->SetFuzzyValue(aTol);
   pPF->SetRunParallel(bRunParallel);
   pPF->SetNonDestructive(bNonDestructive);
+  pPF->SetGlue(aGlue);
   //
   pPF->Perform();
   iErr=pPF->ErrorStatus();
@@ -407,6 +409,7 @@ Standard_Integer  bsection(Draw_Interpretor& di,
   aTol = BOPTest_Objects::FuzzyValue(); 
   bRunParallel = BOPTest_Objects::RunParallel();
   bNonDestructive = BOPTest_Objects::NonDestructive();
+  BOPAlgo_GlueEnum aGlue = BOPTest_Objects::Glue();
   //
   for (i = 4; i < n; ++i) {
     if (!strcmp(a[i], "-n2d")) {
@@ -433,6 +436,7 @@ Standard_Integer  bsection(Draw_Interpretor& di,
   aSec.SetFuzzyValue(aTol);
   aSec.SetRunParallel(bRunParallel);
   aSec.SetNonDestructive(bNonDestructive);
+  aSec.SetGlue(aGlue);
   //
   aSec.Build();
   iErr=aSec.ErrorStatus();
@@ -484,6 +488,7 @@ Standard_Integer bsmt (Draw_Interpretor& di,
   aTol=BOPTest_Objects::FuzzyValue();
   bRunParallel = BOPTest_Objects::RunParallel();
   bNonDestructive = BOPTest_Objects::NonDestructive();
+  BOPAlgo_GlueEnum aGlue = BOPTest_Objects::Glue();
   //
   Handle(NCollection_BaseAllocator)aAL=
     NCollection_BaseAllocator::CommonBaseAllocator();
@@ -495,6 +500,7 @@ Standard_Integer bsmt (Draw_Interpretor& di,
   aPF.SetFuzzyValue(aTol); 
   aPF.SetRunParallel(bRunParallel);
   aPF.SetNonDestructive(bNonDestructive);
+  aPF.SetGlue(aGlue);
   //
   aPF.Perform();
   iErr=aPF.ErrorStatus();
@@ -739,6 +745,7 @@ Standard_Integer mkvolume(Draw_Interpretor& di, Standard_Integer n, const char**
   aTol = BOPTest_Objects::FuzzyValue();
   bRunParallel = BOPTest_Objects::RunParallel();
   bNonDestructive = BOPTest_Objects::NonDestructive();
+  BOPAlgo_GlueEnum aGlue = BOPTest_Objects::Glue();
   //
   bToIntersect = Standard_True;
   bCompounds = Standard_False;
@@ -789,6 +796,7 @@ Standard_Integer mkvolume(Draw_Interpretor& di, Standard_Integer n, const char**
   aMV.SetRunParallel(bRunParallel);
   aMV.SetFuzzyValue(aTol);
   aMV.SetNonDestructive(bNonDestructive);
+  aMV.SetGlue(aGlue);
   //
   aMV.Perform();
   if (aMV.ErrorStatus()) {
index 8956cdb..3183031 100644 (file)
@@ -80,7 +80,6 @@ Standard_Integer bcbuild(Draw_Interpretor& di,
     return 1;
   }
   //
-  Standard_Boolean bRunParallel;
   Standard_Integer iErr;
   BOPCol_ListIteratorOfListOfShape aIt;
   //
@@ -103,8 +102,16 @@ Standard_Integer bcbuild(Draw_Interpretor& di,
     aCBuilder.AddArgument(aS);
   }
   //
-  bRunParallel = BOPTest_Objects::RunParallel();
+  // set the options to the algorithm
+  Standard_Boolean bRunParallel = BOPTest_Objects::RunParallel();
+  Standard_Real aTol = BOPTest_Objects::FuzzyValue();
+  Standard_Boolean bNonDestructive = BOPTest_Objects::NonDestructive();
+  BOPAlgo_GlueEnum aGlue = BOPTest_Objects::Glue();
+  //
   aCBuilder.SetRunParallel(bRunParallel);
+  aCBuilder.SetFuzzyValue(aTol);
+  aCBuilder.SetNonDestructive(bNonDestructive);
+  aCBuilder.SetGlue(aGlue);
   //
   aCBuilder.PerformWithFiller(aPF); 
   iErr = aCBuilder.ErrorStatus();
index 338806d..2fad73b 100644 (file)
@@ -52,6 +52,7 @@ class BOPTest_Session {
     myRunParallel=Standard_False;
     myNonDestructive = Standard_False;
     myFuzzyValue = 0.;
+    myGlue = BOPAlgo_GlueOff;
   };
   //
   // Clear
@@ -123,6 +124,14 @@ class BOPTest_Session {
     return myNonDestructive;
   };
   //
+  void SetGlue(const BOPAlgo_GlueEnum theGlue) {
+    myGlue = theGlue;
+  };
+  //
+  BOPAlgo_GlueEnum Glue() const {
+    return myGlue;
+  };
+  //
 protected:
   //
   BOPTest_Session(const BOPTest_Session&);
@@ -139,6 +148,7 @@ protected:
   Standard_Boolean myRunParallel;
   Standard_Boolean myNonDestructive;
   Standard_Real myFuzzyValue;
+  BOPAlgo_GlueEnum myGlue;
 };
 //
 //=======================================================================
@@ -308,6 +318,22 @@ Standard_Boolean BOPTest_Objects::NonDestructive()
   return GetSession().NonDestructive();
 }
 //=======================================================================
+//function : SetGlue
+//purpose  : 
+//=======================================================================
+void BOPTest_Objects::SetGlue(const BOPAlgo_GlueEnum theGlue)
+{
+  GetSession().SetGlue(theGlue);
+}
+//=======================================================================
+//function : Glue
+//purpose  : 
+//=======================================================================
+BOPAlgo_GlueEnum BOPTest_Objects::Glue()
+{
+  return GetSession().Glue();
+}
+//=======================================================================
 //function : Allocator1
 //purpose  : 
 //=======================================================================
index 5283f15..e1d24ac 100644 (file)
@@ -25,6 +25,8 @@
 #include <Standard_Boolean.hxx>
 #include <Standard_Real.hxx>
 #include <BOPAlgo_CellsBuilder.hxx>
+#include <BOPAlgo_GlueEnum.hxx>
+//
 class BOPAlgo_PaveFiller;
 class BOPAlgo_Builder;
 class BOPAlgo_BOP;
@@ -75,7 +77,9 @@ public:
 
   Standard_EXPORT static Standard_Boolean NonDestructive();
 
+  Standard_EXPORT static void SetGlue(const BOPAlgo_GlueEnum aGlue);
 
+  Standard_EXPORT static BOPAlgo_GlueEnum Glue();
 
 
 protected:
index 1c395f6..8e38fb7 100644 (file)
@@ -17,6 +17,7 @@
 #include <BOPTest_Objects.hxx>
 #include <DBRep.hxx>
 #include <Draw.hxx>
+#include <BOPAlgo_GlueEnum.hxx>
 
 #include <stdio.h>
 #include <string.h>
@@ -24,6 +25,7 @@ static Standard_Integer boptions (Draw_Interpretor&, Standard_Integer, const cha
 static Standard_Integer brunparallel (Draw_Interpretor&, Standard_Integer, const char**); 
 static Standard_Integer bnondestructive(Draw_Interpretor&, Standard_Integer, const char**);
 static Standard_Integer bfuzzyvalue(Draw_Interpretor&, Standard_Integer, const char**);
+static Standard_Integer bGlue(Draw_Interpretor&, Standard_Integer, const char**);
 
 //=======================================================================
 //function : OptionCommands
@@ -41,6 +43,7 @@ void BOPTest::OptionCommands(Draw_Interpretor& theCommands)
   theCommands.Add("brunparallel", "use brunparallel [0/1]" , __FILE__, brunparallel, g);
   theCommands.Add("bnondestructive", "use bnondestructive [0/1]", __FILE__, bnondestructive, g);
   theCommands.Add("bfuzzyvalue", "use bfuzzyvalue value", __FILE__, bfuzzyvalue, g);
+  theCommands.Add("bglue", "use bglue [0 (off) / 1 (shift) / 2 (full)]", __FILE__, bGlue, g);
 }
 //=======================================================================
 //function : boptions
@@ -58,16 +61,21 @@ Standard_Integer boptions(Draw_Interpretor& di,
   char buf[128];
   Standard_Boolean bRunParallel, bNonDestructive;
   Standard_Real aFuzzyValue;
+  BOPAlgo_GlueEnum aGlue;
   //
   bRunParallel=BOPTest_Objects::RunParallel();
   bNonDestructive = BOPTest_Objects::NonDestructive();
   aFuzzyValue = BOPTest_Objects::FuzzyValue();
-  
+  aGlue = BOPTest_Objects::Glue();
+  //
   Sprintf(buf, " RunParallel: %d\n",  bRunParallel);
   di << buf;
   Sprintf(buf, " NonDestructive: %d\n", bNonDestructive);
   di << buf;
-  Sprintf(buf, " FuzzyValue : %lf\n", aFuzzyValue);
+  Sprintf(buf, " FuzzyValue: %lf\n", aFuzzyValue);
+  di << buf;
+  Sprintf(buf, " GlueOption: %s\n", ((aGlue == BOPAlgo_GlueOff) ? "Off" :
+    ((aGlue == BOPAlgo_GlueFull) ? "Full" : "Shift")));
   di << buf;
   //
   return 0;
@@ -151,3 +159,28 @@ Standard_Integer bnondestructive(Draw_Interpretor& di,
   //
   return 0;
 }
+
+//=======================================================================
+//function : bglue
+//purpose  : 
+//=======================================================================
+Standard_Integer bGlue(Draw_Interpretor& di,
+                             Standard_Integer n,
+                             const char** a)
+{
+  if (n != 2) {
+    di << " use bglue [0 (off) / 1 (shift) / 2 (full)]\n";
+    return 1;
+  }
+  //
+  Standard_Integer iGlue = Draw::Atoi(a[1]);
+  if (iGlue < 0 || iGlue > 2) {
+    di << " Wrong value. Use bglue [0 (off) / 1 (shift) / 2 (full)]\n";
+    return 1;
+  }
+  //
+  BOPAlgo_GlueEnum aGlue = BOPAlgo_GlueEnum(iGlue);
+  BOPTest_Objects::SetGlue(aGlue);
+  //
+  return 0;
+}
index 5718130..a86e0c9 100644 (file)
@@ -83,12 +83,13 @@ Standard_Integer bfillds(Draw_Interpretor& di,
   bRunParallel=BOPTest_Objects::RunParallel();
   bNonDestructive = BOPTest_Objects::NonDestructive();
   aTol = BOPTest_Objects::FuzzyValue();
+  BOPAlgo_GlueEnum aGlue = BOPTest_Objects::Glue();
   //
   for (i=1; i<n; ++i) {
     if (!strcmp(a[i], "-t")) {
       bShowTime=Standard_True;
     }
-    }
+  }
   //
   BOPCol_ListOfShape& aLT=BOPTest_Objects::Tools();
   //
@@ -110,6 +111,7 @@ Standard_Integer bfillds(Draw_Interpretor& di,
   aPF.SetRunParallel(bRunParallel);
   aPF.SetNonDestructive(bNonDestructive);
   aPF.SetFuzzyValue(aTol);
+  aPF.SetGlue(aGlue);
   //
   OSD_Timer aTimer;
   aTimer.Start();
index ce20031..33e7f9a 100644 (file)
@@ -308,6 +308,7 @@ void BRepAlgoAPI_BooleanOperation::Build()
     myDSFiller->SetProgressIndicator(myProgressIndicator);
     myDSFiller->SetFuzzyValue(myFuzzyValue);
     myDSFiller->SetNonDestructive(myNonDestructive);
+    myDSFiller->SetGlue(myGlue);
     //
     SetAttributes();
     //
index da28188..f086acb 100644 (file)
@@ -29,7 +29,8 @@ BRepAlgoAPI_BuilderAlgo::BRepAlgoAPI_BuilderAlgo()
   myDSFiller(NULL),
   myBuilder(NULL),
   myFuzzyValue(0.),
-  myNonDestructive(Standard_False)
+  myNonDestructive(Standard_False),
+  myGlue(BOPAlgo_GlueOff)
 {}
 //=======================================================================
 // function: 
@@ -42,7 +43,8 @@ BRepAlgoAPI_BuilderAlgo::BRepAlgoAPI_BuilderAlgo
   myEntryType(0),
   myBuilder(NULL),
   myFuzzyValue(0.),
-  myNonDestructive(Standard_False)
+  myNonDestructive(Standard_False),
+  myGlue(BOPAlgo_GlueOff)
 {
   BOPAlgo_PaveFiller* pPF=(BOPAlgo_PaveFiller*)&aPF;
   myDSFiller=pPF;
@@ -88,6 +90,22 @@ Standard_Boolean BRepAlgoAPI_BuilderAlgo::NonDestructive() const
   return myNonDestructive;
 }
 //=======================================================================
+//function : SetGlue
+//purpose  : 
+//=======================================================================
+void BRepAlgoAPI_BuilderAlgo::SetGlue(const BOPAlgo_GlueEnum theGlue)
+{
+  myGlue=theGlue;
+}
+//=======================================================================
+//function : Glue
+//purpose  : 
+//=======================================================================
+BOPAlgo_GlueEnum BRepAlgoAPI_BuilderAlgo::Glue() const 
+{
+  return myGlue;
+}
+//=======================================================================
 //function : Clear
 //purpose  : 
 //=======================================================================
@@ -144,6 +162,7 @@ void BRepAlgoAPI_BuilderAlgo::Build()
     myDSFiller->SetProgressIndicator(myProgressIndicator);
     myDSFiller->SetFuzzyValue(myFuzzyValue);
     myDSFiller->SetNonDestructive(myNonDestructive);
+    myDSFiller->SetGlue(myGlue);
     //
     myDSFiller->Perform();
     iErr=myDSFiller->ErrorStatus();
index 9ed9b27..d7e5640 100644 (file)
@@ -22,6 +22,7 @@
 #include <Standard_Integer.hxx>
 #include <BOPAlgo_PPaveFiller.hxx>
 #include <BOPAlgo_PBuilder.hxx>
+#include <BOPAlgo_GlueEnum.hxx>
 #include <Standard_Real.hxx>
 #include <TopTools_ListOfShape.hxx>
 #include <BRepAlgoAPI_Algo.hxx>
@@ -62,6 +63,12 @@ Standard_EXPORT virtual ~BRepAlgoAPI_BuilderAlgo();
   //! a copy of a sub-shape is created in the result if it is needed to be updated.
   Standard_EXPORT Standard_Boolean NonDestructive() const;
 
+  //! Sets the glue option for the algorithm
+  Standard_EXPORT void SetGlue(const BOPAlgo_GlueEnum theGlue);
+  
+  //! Returns the glue option of the algorithm
+  Standard_EXPORT BOPAlgo_GlueEnum Glue() const;
+
   //! Sets the arguments
   Standard_EXPORT void SetArguments (const TopTools_ListOfShape& theLS);
   
@@ -113,6 +120,7 @@ protected:
   Standard_Real myFuzzyValue;
   Standard_Boolean myNonDestructive;
   TopTools_ListOfShape myArguments;
+  BOPAlgo_GlueEnum myGlue;
 
 
 private:
diff --git a/tests/bugs/modalg_6/bug27878_1 b/tests/bugs/modalg_6/bug27878_1
new file mode 100644 (file)
index 0000000..e0e0525
--- /dev/null
@@ -0,0 +1,24 @@
+puts "========"
+puts "OCC27878"
+puts "========"
+puts ""
+#################################################
+# Development of the Gluing operations based on the new Boolean component
+#################################################
+
+# planar boxes
+
+restore [locate_data_file bug27878_shapes1.brep] c
+
+# fusing the solids using the glue option
+bglue 2
+bclearobjects
+bcleartools
+baddobjects {*}[explode c so]
+bfillds -t
+bbuild result
+
+checknbshapes result -face 1176 -solid 343
+checkprops result -s 2058 -v 343
+
+checkview -display result -2d -path ${imagedir}/${test_image}.png
\ No newline at end of file
diff --git a/tests/bugs/modalg_6/bug27878_2 b/tests/bugs/modalg_6/bug27878_2
new file mode 100644 (file)
index 0000000..57b1dbd
--- /dev/null
@@ -0,0 +1,24 @@
+puts "========"
+puts "OCC27878"
+puts "========"
+puts ""
+#################################################
+# Development of the Gluing operations based on the new Boolean component
+#################################################
+
+# bspline boxes
+
+restore [locate_data_file bug27878_shapes2.brep] c
+
+# fusing the solids using the glue option
+bglue 2
+bclearobjects
+bcleartools
+baddobjects {*}[explode c so]
+bfillds -t
+bbuild result
+
+checknbshapes result -face 240 -solid 64
+checkprops result -s 384 -v 64
+
+checkview -display result -2d -path ${imagedir}/${test_image}.png
\ No newline at end of file
diff --git a/tests/bugs/modalg_6/bug27878_3 b/tests/bugs/modalg_6/bug27878_3
new file mode 100644 (file)
index 0000000..c351cce
--- /dev/null
@@ -0,0 +1,24 @@
+puts "========"
+puts "OCC27878"
+puts "========"
+puts ""
+#################################################
+# Development of the Gluing operations based on the new Boolean component
+#################################################
+
+# planar boxes shifted x y
+
+restore [locate_data_file bug27878_shapes3.brep] c
+
+# fusing the solids using the glue option
+bglue 1
+bclearobjects
+bcleartools
+baddobjects {*}[explode c so]
+bfillds -t
+bbuild result
+
+checknbshapes result -face 2052 -solid 343
+checkprops result -s 2058 -v 343
+
+checkview -display result -2d -path ${imagedir}/${test_image}.png
\ No newline at end of file
diff --git a/tests/bugs/modalg_6/bug27878_4 b/tests/bugs/modalg_6/bug27878_4
new file mode 100644 (file)
index 0000000..e547068
--- /dev/null
@@ -0,0 +1,24 @@
+puts "========"
+puts "OCC27878"
+puts "========"
+puts ""
+#################################################
+# Development of the Gluing operations based on the new Boolean component
+#################################################
+
+# bspline boxes shifted x y
+
+restore [locate_data_file bug27878_shapes4.brep] c
+
+# fusing the solids using the glue option
+bglue 1
+bclearobjects
+bcleartools
+baddobjects {*}[explode c so]
+bfillds -t
+bbuild result
+
+checknbshapes result -face 381 -solid 64
+checkprops result -s 384 -v 64
+
+checkview -display result -2d -path ${imagedir}/${test_image}.png
\ No newline at end of file
diff --git a/tests/bugs/modalg_6/bug27878_5 b/tests/bugs/modalg_6/bug27878_5
new file mode 100644 (file)
index 0000000..1031bbb
--- /dev/null
@@ -0,0 +1,26 @@
+puts "========"
+puts "OCC27878"
+puts "========"
+puts ""
+#################################################
+# Development of the Gluing operations based on the new Boolean component
+#################################################
+
+restore [locate_data_file bug28165_shapes3.brep] c
+
+# fuse the shapes
+bglue 1
+bclearobjects
+bcleartools
+baddobjects {*}[explode c so]
+bfillds -t
+
+# remove all internal faces to make only one solid
+bcbuild rx
+bcaddall result -m 1 -u
+
+checkshape result
+checknbshapes result -edge 1400 -face 506 -solid 1
+checkprops result -v 4.69342e+007 -s 1.38778e+006
+
+checkview -display result -2d -path ${imagedir}/${test_image}.png
\ No newline at end of file
diff --git a/tests/bugs/modalg_6/bug27878_6 b/tests/bugs/modalg_6/bug27878_6
new file mode 100644 (file)
index 0000000..a5c364c
--- /dev/null
@@ -0,0 +1,46 @@
+puts "========"
+puts "OCC27878"
+puts "========"
+puts ""
+#################################################
+# Development of the Gluing operations based on the new Boolean component
+#################################################
+
+compound sh
+for {set i 0} {$i < 4} {incr i} {
+  for {set j 0} {$j < 4} {incr j} {
+    box b 1 1 1;
+    ttranslate b $i $j 0;
+    add b sh
+  }
+}
+
+nurbsconvert b1 sh
+
+#fuse boxes using glue full option
+bglue 2
+
+bclearobjects
+bcleartools
+baddobjects {*}[explode b1 so]
+bfillds -t
+bcbuild rx
+bcaddall res1 -m 1 -u
+
+copy res1 b2
+ttranslate b2 0.5 0.5 1
+
+# fuse two solids using glue shift
+bglue 1
+
+chrono t reset; chrono t start
+bop res1 b2
+chrono t stop; chrono t show
+
+bopfuse result
+
+checkshape result
+checknbshapes result -face 78 -solid 1
+checkprops result -s 71.5 -v 32
+
+checkview -display result -2d -path ${imagedir}/${test_image}.png
\ No newline at end of file