OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-08-09 13:22:24 +03:00
Code Activity

0028165: Improve performance of Boolean Operations

Browse Source 
1. Unification of the usage of the BRepAdaptor_Surface in Boolean Operations algorithm.
For each face when it is necessary the Adaptor is initialized only once and stored in Context.

For that purpose the new IntTools_Context::SurfaceAdaptor(const TopoDS_Face&) method has been implemented.

To provide possibility to take the Adaptor from the context, the context has been added as
a parameter in following methods:
BOPTools_AlgoTools::MakePCurve()
BOPTools_AlgoTools::Sence()
BOPTools_AlgoTools2D::BuildPCurveForEdgeOnFace()
BOPTools_AlgoTools2D::PointOnSurface
BOPTools_AlgoTools2D::CurveOnSurface
BOPTools_AlgoTools2D::AdjustPCurveOnFace
BOPTools_AlgoTools2D::Make2D
BOPTools_AlgoTools2D::MakePCurveOnFace
BOPTools_AlgoTools3D::GetNormalToFaceOnEdge

It is also possible now to pass the context into BOPAlgo_WireSplitter algorithm.

Also, the new IntTools_Context::UVBounds(const TopoDS_Face&) method
has been implemented to get the UV bounds of a face.

2. Additional improvement is a calculation of reduced intersection range only for the intersection
type VERTEX during computation of Edge/Face interference.

3. The methods IntTools_EdgeFace::Prepare() and IntTools_EdgeFace::FindProjectableRoot()
and the fields IntTools_EdgeFace::myProjectableRanges and IntTools_EdgeFace::myFClass2d
have been removed as obsolete.

4. Test cases for the issue.
This commit is contained in:
emv
2016-11-30 13:29:37 +03:00
committed by apn
parent 483ce1bd89
commit 51db017972
31 changed files with 623 additions and 488 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/BOPAlgo/BOPAlgo_BuilderFace.cxx
View File

