OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-04 18:06:22 +03:00
Code Packages Releases Activity

0027878: Development of the Gluing operations based on the new Boolean component

Browse Source 
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.
This commit is contained in:
emv 2016-12-08 16:49:29 +03:00 committed by apn
parent b4327ba8df
commit 483ce1bd89
33 changed files with 628 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
dox/user_guides/boolean_operations/boolean_operations.md
View 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.

BIN
dox/user_guides/boolean_operations/images/glue_options_image001.PNG Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 4.3 KiB

BIN
dox/user_guides/boolean_operations/images/glue_options_image002.PNG Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 3.4 KiB

BIN
dox/user_guides/boolean_operations/images/glue_options_image003.PNG Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 4.6 KiB

BIN
dox/user_guides/boolean_operations/images/glue_options_image004.PNG Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 12 KiB

BIN
dox/user_guides/boolean_operations/images/glue_options_image005.PNG Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 19 KiB

1
src/BOPAlgo/BOPAlgo_BOP.cxx
View File

@ -376,6 +376,7 @@ void BOPAlgo_BOP::Perform()
pPF->SetProgressIndicator(myProgressIndicator);
pPF->SetFuzzyValue(myFuzzyValue);
pPF->SetNonDestructive(myNonDestructive);
pPF->SetGlue(myGlue);
//
pPF->Perform();
//

24
src/BOPAlgo/BOPAlgo_Builder.cxx
View 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);
}
//=======================================================================

7
src/BOPAlgo/BOPAlgo_Builder.hxx
View 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:

64
src/BOPAlgo/BOPAlgo_GlueEnum.hxx Normal file
View File

@ -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

1
src/BOPAlgo/BOPAlgo_MakerVolume.cxx
View 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;

22
src/BOPAlgo/BOPAlgo_PaveFiller.cxx
View 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) {

10
src/BOPAlgo/BOPAlgo_PaveFiller.hxx
View 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:

175
src/BOPAlgo/BOPAlgo_PaveFiller_4.cxx
View 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();
aVFs.SetIncrement(iSize);
}
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();
}
//=======================================================================

23
src/BOPAlgo/BOPAlgo_PaveFiller_5.cxx
View 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;

46
src/BOPAlgo/BOPAlgo_PaveFiller_6.cxx
View 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;

1
src/BOPAlgo/FILES
View File

@ -65,3 +65,4 @@ BOPAlgo_WireSplitter.lxx
BOPAlgo_WireSplitter_1.cxx
BOPAlgo_CellsBuilder.cxx
BOPAlgo_CellsBuilder.hxx
BOPAlgo_GlueEnum.hxx

4
src/BOPTest/BOPTest_APICommands.cxx
View 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();

8
src/BOPTest/BOPTest_BOPCommands.cxx
View 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()) {

11
src/BOPTest/BOPTest_CellsCommands.cxx
View 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();

26
src/BOPTest/BOPTest_Objects.cxx
View 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 :
//=======================================================================

4
src/BOPTest/BOPTest_Objects.hxx
View 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:

37
src/BOPTest/BOPTest_OptionCommands.cxx
View 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;
}

4
src/BOPTest/BOPTest_PartitionCommands.cxx
View 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();

1
src/BRepAlgoAPI/BRepAlgoAPI_BooleanOperation.cxx
View File

@ -308,6 +308,7 @@ void BRepAlgoAPI_BooleanOperation::Build()
myDSFiller->SetProgressIndicator(myProgressIndicator);
myDSFiller->SetFuzzyValue(myFuzzyValue);
myDSFiller->SetNonDestructive(myNonDestructive);
myDSFiller->SetGlue(myGlue);
//
SetAttributes();
//

23
src/BRepAlgoAPI/BRepAlgoAPI_BuilderAlgo.cxx
View 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();

8
src/BRepAlgoAPI/BRepAlgoAPI_BuilderAlgo.hxx
View 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:

24
tests/bugs/modalg_6/bug27878_1 Normal file
View File

@ -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

24
tests/bugs/modalg_6/bug27878_2 Normal file
View File

@ -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

24
tests/bugs/modalg_6/bug27878_3 Normal file
View File

@ -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

24
tests/bugs/modalg_6/bug27878_4 Normal file
View File

@ -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

26
tests/bugs/modalg_6/bug27878_5 Normal file
View File

@ -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

46
tests/bugs/modalg_6/bug27878_6 Normal file
View File

@ -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