@@ -348,6 +348,7 @@ void BOPAlgo_BuilderFace::PerformLoops()
//
aWSp.SetWES(aWES);
aWSp.SetRunParallel(myRunParallel);
aWSp.SetContext(myContext);
aWSp.Perform();
iErr=aWSp.ErrorStatus();
if (iErr) {
@@ -839,7 +840,7 @@ Standard_Boolean IsInside(const TopoDS_Shape& theHole,
if (!BRep_Tool::Degenerated(aE)) {
//
aT=BOPTools_AlgoTools2D::IntermediatePoint(aE);
BOPTools_AlgoTools2D::PointOnSurface(aE, aF2, aT, aU, aV);
BOPTools_AlgoTools2D::PointOnSurface(aE, aF2, aT, aU, aV, theContext);
aP2D.SetCoord(aU, aV);
//
IntTools_FClass2d& aClsf=theContext->FClass2d(aF2);

2
src/BOPAlgo/BOPAlgo_Builder_2.cxx
View File

@@ -715,7 +715,7 @@ void BOPAlgo_Builder::FillImagesFaces1()
}
else {
aFSD=(*(TopoDS_Face*)(&myShapesSD.Find(aFSp)));
iSense=BOPTools_AlgoTools::Sense(aFSp, aFSD);
iSense=BOPTools_AlgoTools::Sense(aFSp, aFSD, myContext);
if (iSense<0) {
aFSD.Reverse();
}

2
src/BOPAlgo/BOPAlgo_PaveFiller.cxx
View File

@@ -151,7 +151,7 @@ BOPDS_PDS BOPAlgo_PaveFiller::PDS()
//function : Context
//purpose :
//=======================================================================
Handle(IntTools_Context) BOPAlgo_PaveFiller::Context()
const Handle(IntTools_Context)& BOPAlgo_PaveFiller::Context()
{
return myContext;
}

2
src/BOPAlgo/BOPAlgo_PaveFiller.hxx
View File

@@ -84,7 +84,7 @@ public:
Standard_EXPORT const BOPCol_ListOfShape& Arguments() const;
Standard_EXPORT Handle(IntTools_Context) Context();
Standard_EXPORT const Handle(IntTools_Context)& Context();
Standard_EXPORT void SetSectionAttribute (const BOPAlgo_SectionAttribute& theSecAttr);

19
src/BOPAlgo/BOPAlgo_PaveFiller_10.cxx
View File

@@ -243,6 +243,7 @@ void BOPAlgo_PaveFiller::PerformVZ()
Standard_Boolean bJustAdd;
Standard_Integer iSize, nV, nZ, k, aNbVVS;
TopAbs_State aState;
BOPDS_MapOfPassKey aMPK;
//
myErrorStatus=0;
//
@@ -263,11 +264,21 @@ void BOPAlgo_PaveFiller::PerformVZ()
continue;
}
//
const BOPDS_ShapeInfo& aSIV=myDS->ShapeInfo(nV);
const BOPDS_ShapeInfo& aSIZ=myDS->ShapeInfo(nZ);
if (myDS->HasInterfShapeSubShapes(nV, nZ)) {
continue;
}
//
const TopoDS_Vertex& aV=*((TopoDS_Vertex*)&aSIV.Shape());
const TopoDS_Solid& aZ=*((TopoDS_Solid*)&aSIZ.Shape());
Standard_Integer nVSD = nV;
myDS->HasShapeSD(nV, nVSD);
//
BOPDS_PassKey aPK;
aPK.SetIds(nVSD, nZ);
if (!aMPK.Add(aPK)) {
continue;
}
//
const TopoDS_Vertex& aV=*((TopoDS_Vertex*)&myDS->Shape(nVSD));
const TopoDS_Solid& aZ=*((TopoDS_Solid*)&myDS->Shape(nZ));
//
BOPAlgo_VertexSolid& aVertexSolid=aVVS.Append1();
aVertexSolid.SetIndices(nV, nZ);

10
src/BOPAlgo/BOPAlgo_PaveFiller_3.cxx
View File

@@ -427,6 +427,11 @@ void BOPAlgo_PaveFiller::PerformEE()
continue;
}
//
const IntTools_SequenceOfCommonPrts& aCPrts = anEdgeEdge.CommonParts();
aNbCPrts = aCPrts.Length();
if (!aNbCPrts) {
continue;
}
//--------------------------------------------
Handle(BOPDS_PaveBlock)& aPB1=anEdgeEdge.PaveBlock1();
nE1=aPB1->OriginalEdge();
@@ -456,11 +461,8 @@ void BOPAlgo_PaveFiller::PerformEE()
IntTools_Range aR11(aT11, aTS11), aR12(aTS12, aT12),
aR21(aT21, aTS21), aR22(aTS22, aT22);
//
const IntTools_SequenceOfCommonPrts& aCPrts = anEdgeEdge.CommonParts();
aNbCPrts = aCPrts.Length();
//
Standard_Boolean bAnalytical = Standard_False;
if (aNbCPrts) {
{
const TopoDS_Edge& aOE1 = *(TopoDS_Edge*)&myDS->Shape(nE1);
const TopoDS_Edge& aOE2 = *(TopoDS_Edge*)&myDS->Shape(nE2);
//

32
src/BOPAlgo/BOPAlgo_PaveFiller_5.cxx
View File

@@ -273,7 +273,13 @@ void BOPAlgo_PaveFiller::PerformEF()
if (!aEdgeFace.IsDone()) {
continue;
}
//~~~
//
const IntTools_SequenceOfCommonPrts& aCPrts=aEdgeFace.CommonParts();
aNbCPrts = aCPrts.Length();
if (!aNbCPrts) {
continue;
}
//
aEdgeFace.Indices(nE, nF);
//
const TopoDS_Edge& aE=aEdgeFace.Edge();
@@ -290,29 +296,27 @@ void BOPAlgo_PaveFiller::PerformEF()
//
anewSR.Range(aTS1, aTS2);
//
// extend vertices ranges using Edge/Edge intersections
// between the edge aE and the edges of the face aF.
// thereby the edge's intersection range is reduced
ReduceIntersectionRange(nV[0], nV[1], nE, nF, aTS1, aTS2);
if (aCPrts(1).Type() == TopAbs_VERTEX) {
// for the intersection type VERTEX
// extend vertices ranges using Edge/Edge intersections
// between the edge aE and the edges of the face aF.
// thereby the edge's intersection range is reduced
ReduceIntersectionRange(nV[0], nV[1], nE, nF, aTS1, aTS2);
}
//
IntTools_Range aR1(aT1, aTS1), aR2(aTS2, aT2);
//
BOPDS_FaceInfo& aFI=myDS->ChangeFaceInfo(nF);
const BOPCol_MapOfInteger& aMIFOn=aFI.VerticesOn();
const BOPCol_MapOfInteger& aMIFIn=aFI.VerticesIn();
//~~~
const IntTools_SequenceOfCommonPrts& aCPrts=aEdgeFace.CommonParts();
aNbCPrts = aCPrts.Length();
//
Standard_Boolean bLinePlane = Standard_False;
if (aNbCPrts) {
BRepAdaptor_Curve aBAC(aE);
BRepAdaptor_Surface aBAS(aF, Standard_False);
//
bLinePlane = (aBAC.GetType() == GeomAbs_Line &&
aBAS.GetType() == GeomAbs_Plane);
myContext->SurfaceAdaptor(aF).GetType() == GeomAbs_Plane);
}
//
for (i=1; i<=aNbCPrts; ++i) {
const IntTools_CommonPrt& aCPart=aCPrts(i);
aType=aCPart.Type();
@@ -766,6 +770,10 @@ void BOPAlgo_PaveFiller::ReduceIntersectionRange(const Standard_Integer theV1,
return;
}
//
if (!myDS->HasInterfShapeSubShapes(theE, theF)) {
return;
}
//
BOPDS_VectorOfInterfEE& aEEs = myDS->InterfEE();
Standard_Integer aNbEEs = aEEs.Extent();
if (!aNbEEs) {

10
src/BOPAlgo/BOPAlgo_PaveFiller_6.cxx
View File

@@ -189,7 +189,6 @@ void BOPAlgo_PaveFiller::PerformFF()
Standard_Integer nF1, nF2, aNbCurves, aNbPoints, i, aNbLP;
Standard_Integer aNbFaceFace, k;
Standard_Real aApproxTol, aTolR3D, aTolR2D, aTolFF, aTolReal;
BRepAdaptor_Surface aBAS1, aBAS2;
BOPCol_MapOfInteger aMI;
BOPAlgo_VectorOfFaceFace aVFaceFace;
//
@@ -220,8 +219,8 @@ void BOPAlgo_PaveFiller::PerformFF()
myDS->UpdateFaceInfoIn(nF2);
}
//
aBAS1.Initialize(aF1, Standard_False);
aBAS2.Initialize(aF2, Standard_False);
const BRepAdaptor_Surface& aBAS1 = myContext->SurfaceAdaptor(aF1);
const BRepAdaptor_Surface& aBAS2 = myContext->SurfaceAdaptor(aF2);
if (aBAS1.GetType() == GeomAbs_Plane &&
aBAS2.GetType() == GeomAbs_Plane) {
Standard_Boolean bToIntersect;
@@ -235,7 +234,7 @@ void BOPAlgo_PaveFiller::PerformFF()
}
}
//
ToleranceFF(aBAS1, aBAS2, aTolFF);
ToleranceFF(aBAS1, aBAS2, aTolFF);
//
if (myGlue == BOPAlgo_GlueOff) {
BOPAlgo_FaceFace& aFaceFace=aVFaceFace.Append1();
@@ -613,7 +612,8 @@ void BOPAlgo_PaveFiller::MakeBlocks()
// Make p-curves
BOPTools_AlgoTools::MakePCurve(aES, aF1, aF2, aIC,
mySectionAttribute.PCurveOnS1(),
mySectionAttribute.PCurveOnS2());
mySectionAttribute.PCurveOnS2(),
myContext);
//
// Append the Pave Block to the Curve j
aLPBC.Append(aPB);

2
src/BOPAlgo/BOPAlgo_PaveFiller_7.cxx
View File

@@ -258,7 +258,7 @@ class BOPAlgo_MPC : public BOPAlgo_Algo {
}
//
if (iErr) {
BOPTools_AlgoTools2D::BuildPCurveForEdgeOnFace(myE, myF);
BOPTools_AlgoTools2D::BuildPCurveForEdgeOnFace(myE, myF, myContext);
}
//
if (myFlag) {

134
src/BOPAlgo/BOPAlgo_WireSplitter.cxx
View File

@@ -79,6 +79,22 @@ BOPAlgo_WireEdgeSet& BOPAlgo_WireSplitter::WES()
return *myWES;
}
//=======================================================================
//function : SetContext
//purpose :
//=======================================================================
void BOPAlgo_WireSplitter::SetContext(const Handle(IntTools_Context)& theContext)
{
myContext = theContext;
}
//=======================================================================
//function : Context
//purpose :
//=======================================================================
const Handle(IntTools_Context)& BOPAlgo_WireSplitter::Context()
{
return myContext;
}
//=======================================================================
// function: CheckData
// purpose:
//=======================================================================
@@ -103,6 +119,11 @@ void BOPAlgo_WireSplitter::Perform()
return;
}
//
// create a context
if (myContext.IsNull()) {
myContext = new IntTools_Context;
}
//
MakeConnexityBlocks();
MakeWires();
}
@@ -251,56 +272,59 @@ void BOPAlgo_WireSplitter::MakeConnexityBlocks()
}
}
/////////////////////////////////////////////////////////////////////////
class BOPAlgo_WS_ConnexityBlock {
public:
BOPAlgo_WS_ConnexityBlock() {};
~BOPAlgo_WS_ConnexityBlock() {};
typedef BOPCol_NCVector<BOPTools_ConnexityBlock> \
BOPTools_VectorOfConnexityBlock;
void SetFace(const TopoDS_Face& theF) {
myFace = theF;
}
const TopoDS_Face& Face() const {
return myFace;
}
void SetConnexityBlock(const BOPTools_ConnexityBlock& theCB) {
myCB = theCB;
}
const BOPTools_ConnexityBlock& ConnexityBlock() const {
return myCB;
}
void SetContext(const Handle(IntTools_Context)& aContext) {
myContext = aContext;
}
//
const Handle(IntTools_Context)& Context()const {
return myContext;
}
void Perform() {
BOPAlgo_WireSplitter::SplitBlock(myFace, myCB, myContext);
}
//=======================================================================
//class : WireSplitterFunctor
//purpose :
//=======================================================================
class BOPAlgo_WireSplitterFunctor
{
protected:
TopoDS_Face myFace;
BOPTools_VectorOfConnexityBlock* myPVCB;
BOPTools_ConnexityBlock myCB;
Handle(IntTools_Context) myContext;
};
typedef BOPCol_NCVector<BOPAlgo_WS_ConnexityBlock> \
BOPAlgo_VectorOfConnexityBlock;
//
typedef BOPCol_ContextFunctor
<BOPAlgo_WS_ConnexityBlock,
BOPAlgo_VectorOfConnexityBlock,
Handle(IntTools_Context),
IntTools_Context> BOPAlgo_SplitBlockFunctor;
//
typedef BOPCol_ContextCnt
<BOPAlgo_SplitBlockFunctor,
BOPAlgo_VectorOfConnexityBlock,
Handle(IntTools_Context)> BOPAlgo_SplitBlockCnt;
public:
//
BOPAlgo_WireSplitterFunctor(const TopoDS_Face& aF,
BOPTools_VectorOfConnexityBlock& aVCB)
: myFace(aF), myPVCB(&aVCB)
{
}
//
void operator()( const Standard_Integer& theIndex ) const
{
BOPTools_VectorOfConnexityBlock& aVCB = *myPVCB;
BOPTools_ConnexityBlock& aCB = aVCB(theIndex);
BOPAlgo_WireSplitter::SplitBlock(myFace, aCB);
}
};
//=======================================================================
//class : BOPAlgo_WireSplitterCnt
//purpose :
//=======================================================================
class BOPAlgo_WireSplitterCnt
{
public:
//-------------------------------
// Perform
Standard_EXPORT
static void Perform(const Standard_Boolean bRunParallel,
const TopoDS_Face& aF,
BOPTools_VectorOfConnexityBlock& aVCB)
{
//
BOPAlgo_WireSplitterFunctor aWSF(aF, aVCB);
Standard_Integer aNbVCB = aVCB.Extent();
//
OSD_Parallel::For(0, aNbVCB, aWSF, !bRunParallel);
}
};
//=======================================================================
//function : MakeWires
//purpose :
@@ -312,7 +336,9 @@ void BOPAlgo_WireSplitter::MakeWires()
TopoDS_Wire aW;
BOPTools_ListIteratorOfListOfConnexityBlock aItCB;
BOPCol_ListIteratorOfListOfShape aIt;
BOPTools_VectorOfConnexityBlock aVCB;
BOPAlgo_VectorOfConnexityBlock aVCB;
//
const TopoDS_Face& aF=myWES->Face();
//
aItCB.Initialize(myLCB);
for (; aItCB.More(); aItCB.Next()) {
@@ -324,18 +350,18 @@ void BOPAlgo_WireSplitter::MakeWires()
myWES->AddShape(aW);
}
else {
aVCB.Append(aCB);
BOPAlgo_WS_ConnexityBlock& aWSCB = aVCB.Append1();
aWSCB.SetFace(aF);
aWSCB.SetConnexityBlock(aCB);
}
}
//
//===================================================
BOPAlgo_SplitBlockCnt::Perform(myRunParallel, aVCB, myContext);
//===================================================
aNbVCB=aVCB.Extent();
const TopoDS_Face& aF=myWES->Face();
//===================================================
BOPAlgo_WireSplitterCnt::Perform(myRunParallel, aF, aVCB);
//===================================================
for (k=0; k<aNbVCB; ++k) {
const BOPTools_ConnexityBlock& aCB=aVCB(k);
const BOPCol_ListOfShape& aLW=aCB.Loops();
const BOPAlgo_WS_ConnexityBlock& aCB=aVCB(k);
const BOPCol_ListOfShape& aLW=aCB.ConnexityBlock().Loops();
aIt.Initialize(aLW);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aWx=aIt.Value();

34
src/BOPAlgo/BOPAlgo_WireSplitter.hxx
View File

@@ -25,12 +25,12 @@
#include <BOPCol_BaseAllocator.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPTools_ConnexityBlock.hxx>
#include <IntTools_Context.hxx>
class BOPAlgo_WireEdgeSet;
class TopoDS_Wire;
class TopoDS_Face;
class BOPAlgo_WireSplitter : public BOPAlgo_Algo
{
public:
@@ -39,50 +39,44 @@ public:
Standard_EXPORT BOPAlgo_WireSplitter();
Standard_EXPORT virtual ~BOPAlgo_WireSplitter();
Standard_EXPORT virtual ~BOPAlgo_WireSplitter();
Standard_EXPORT BOPAlgo_WireSplitter(const BOPCol_BaseAllocator& theAllocator);
Standard_EXPORT void SetWES (const BOPAlgo_WireEdgeSet& theWES);
Standard_EXPORT BOPAlgo_WireEdgeSet& WES();
//! Sets the context for the algorithm
Standard_EXPORT void SetContext(const Handle(IntTools_Context)& theContext);
//! Returns the context
Standard_EXPORT const Handle(IntTools_Context)& Context();
Standard_EXPORT virtual void Perform() Standard_OVERRIDE;
static void MakeWire (BOPCol_ListOfShape& theLE, TopoDS_Wire& theW);
static void MakeWire(BOPCol_ListOfShape& theLE, TopoDS_Wire& theW);
Standard_EXPORT static void SplitBlock (const TopoDS_Face& theF, BOPTools_ConnexityBlock& theCB);
Standard_EXPORT static void SplitBlock (const TopoDS_Face& theF,
BOPTools_ConnexityBlock& theCB,
const Handle(IntTools_Context)& theContext);
protected:
Standard_EXPORT virtual void CheckData() Standard_OVERRIDE;
Standard_EXPORT void MakeConnexityBlocks();
Standard_EXPORT void MakeWires();
BOPAlgo_PWireEdgeSet myWES;
BOPTools_ListOfConnexityBlock myLCB;
Handle(IntTools_Context) myContext;
private:
};
#include <BOPAlgo_WireSplitter.lxx>
#endif // _BOPAlgo_WireSplitter_HeaderFile

43
src/BOPAlgo/BOPAlgo_WireSplitter_1.cxx
View File

@@ -62,7 +62,8 @@ static
const TopoDS_Edge& anEdge,
const TopoDS_Face& myFace,
const GeomAdaptor_Surface& aGAS,
const Standard_Boolean aFlag);
const Standard_Boolean aFlag,
const Handle(IntTools_Context)& theContext);
static
void GetNextVertex(const TopoDS_Vertex& aV,
@@ -121,14 +122,16 @@ static
static
void RefineAngles(const TopoDS_Face& myFace,
const BOPCol_ListOfShape&,
BOPAlgo_IndexedDataMapOfShapeListOfEdgeInfo&);
BOPAlgo_IndexedDataMapOfShapeListOfEdgeInfo&,
const Handle(IntTools_Context)&);
static
void RefineAngles(const TopoDS_Vertex& ,
const TopoDS_Face& ,
const BOPCol_MapOfShape& ,
BOPAlgo_ListOfEdgeInfo& );
BOPAlgo_ListOfEdgeInfo&,
const Handle(IntTools_Context)&);
static
Standard_Boolean RefineAngle2D(const TopoDS_Vertex& ,
@@ -136,14 +139,16 @@ static
const TopoDS_Face& ,
const Standard_Real ,
const Standard_Real ,
Standard_Real& );
Standard_Real& ,
const Handle(IntTools_Context)& );
//=======================================================================
//function : SplitBlock
//purpose :
//=======================================================================
void BOPAlgo_WireSplitter::SplitBlock(const TopoDS_Face& myFace,
BOPTools_ConnexityBlock& aCB)
BOPTools_ConnexityBlock& aCB,
const Handle(IntTools_Context)& theContext)
{
Standard_Boolean bNothingToDo, bIsClosed, bIsIN;
Standard_Integer aIx, aNb, i, aCntIn, aCntOut;
@@ -287,7 +292,7 @@ void BOPAlgo_WireSplitter::SplitBlock(const TopoDS_Face& myFace,
}
//
// 3. Angles in mySmartMap
BRepAdaptor_Surface aBAS(myFace);
const BRepAdaptor_Surface& aBAS = theContext->SurfaceAdaptor(myFace);
const GeomAdaptor_Surface& aGAS=aBAS.Surface();
//
for (i=1; i<=aNb; i++) {
@@ -302,15 +307,15 @@ void BOPAlgo_WireSplitter::SplitBlock(const TopoDS_Face& myFace,
bIsIN = aEI.IsIn();
aOr = bIsIN ? TopAbs_REVERSED : TopAbs_FORWARD;
aVV.Orientation(aOr);
aAngle = Angle2D(aVV, aE, myFace, aGAS, bIsIN);
aAngle = Angle2D(aVV, aE, myFace, aGAS, bIsIN, theContext);
aEI.SetAngle(aAngle);
}
}// for (i=1; i<=aNb; i++) {
//
//Theme: The treatment p-curves convergent in node.
//The refining the angles of p-curves taking into account
//bounging curves if exist.
RefineAngles(myFace, myEdges, mySmartMap);
//bounding curves if exist.
RefineAngles(myFace, myEdges, mySmartMap, theContext);
//
// 4. Do
//
@@ -712,7 +717,8 @@ Standard_Integer NbWaysOut(const BOPAlgo_ListOfEdgeInfo& aLEInfo)
const TopoDS_Edge& anEdge,
const TopoDS_Face& myFace,
const GeomAdaptor_Surface& aGAS,
const Standard_Boolean bIsIN)
const Standard_Boolean bIsIN,
const Handle(IntTools_Context)& theContext)
{
Standard_Real aFirst, aLast, aToler, dt, aTV, aTV1, anAngle, aTX;
gp_Pnt2d aPV, aPV1;
@@ -725,7 +731,7 @@ Standard_Integer NbWaysOut(const BOPAlgo_ListOfEdgeInfo& aLEInfo)
}
//
BOPTools_AlgoTools2D::CurveOnSurface (anEdge, myFace, aC2D,
aFirst, aLast, aToler);
aFirst, aLast, aToler, theContext);
Standard_Real tol2d =2.*Tolerance2D(aV, aGAS);
//
GeomAbs_CurveType aType;
@@ -849,7 +855,8 @@ Standard_Real VTolerance2D (const TopoDS_Vertex& aV,
//=======================================================================
void RefineAngles(const TopoDS_Face& myFace,
const BOPCol_ListOfShape& myEdges,
BOPAlgo_IndexedDataMapOfShapeListOfEdgeInfo& mySmartMap)
BOPAlgo_IndexedDataMapOfShapeListOfEdgeInfo& mySmartMap,
const Handle(IntTools_Context)& theContext)
{
Standard_Integer aNb, i;
BOPCol_IndexedDataMapOfShapeInteger aMSI;
@@ -886,7 +893,7 @@ void RefineAngles(const TopoDS_Face& myFace,
const TopoDS_Vertex& aV=*((TopoDS_Vertex*)&mySmartMap.FindKey(i));
BOPAlgo_ListOfEdgeInfo& aLEI=mySmartMap(i);
//
RefineAngles(aV, myFace, aMBE, aLEI);
RefineAngles(aV, myFace, aMBE, aLEI, theContext);
}
}
//=======================================================================
@@ -903,7 +910,8 @@ typedef BOPCol_DataMapOfShapeReal::Iterator \
void RefineAngles(const TopoDS_Vertex& aV,
const TopoDS_Face& myFace,
const BOPCol_MapOfShape& aMBE,
BOPAlgo_ListOfEdgeInfo& aLEI)
BOPAlgo_ListOfEdgeInfo& aLEI,
const Handle(IntTools_Context)& theContext)
{
Standard_Boolean bIsIn, bIsBoundary, bRefined;
Standard_Integer iCntBnd, iCntInt;
@@ -956,7 +964,7 @@ void RefineAngles(const TopoDS_Vertex& aV,
continue;
}
//
bRefined=RefineAngle2D(aV, aE, myFace, aA1, aA2, aA);
bRefined=RefineAngle2D(aV, aE, myFace, aA1, aA2, aA, theContext);
if (bRefined) {
aDMSR.Bind(aE, aA);
}
@@ -999,7 +1007,8 @@ Standard_Boolean RefineAngle2D(const TopoDS_Vertex& aV,
const TopoDS_Face& myFace,
const Standard_Real aA1,
const Standard_Real aA2,
Standard_Real& aA)
Standard_Real& aA,
const Handle(IntTools_Context)& theContext)
{
Standard_Boolean bRet;
Standard_Integer i, j, aNbP;
@@ -1016,7 +1025,7 @@ Standard_Boolean RefineAngle2D(const TopoDS_Vertex& aV,
aCf=0.01;
aTolInt=1.e-10;
//
BOPTools_AlgoTools2D::CurveOnSurface(aE, myFace, aC2D, aT1, aT2, aTol);
BOPTools_AlgoTools2D::CurveOnSurface(aE, myFace, aC2D, aT1, aT2, aTol, theContext);
aGAC1.Load(aC2D, aT1, aT2);
//
aTV=BRep_Tool::Parameter (aV, aE, myFace);