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

0024639: Parallelization FillDS part of BO

Browse Source 
Modifications to avoid compilation errors
This commit is contained in:
pkv 2014-03-24 09:34:34 +04:00 committed by bugmaster
parent ca1028006d
commit 505abfb89f
11 changed files with 873 additions and 300 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/BOPAlgo/BOPAlgo_PaveFiller.cdl
View File

@ -20,7 +20,8 @@ class PaveFiller from BOPAlgo
---Purpose:
uses
Pnt from gp,
Pnt from gp,
ShapeEnum from TopAbs,
Vertex from TopoDS,
Face from TopoDS,
Edge from TopoDS,
@ -139,7 +140,12 @@ is
FillShrunkData(me:out;
thePB:out PaveBlock from BOPDS)
is protected;
FillShrunkData(me:out;
theType1: ShapeEnum from TopAbs;
theType2: ShapeEnum from TopAbs)
is protected;
PerformVerticesEE(me:out;
theMVCPB:out IndexedDataMapOfShapeCoupleOfPaveBlocks from BOPDS;
theAllocator:out BaseAllocator from BOPCol)

122
src/BOPAlgo/BOPAlgo_PaveFiller_2.cxx
View File

@ -21,6 +21,9 @@
#include <TopoDS_Edge.hxx>
#include <BRep_Tool.hxx>
#include <BOPCol_NCVector.hxx>
#include <BOPCol_TBB.hxx>
#include <BOPInt_Context.hxx>
#include <BOPDS_Iterator.hxx>
@ -31,20 +34,110 @@
#include <BRepBndLib.hxx>
#include <BRep_Builder.hxx>
//=======================================================================
//class : BOPAlgo_VertexEdgeEdge
//purpose :
//=======================================================================
class BOPAlgo_VertexEdge {
public:
BOPAlgo_VertexEdge()
: myIV(-1), myIE(-1), myIVx(-1), myFlag(-1), myT(-1.) {
};
//
~BOPAlgo_VertexEdge(){
};
//
void SetIndices(const Standard_Integer nV,
const Standard_Integer nE,
const Standard_Integer nVx) {
myIV=nV;
myIE=nE;
myIVx=nVx;
}
//
void Indices(Standard_Integer& nV,
Standard_Integer& nE,
Standard_Integer& nVx) const {
nV=myIV;
nE=myIE;
nVx=myIVx;
}
//
void SetVertex(const TopoDS_Vertex& aV) {
myV=aV;
}
//
const TopoDS_Vertex& Vertex()const {
return myV;
}
//
void SetEdge(const TopoDS_Edge& aE) {
myE=aE;
}
//
const TopoDS_Edge& Edge()const {
return myE;
}
//
Standard_Integer Flag()const {
return myFlag;
}
//
Standard_Real Parameter()const {
return myT;
}
//
void SetContext(const Handle(BOPInt_Context)& aContext) {
myContext=aContext;
}
//
const Handle(BOPInt_Context)& Context()const {
return myContext;
}
//
void Perform() {
myFlag=myContext->ComputeVE (myV, myE, myT);
};
//
protected:
Standard_Integer myIV;
Standard_Integer myIE;
Standard_Integer myIVx;
Standard_Integer myFlag;
Standard_Real myT;
TopoDS_Vertex myV;
TopoDS_Edge myE;
Handle(BOPInt_Context) myContext;
};
//=======================================================================
typedef BOPCol_NCVector
<BOPAlgo_VertexEdge> BOPAlgo_VectorOfVertexEdge;
//
typedef BOPCol_TBBContextFunctor
<BOPAlgo_VertexEdge,
BOPAlgo_VectorOfVertexEdge,
Handle_BOPInt_Context,
BOPInt_Context> BOPAlgo_VertexEdgeFunctor;
//
typedef BOPCol_TBBContextCnt
<BOPAlgo_VertexEdgeFunctor,
BOPAlgo_VectorOfVertexEdge,
Handle_BOPInt_Context> BOPAlgo_VertexEdgeCnt;
//
//=======================================================================
// function: PerformVE
// purpose:
//=======================================================================
void BOPAlgo_PaveFiller::PerformVE()
void BOPAlgo_PaveFiller::PerformVE()
{
Standard_Boolean bJustAdd;
Standard_Integer iSize, nV, nE, nVSD, iFlag, nVx, i;
Standard_Integer iSize, nV, nE, nVSD, iFlag, nVx, i, k, aNbVE;;
Standard_Real aT, aTolE, aTolV;
BOPDS_Pave aPave;
BOPDS_PassKey aPK;
BOPDS_MapOfPassKey aMPK;
BRep_Builder aBB;
BOPAlgo_VectorOfVertexEdge aVVE;
//
myErrorStatus=0;
//
@ -92,8 +185,27 @@
const TopoDS_Edge& aE=(*(TopoDS_Edge *)(&aSIE.Shape()));
const TopoDS_Vertex& aV=(*(TopoDS_Vertex *)(&myDS->Shape(nVx)));
//
iFlag=myContext->ComputeVE (aV, aE, aT);
BOPAlgo_VertexEdge& aVESolver=aVVE.Append1();
//
aVESolver.SetIndices(nV, nE, nVx);
aVESolver.SetVertex(aV);
aVESolver.SetEdge(aE);
//
}// myIterator->Initialize(TopAbs_VERTEX, TopAbs_EDGE);
//
aNbVE=aVVE.Extent();
//=============================================================
BOPAlgo_VertexEdgeCnt::Perform(myRunParallel, aVVE, myContext);
//=============================================================
//
for (k=0; k < aNbVE; ++k) {
const BOPAlgo_VertexEdge& aVESolver=aVVE(k);
iFlag=aVESolver.Flag();
if (!iFlag) {
aVESolver.Indices(nV, nE, nVx);
aT=aVESolver.Parameter();
const TopoDS_Vertex& aV=aVESolver.Vertex();
const TopoDS_Edge& aE=aVESolver.Edge();
// 1
i=aVEs.Append()-1;
BOPDS_InterfVE& aVE=aVEs(i);
@ -117,5 +229,5 @@
BRepBndLib::Add(aV, aBoxDS);
}
}
}//for (; myIterator->More(); myIterator->Next()) {
}//for (k=0; k < aNbVE; ++k) {
}

77
src/BOPAlgo/BOPAlgo_PaveFiller_3.cxx
View File

@ -98,60 +98,18 @@ class BOPAlgo_EdgeEdge : public IntTools_EdgeEdge {
Handle(BOPDS_PaveBlock) myPB2;
};
//
typedef BOPCol_NCVector<BOPAlgo_EdgeEdge> BOPAlgo_VectorOfEdgeEdge;
//=======================================================================
typedef BOPCol_NCVector
<BOPAlgo_EdgeEdge> BOPAlgo_VectorOfEdgeEdge;
//
typedef BOPCol_TBBFunctor
<BOPAlgo_EdgeEdge,
BOPAlgo_VectorOfEdgeEdge> BOPAlgo_EdgeEdgeFunctor;
//
typedef BOPCol_TBBCnt
<BOPAlgo_EdgeEdgeFunctor,
BOPAlgo_VectorOfEdgeEdge> BOPAlgo_EdgeEdgeCnt;
//
//=======================================================================
//class : BOPAlgo_EdgeEdgeFunctor
//purpose :
//=======================================================================
class BOPAlgo_EdgeEdgeFunctor {
protected:
BOPAlgo_VectorOfEdgeEdge* myPVEE;
//
public:
//
BOPAlgo_EdgeEdgeFunctor(BOPAlgo_VectorOfEdgeEdge& aVEE)
: myPVEE(&aVEE) {
}
//
void operator()( const flexible_range<Standard_Integer>& aBR ) const{
Standard_Integer i, iBeg, iEnd;
//
BOPAlgo_VectorOfEdgeEdge& aVEE=*myPVEE;
//
iBeg=aBR.begin();
iEnd=aBR.end();
for(i=iBeg; i!=iEnd; ++i) {
BOPAlgo_EdgeEdge& aEE=aVEE(i);
//
aEE.Perform();
}
}
};
//=======================================================================
//class : BOPAlgo_EdgeEdgeCnt
//purpose :
//=======================================================================
class BOPAlgo_EdgeEdgeCnt {
public:
//-------------------------------
// Perform
Standard_EXPORT
static void Perform(const Standard_Boolean bRunParallel,
BOPAlgo_VectorOfEdgeEdge& aVEdgeEdge) {
//
BOPAlgo_EdgeEdgeFunctor aEEF(aVEdgeEdge);
Standard_Integer aNbEE=aVEdgeEdge.Extent();
//
if (bRunParallel) {
flexible_for(flexible_range<Standard_Integer>(0,aNbEE), aEEF);
}
else {
aEEF.operator()(flexible_range<Standard_Integer>(0,aNbEE));
}
}
};
//=======================================================================
// function: PerformEE
// purpose:
@ -162,6 +120,8 @@ void BOPAlgo_PaveFiller::PerformEE()
//
myErrorStatus=0;
//
FillShrunkData(TopAbs_EDGE, TopAbs_EDGE);
//
myIterator->Initialize(TopAbs_EDGE, TopAbs_EDGE);
iSize=myIterator->ExpectedLength();
if (!iSize) {
@ -214,10 +174,7 @@ void BOPAlgo_PaveFiller::PerformEE()
//
Handle(BOPDS_PaveBlock)& aPB1=aIt1.ChangeValue();
if (!aPB1->HasShrunkData()) {
FillShrunkData(aPB1);
if (myWarningStatus) {
continue;
}
continue;
}
aPB1->ShrunkData(aTS11, aTS12, aBB1);
//
@ -227,10 +184,7 @@ void BOPAlgo_PaveFiller::PerformEE()
//
Handle(BOPDS_PaveBlock)& aPB2=aIt2.ChangeValue();
if (!aPB2->HasShrunkData()) {
FillShrunkData(aPB2);
if (myWarningStatus) {
continue;
}
continue;
}
aPB2->ShrunkData(aTS21, aTS22, aBB2);
//
@ -744,7 +698,8 @@ void BOPAlgo_PaveFiller::FillShrunkData(Handle(BOPDS_PaveBlock)& thePB)
nE=thePB->OriginalEdge();
const TopoDS_Edge& aE=(*(TopoDS_Edge *)(&myDS->Shape(nE)));
//
aSR.SetData(aE, aT1, aT2, aV1, aV2, myContext);
aSR.SetContext(myContext);
aSR.SetData(aE, aT1, aT2, aV1, aV2);
//
aSR.Perform();
iErr=aSR.ErrorStatus();

180
src/BOPAlgo/BOPAlgo_PaveFiller_7.cxx
View File

@ -34,6 +34,9 @@
#include <Geom_Surface.hxx>
#include <Geom2d_Curve.hxx>
#include <BOPCol_NCVector.hxx>
#include <BOPCol_TBB.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_AlgoTools2D.hxx>
@ -52,14 +55,101 @@
#include <BOPDS_MapOfPaveBlock.hxx>
#include <BOPDS_Curve.hxx>
static void UpdateVertices(const TopoDS_Edge& aE,
const TopoDS_Face& aF);
//=======================================================================
//class : BOPAlgo_SplitEdge
//purpose :
//=======================================================================
class BOPAlgo_SplitEdge {
public:
BOPAlgo_SplitEdge() {
myT1=0.;
myT2=0.;
}
//
~BOPAlgo_SplitEdge() {
}
//
void SetData(const TopoDS_Edge& aE,
const TopoDS_Vertex& aV1,
const Standard_Real aT1,
const TopoDS_Vertex& aV2,
const Standard_Real aT2) {
myE=aE;
myV1=aV1;
myT1=aT1;
myV2=aV2;
myT2=aT2;
myESp=aE;
}
//
void SetPaveBlock(const Handle(BOPDS_PaveBlock)& aPB) {
myPB=aPB;
}
//
Handle(BOPDS_PaveBlock)& PaveBlock() {
return myPB;
}
//
void SetCommonBlock(const Handle(BOPDS_CommonBlock)& aCB) {
myCB=aCB;
}
//
Handle(BOPDS_CommonBlock)& CommonBlock() {
return myCB;
}
//
const TopoDS_Edge& SplitEdge() const {
return myESp;
}
//
const Bnd_Box Box() {
return myBox;
}
//
void Perform () {
BOPTools_AlgoTools::MakeSplitEdge(myE,
myV1, myT1,
myV2, myT2,
myESp);
BRepBndLib::Add(myESp, myBox);
}
//
protected:
// ->
TopoDS_Edge myE;
TopoDS_Vertex myV1;
Standard_Real myT1;
TopoDS_Vertex myV2;
Standard_Real myT2;
// <->
Handle(BOPDS_PaveBlock) myPB;
Handle(BOPDS_CommonBlock) myCB;
// <-
TopoDS_Edge myESp;
Bnd_Box myBox;
};
//
//=======================================================================
typedef BOPCol_NCVector
<BOPAlgo_SplitEdge> BOPAlgo_VectorOfSplitEdge;
//
typedef BOPCol_TBBFunctor
<BOPAlgo_SplitEdge,
BOPAlgo_VectorOfSplitEdge> BOPAlgo_SplitEdgeFunctor;
//
typedef BOPCol_TBBCnt
<BOPAlgo_SplitEdgeFunctor,
BOPAlgo_VectorOfSplitEdge> BOPAlgo_SplitEdgeCnt;
//
//=======================================================================
// function: MakeSplitEdges
// purpose:
//=======================================================================
void BOPAlgo_PaveFiller::MakeSplitEdges()
void BOPAlgo_PaveFiller::MakeSplitEdges()
{
Standard_Integer aNbPBP;
//
@ -72,26 +162,20 @@ static void UpdateVertices(const TopoDS_Edge& aE,
}
//
Standard_Boolean bCB, bV1, bV2;
Standard_Integer i, nE, nV1, nV2, nSp, aNbPB;
Standard_Integer i, nE, nV1, nV2, nSp, aNbPB, aNbVBSE, k;
Standard_Real aT1, aT2;
Handle(NCollection_IncAllocator) aAllocator;
BOPDS_ListIteratorOfListOfPaveBlock aItPB, aItPBCB;
Handle(BOPDS_PaveBlock) aPB, aPBx;
//-----------------------------------------------------scope f
//
aAllocator=new NCollection_IncAllocator();
//
BOPDS_MapOfPaveBlock aMPB(100,aAllocator);
Handle(BOPDS_PaveBlock) aPB;
BOPDS_MapOfPaveBlock aMPB(100);
TopoDS_Vertex aV1, aV2;
TopoDS_Edge aE;
BOPAlgo_VectorOfSplitEdge aVBSE;
//
for (i=0; i<aNbPBP; ++i) {
BOPDS_ListOfPaveBlock& aLPB=aPBP(i);
//
aNbPB=aLPB.Extent();
//DEBf
if (aNbPB) {
aPBx=aLPB.First();
}
//DEBt
if (aNbPB==1) {
aPB=aLPB.First();
aPB->Indices(nV1, nV2);
@ -120,23 +204,57 @@ static void UpdateVertices(const TopoDS_Edge& aE,
aPB->Indices(nV1, nV2);
aPB->Range(aT1, aT2);
//
nSp = SplitEdge(nE, nV1, aT1, nV2, aT2);
aE=(*(TopoDS_Edge *)(&myDS->Shape(nE)));
aE.Orientation(TopAbs_FORWARD);
//
aV1=(*(TopoDS_Vertex *)(&myDS->Shape(nV1)));
aV1.Orientation(TopAbs_FORWARD);
//
aV2=(*(TopoDS_Vertex *)(&myDS->Shape(nV2)));
aV2.Orientation(TopAbs_REVERSED);
//
BOPAlgo_SplitEdge& aBSE=aVBSE.Append1();
//
aBSE.SetData(aE, aV1, aT1, aV2, aT2);
aBSE.SetPaveBlock(aPB);
if (bCB) {
aCB->SetEdge(nSp);
aBSE.SetCommonBlock(aCB);
}
else {
aPB->SetEdge(nSp);
}
}// if (aMPB.Add(aPB)) {
}// for (; aItPB.More(); aItPB.Next()) {
}// for (i=0; i<aNbPBP; ++i) {
}
} // for (; aItPB.More(); aItPB.Next()) {
} // for (i=0; i<aNbPBP; ++i) {
//
//-----------------------------------------------------scope t
aMPB.Clear();
aAllocator.Nullify();
aNbVBSE=aVBSE.Extent();
//======================================================
BOPAlgo_SplitEdgeCnt::Perform(myRunParallel, aVBSE);
//======================================================
//
BOPDS_ShapeInfo aSI;
//
aSI.SetShapeType(TopAbs_EDGE);
//
for (k=0; k < aNbVBSE; ++k) {
BOPAlgo_SplitEdge& aBSE=aVBSE(k);
//
const TopoDS_Edge& aSp=aBSE.SplitEdge();
const Bnd_Box& aBox=aBSE.Box();
//
Handle(BOPDS_PaveBlock) aPBk=aBSE.PaveBlock();
Handle(BOPDS_CommonBlock)& aCBk=aBSE.CommonBlock();
//
aSI.SetShape(aSp);
aSI.ChangeBox()=aBox;
//
nSp=myDS->Append(aSI);
//
if (!aCBk.IsNull()) {
aCBk->SetEdge(nSp);
}
else {
aPBk->SetEdge(nSp);
}
}
}
//=======================================================================
// function: SplitEdge
// purpose:
@ -173,12 +291,11 @@ Standard_Integer BOPAlgo_PaveFiller::SplitEdge(const Standard_Integer nE,
nSp=myDS->Append(aSI);
return nSp;
}
//=======================================================================
// function: MakePCurves
// purpose:
//=======================================================================
void BOPAlgo_PaveFiller::MakePCurves()
void BOPAlgo_PaveFiller::MakePCurves()
{
Standard_Integer i, nF1, nF2, aNbC, k, nE, aNbFF, aNbFI;
BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
@ -262,12 +379,11 @@ Standard_Integer BOPAlgo_PaveFiller::SplitEdge(const Standard_Integer nE,
}
}
}
//=======================================================================
// function: RefineFaceInfoOn
// purpose:
//=======================================================================
void BOPAlgo_PaveFiller::RefineFaceInfoOn()
void BOPAlgo_PaveFiller::RefineFaceInfoOn()
{
Standard_Integer aNbPBP;
//
@ -304,13 +420,13 @@ Standard_Integer BOPAlgo_PaveFiller::SplitEdge(const Standard_Integer nE,
}//for (i=0; i<aNbPBP; ++i) {
myDS->RefineFaceInfoOn();
}
//=======================================================================
//function : UpdateVertices
//purpose : update tolerances of vertices comparing extremities of
// 3d and 2d curves
//=======================================================================
void UpdateVertices(const TopoDS_Edge& aE, const TopoDS_Face& aF)
void UpdateVertices(const TopoDS_Edge& aE,
const TopoDS_Face& aF)
{
Standard_Integer j;
Standard_Real aT[2], aUx, aVx, aTolV2, aD2, aD;

179
src/BOPAlgo/BOPAlgo_PaveFiller_9.cxx Normal file
View File

@ -0,0 +1,179 @@
// Created by: Peter KURNEV
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <BOPAlgo_PaveFiller.ixx>
//
#include <Bnd_Box.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Vertex.hxx>
#include <BOPCol_NCVector.hxx>
#include <BOPCol_MapOfInteger.hxx>
#include <BOPCol_TBB.hxx>
#include <BOPDS_ShapeInfo.hxx>
#include <BOPDS_PaveBlock.hxx>
#include <BOPDS_Iterator.hxx>
#include <BOPDS_ListOfPaveBlock.hxx>
#include <BOPInt_ShrunkRange.hxx>
//=======================================================================
//class : BOPAlgo_ShrunkRange
//purpose :
//=======================================================================
class BOPAlgo_ShrunkRange : public BOPInt_ShrunkRange {
public:
BOPAlgo_ShrunkRange()
: BOPInt_ShrunkRange(),
myWarningStatus(0) {
}
//
virtual ~BOPAlgo_ShrunkRange() {
}
//
void SetPaveBlock(const Handle(BOPDS_PaveBlock)& aPB) {
myPB=aPB;
}
//
Handle(BOPDS_PaveBlock)& PaveBlock() {
return myPB;
}
//
virtual void Perform() {
//
myWarningStatus=0;
//
BOPInt_ShrunkRange::Perform();
if (myErrorStatus) {
myWarningStatus=1;
}
}
//
Standard_Integer WarningStatus() const {
return myWarningStatus;
}
//
protected:
Standard_Integer myWarningStatus;
Handle(BOPDS_PaveBlock) myPB;
};
//
//=======================================================================
typedef BOPCol_NCVector
<BOPAlgo_ShrunkRange> BOPAlgo_VectorOfShrunkRange;
//
typedef BOPCol_TBBContextFunctor
<BOPAlgo_ShrunkRange,
BOPAlgo_VectorOfShrunkRange,
Handle_BOPInt_Context,
BOPInt_Context> BOPAlgo_ShrunkRangeFunctor;
//
typedef BOPCol_TBBContextCnt
<BOPAlgo_ShrunkRangeFunctor,
BOPAlgo_VectorOfShrunkRange,
Handle_BOPInt_Context> BOPAlgo_ShrunkRangeCnt;
//
//=======================================================================
// function: FillShrunkData
// purpose:
//=======================================================================
void BOPAlgo_PaveFiller::FillShrunkData(const TopAbs_ShapeEnum aType1,
const TopAbs_ShapeEnum aType2)
{
Standard_Integer iSize;
//
myErrorStatus=0;
//
myIterator->Initialize(aType1, aType2);
iSize=myIterator->ExpectedLength();
if (!iSize) {
return;
}
//
Standard_Boolean bJustAdd;
Standard_Integer i, iEnd, nS[2], nE, nV1, nV2, aNbVSD, k, iWrn;
Standard_Real aT1, aT2, aTS1, aTS2;
BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
BOPCol_MapOfInteger aMI;
BOPAlgo_VectorOfShrunkRange aVSD;
//
iEnd=(aType2==TopAbs_EDGE) ? 2 : 1;
//
for (; myIterator->More(); myIterator->Next()) {
myIterator->Value(nS[0], nS[1], bJustAdd);
if(bJustAdd) {
continue;
}
//
for (i=0; i<iEnd; ++i) {
nE=nS[i];
if (!aMI.Add(nE)) {
continue;
}
//
const BOPDS_ShapeInfo& aSIE=myDS->ShapeInfo(nE);
if (aSIE.HasFlag()){
continue;
}
//
BOPDS_ListOfPaveBlock& aLPB=myDS->ChangePaveBlocks(nE);
aItLPB.Initialize(aLPB);
for (; aItLPB.More(); aItLPB.Next()) {
const Handle(BOPDS_PaveBlock)& aPB=aItLPB.ChangeValue();
if (aPB->HasShrunkData()) {
continue;
}
//
// FillShrunkData(aPB);
aPB->Indices(nV1, nV2);
aPB->Range(aT1, aT2);
//
const TopoDS_Edge& aE=(*(TopoDS_Edge *)(&aSIE.Shape()));
//
const TopoDS_Vertex& aV1=
(*(TopoDS_Vertex *)(&myDS->Shape(nV1)));
//
const TopoDS_Vertex& aV2=
(*(TopoDS_Vertex *)(&myDS->Shape(nV2)));
//
BOPAlgo_ShrunkRange& aSD=aVSD.Append1();
//
aSD.SetPaveBlock(aPB);
aSD.SetData(aE, aT1, aT2, aV1, aV2);
}
}
}
//
aNbVSD=aVSD.Extent();
//=============================================================
BOPAlgo_ShrunkRangeCnt::Perform(myRunParallel, aVSD, myContext);
//=============================================================
//
for (k=0; k < aNbVSD; ++k) {
BOPAlgo_ShrunkRange& aSD=aVSD(k);
iWrn=aSD.WarningStatus();
if (iWrn==1) {
continue;
}
//
Handle(BOPDS_PaveBlock)& aPB=aSD.PaveBlock();
aSD.ShrunkRange(aTS1, aTS2);
const Bnd_Box& aBox=aSD.BndBox();
//
aPB->SetShrunkData(aTS1, aTS2, aBox);
}
}

1
src/BOPAlgo/FILES
View File

@ -16,3 +16,4 @@ BOPAlgo_ListOfCheckResult.hxx
BOPAlgo_Builder_2Cnt.hxx
BOPAlgo_CheckerSI_1.cxx
BOPAlgo_PaveFiller_9.cxx

146
src/BOPCol/BOPCol_TBB.hxx
View File

@ -43,7 +43,7 @@ using namespace tbb;
template <class Type> class serial_range {
public:
serial_range(const Type& aBegin,
const Type& aEnd)
const Type& aEnd)
: myBegin(aBegin), myEnd(aEnd) {
}
//
@ -72,5 +72,149 @@ static void serial_for( const Range& range, const Body& body ) {
body.operator()(range);
};
#endif // not HAVE_TBB
//
// 2. Implementation of Functors/Starters
//
// 2.1. Pure version
//
//=======================================================================
//class : BOPCol_TBBFunctor
//purpose :
//=======================================================================
template <class TypeSolver,
class TypeSolverVector> class BOPCol_TBBFunctor {
public:
BOPCol_TBBFunctor(TypeSolverVector& aV)
: myPV(&aV) {
}
//
~BOPCol_TBBFunctor() {
}
//
void operator()( const flexible_range<Standard_Size>& aBR ) const{
Standard_Size i, iBeg, iEnd;
//
TypeSolverVector& aV=*myPV;
//
iBeg=aBR.begin();
iEnd=aBR.end();
for(i=iBeg; i!=iEnd; ++i) {
TypeSolver& aSolver=aV(i);
//
aSolver.Perform();
}
}
//
protected:
TypeSolverVector* myPV;
};
//=======================================================================
//class : BOPCol_TBBCnt
//purpose :
//=======================================================================
template <class TypeFunctor,
class TypeSolverVector> class BOPCol_TBBCnt {
public:
//-------------------------------
// Perform
Standard_EXPORT
static void Perform(const Standard_Boolean bRunParallel,
TypeSolverVector& aV) {
//
TypeFunctor aFunctor(aV);
Standard_Size aNb=aV.Extent();
//
if (bRunParallel) {
flexible_for(flexible_range<Standard_Size>(0,aNb), aFunctor);
}
else {
aFunctor.operator()(flexible_range<Standard_Size>(0,aNb));
}
}
};
//
// 2.2. Context dependent version
//
#include <Standard_Macro.hxx>
//=======================================================================
//class : BOPCol_TBBContextFunctor
//purpose :
//=======================================================================
template <class TypeSolver,
class TypeSolverVector,
class TypeContext,
typename TN> class BOPCol_TBBContextFunctor {
public:
BOPCol_TBBContextFunctor(TypeSolverVector& aV)
: myPV(&aV) {
}
//
~BOPCol_TBBContextFunctor() {
}
//
void SetContext(TypeContext& aCtx) {
myContext=aCtx;
}
//
void operator()( const flexible_range<Standard_Size>& aBR ) const{
Standard_Size i, iBeg, iEnd;
TypeContext aCtx;
//
if (myContext.IsNull()) {
aCtx=new TN
(NCollection_BaseAllocator::CommonBaseAllocator());
}
else {
aCtx=myContext;
}
//
TypeSolverVector& aV=*myPV;
//
iBeg=aBR.begin();
iEnd=aBR.end();
for(i=iBeg; i!=iEnd; ++i) {
TypeSolver& aSolver=aV(i);
//
aSolver.SetContext(aCtx);
aSolver.Perform();
}
}
//
protected:
TypeSolverVector* myPV;
TypeContext myContext;
//
};
//=======================================================================
//class : BOPCol_TBBContextCnt
//purpose :
//=======================================================================
template <class TypeFunctor,
class TypeSolverVector,
class TypeContext> class BOPCol_TBBContextCnt {
public:
//-------------------------------
// Perform
Standard_EXPORT
static void Perform(const Standard_Boolean bRunParallel,
TypeSolverVector& aV,
TypeContext& aCtx) {
//
TypeFunctor aFunctor(aV);
Standard_Size aNb=aV.Extent();
//
if (bRunParallel) {
flexible_for(flexible_range<Standard_Size>(0,aNb), aFunctor);
}
else {
aFunctor.SetContext(aCtx);
aFunctor.operator()(flexible_range<Standard_Size>(0,aNb));
}
}
};
#endif

81
src/BOPInt/BOPInt_ShrunkRange.cdl
View File

@ -14,11 +14,11 @@
class ShrunkRange from BOPInt
---Purpose:
--- The class provides the computation of
--- a working (shrunk) range [t1, t2] for
--- the 3D-curve of the edge.
---Purpose:
--- The class provides the computation of
--- a working (shrunk) range [t1, t2] for
--- the 3D-curve of the edge.
uses
Box from Bnd,
Edge from TopoDS,
@ -29,49 +29,56 @@ uses
is
Create
returns ShrunkRange from BOPInt;
returns ShrunkRange from BOPInt;
---C++: alias "Standard_EXPORT virtual ~BOPInt_ShrunkRange();"
SetData (me:out;
aE : Edge from TopoDS;
aT1 : Real from Standard;
aT2 : Real from Standard;
aV1 : Vertex from TopoDS;
aV2 : Vertex from TopoDS;
ICtx: Context from BOPInt);
aE : Edge from TopoDS;
aT1 : Real from Standard;
aT2 : Real from Standard;
aV1 : Vertex from TopoDS;
aV2 : Vertex from TopoDS);
SetContext(me:out;
aCtx: Context from BOPInt);
Context(me)
returns Context from BOPInt;
---C++: return const &
SetShrunkRange(me:out;
aT1 : Real from Standard;
aT2 : Real from Standard);
aT1 : Real from Standard;
aT2 : Real from Standard);
ShrunkRange(me;
aT1 :out Real from Standard;
aT2 :out Real from Standard);
aT1 :out Real from Standard;
aT2 :out Real from Standard);
BndBox (me)
returns Box from Bnd;
returns Box from Bnd;
---C++: return const &
Edge (me)
returns Edge from TopoDS;
---C++: return const &
returns Edge from TopoDS;
---C++: return const &
Perform(me:out);
ErrorStatus(me)
returns Integer from Standard;
---Purpose:
--- Returns code of computing shrunk range
--- completion
--- 0 - means successful completion
--- 1 - nothing has been done
--- 2 - initial range is out of edge's range
--- 3 - first boundary of initial range is more than
--- last boundary
--- 4 - projection of first vertex failed
--- 5 - projection of second vertex failed
--- 6 - shrunk range can not be computed
--- shrunk range is setted to initial range
---
returns Integer from Standard;
---Purpose:
--- Returns code of computing shrunk range
--- completion
--- 0 - means successful completion
--- 1 - nothing has been done
--- 2 - initial range is out of edge's range
--- 3 - first boundary of initial range is more than
--- last boundary
--- 4 - projection of first vertex failed
--- 5 - projection of second vertex failed
--- 6 - shrunk range can not be computed
--- shrunk range is setted to initial range
---
fields
myEdge : Edge from TopoDS is protected;

60
src/BOPInt/BOPInt_ShrunkRange.cxx
View File

@ -42,30 +42,50 @@
myErrorStatus=1;
}
//=======================================================================
//function : ~
//purpose :
//=======================================================================
BOPInt_ShrunkRange::~BOPInt_ShrunkRange ()
{
}
//=======================================================================
//function : SetData
//purpose :
//=======================================================================
void BOPInt_ShrunkRange::SetData(const TopoDS_Edge& aE,
const Standard_Real aT1,
const Standard_Real aT2,
const TopoDS_Vertex& aV1,
const TopoDS_Vertex& aV2,
const Handle(BOPInt_Context)& aCtx)
void BOPInt_ShrunkRange::SetData(const TopoDS_Edge& aE,
const Standard_Real aT1,
const Standard_Real aT2,
const TopoDS_Vertex& aV1,
const TopoDS_Vertex& aV2)
{
myEdge=aE;
myV1=aV1;
myV2=aV2;
myT1=aT1;
myT2=aT2;
//myRange=aR;
myCtx=aCtx;
myErrorStatus=1;
}
//=======================================================================
//function : SetContext
//purpose :
//=======================================================================
void BOPInt_ShrunkRange::SetContext(const Handle(BOPInt_Context)& aCtx)
{
myCtx=aCtx;
}
//=======================================================================
//function : Context
//purpose :
//=======================================================================
const Handle(BOPInt_Context)& BOPInt_ShrunkRange::Context()const
{
return myCtx;
}
//=======================================================================
//function : Edge
//purpose :
//=======================================================================
const TopoDS_Edge& BOPInt_ShrunkRange::Edge() const
const TopoDS_Edge& BOPInt_ShrunkRange::Edge() const
{
return myEdge;
}
@ -73,8 +93,8 @@
//function : ShrunkRange
//purpose :
//=======================================================================
void BOPInt_ShrunkRange::ShrunkRange(Standard_Real& aT1,
Standard_Real& aT2) const
void BOPInt_ShrunkRange::ShrunkRange(Standard_Real& aT1,
Standard_Real& aT2) const
{
aT1=myTS1;
aT2=myTS2;
@ -83,7 +103,7 @@
//function : BndBox
//purpose :
//=======================================================================
const Bnd_Box& BOPInt_ShrunkRange::BndBox() const
const Bnd_Box& BOPInt_ShrunkRange::BndBox() const
{
return myBndBox;
}
@ -91,7 +111,7 @@
//function : ErrorStatus
//purpose :
//=======================================================================
Standard_Integer BOPInt_ShrunkRange::ErrorStatus() const
Standard_Integer BOPInt_ShrunkRange::ErrorStatus() const
{
return myErrorStatus;
}
@ -100,8 +120,8 @@
//function : SetShrunkRange
//purpose :
//=======================================================================
void BOPInt_ShrunkRange::SetShrunkRange(const Standard_Real aT1,
const Standard_Real aT2)
void BOPInt_ShrunkRange::SetShrunkRange(const Standard_Real aT1,
const Standard_Real aT2)
{
myTS1=aT1;
myTS2=aT2;
@ -114,9 +134,10 @@
//function : Perform
//purpose :
//=======================================================================
void BOPInt_ShrunkRange::Perform()
void BOPInt_ShrunkRange::Perform()
{
Standard_Real aCF, aCL, aTolE, aTolV1, aTolV2, t1, t11, t1C, t2, t12, t2C;
Standard_Real aCF, aCL, aTolE, aTolV1;
Standard_Real aTolV2, t1, t11, t1C, t2, t12, t2C;
Standard_Real aCoeff1, aCoeff2, aTol1, aTol2, dt1, dt2, aR, anEps;
Standard_Integer pri;
Standard_Boolean bInf1, bInf2, bAppr;
@ -155,7 +176,7 @@
return;
}
//
bAppr = (fabs(t2 - t1) > 100) ? Standard_False : Standard_True;
bAppr = !(fabs(t2 - t1) > 100);
if (fabs(t2 - t1) < anEps) {
myErrorStatus=7;
return;
@ -426,8 +447,7 @@
}
}
} // else {
//
if (t1C>t2){
t1C=0.5*(t2+t1);
t2C=t1C+0.1*(t2-t1C);

210
src/BOPTools/BOPTools_AlgoTools.cxx
View File

@ -104,10 +104,11 @@ static
// function: MakeConnexityBlocks
// purpose:
//=======================================================================
void BOPTools_AlgoTools::MakeConnexityBlocks (const TopoDS_Shape& theS,
const TopAbs_ShapeEnum theType1,
const TopAbs_ShapeEnum theType2,
BOPCol_ListOfShape& theLCB)
void BOPTools_AlgoTools::MakeConnexityBlocks
(const TopoDS_Shape& theS,
const TopAbs_ShapeEnum theType1,
const TopAbs_ShapeEnum theType2,
BOPCol_ListOfShape& theLCB)
{
Standard_Integer aNbF, aNbAdd, aNbAdd1, i;
BRep_Builder aBB;
@ -203,7 +204,9 @@ void BOPTools_AlgoTools::OrientFacesOnShell (TopoDS_Shape& aShell)
//
BOPTools_AlgoTools::MakeContainer(TopAbs_SHELL, aShellNew);
//
BOPTools::MapShapesAndAncestors(aShell, TopAbs_EDGE, TopAbs_FACE, aEFMap);
BOPTools::MapShapesAndAncestors(aShell,
TopAbs_EDGE, TopAbs_FACE,
aEFMap);
aNbE=aEFMap.Extent();
//
// One seam edge in aEFMap contains 2 equivalent faces.
@ -334,18 +337,15 @@ TopAbs_Orientation Orientation(const TopoDS_Edge& anE,
}
return anOr;
}
////////////
//=======================================================================
// function: MakeConnexityBlock.
// purpose:
//=======================================================================
void BOPTools_AlgoTools::MakeConnexityBlock (BOPCol_ListOfShape& theLFIn,
BOPCol_IndexedMapOfShape& theMEAvoid,
BOPCol_ListOfShape& theLCB,
const Handle(NCollection_BaseAllocator)& theAllocator)
void BOPTools_AlgoTools::MakeConnexityBlock
(BOPCol_ListOfShape& theLFIn,
BOPCol_IndexedMapOfShape& theMEAvoid,
BOPCol_ListOfShape& theLCB,
const Handle(NCollection_BaseAllocator)& theAllocator)
{
Standard_Integer aNbF, aNbAdd1, aNbAdd, i;
TopExp_Explorer aExp;
@ -422,10 +422,11 @@ void BOPTools_AlgoTools::MakeConnexityBlock (BOPCol_ListOfShape& theLFIn,
// function: ComputeStateByOnePoint
// purpose:
//=======================================================================
TopAbs_State BOPTools_AlgoTools::ComputeStateByOnePoint(const TopoDS_Shape& theS,
const TopoDS_Solid& theRef,
const Standard_Real theTol,
Handle(BOPInt_Context)& theContext)
TopAbs_State BOPTools_AlgoTools::ComputeStateByOnePoint
(const TopoDS_Shape& theS,
const TopoDS_Solid& theRef,
const Standard_Real theTol,
Handle(BOPInt_Context)& theContext)
{
TopAbs_State aState;
TopAbs_ShapeEnum aType;
@ -447,11 +448,12 @@ TopAbs_State BOPTools_AlgoTools::ComputeStateByOnePoint(const TopoDS_Shape& theS
// function: ComputeState
// purpose:
//=======================================================================
TopAbs_State BOPTools_AlgoTools::ComputeState(const TopoDS_Face& theF,
const TopoDS_Solid& theRef,
const Standard_Real theTol,
BOPCol_IndexedMapOfShape& theBounds,
Handle(BOPInt_Context)& theContext)
TopAbs_State BOPTools_AlgoTools::ComputeState
(const TopoDS_Face& theF,
const TopoDS_Solid& theRef,
const Standard_Real theTol,
BOPCol_IndexedMapOfShape& theBounds,
Handle(BOPInt_Context)& theContext)
{
TopAbs_State aState;
TopExp_Explorer aExp;
@ -470,7 +472,8 @@ TopAbs_State BOPTools_AlgoTools::ComputeState(const TopoDS_Face& theF,
//
if (!theBounds.Contains(aSE)) {
const TopoDS_Edge& aE=(*(TopoDS_Edge*)(&aSE));
aState=BOPTools_AlgoTools::ComputeState(aE, theRef, theTol, theContext);
aState=BOPTools_AlgoTools::ComputeState(aE, theRef, theTol,
theContext);
return aState;
}
if (aE1.IsNull()) {
@ -479,8 +482,10 @@ TopAbs_State BOPTools_AlgoTools::ComputeState(const TopoDS_Face& theF,
}
// !!<- process edges that are all on theRef
if (!aE1.IsNull()) {
BOPTools_AlgoTools3D::PointNearEdge(aE1, theF, aP2D, aP3D, theContext);
aState=BOPTools_AlgoTools::ComputeState(aP3D, theRef, theTol, theContext);
BOPTools_AlgoTools3D::PointNearEdge(aE1, theF,
aP2D, aP3D, theContext);
aState=BOPTools_AlgoTools::ComputeState(aP3D, theRef, theTol,
theContext);
}
//
return aState;
@ -489,26 +494,29 @@ TopAbs_State BOPTools_AlgoTools::ComputeState(const TopoDS_Face& theF,
// function: ComputeState
// purpose:
//=======================================================================
TopAbs_State BOPTools_AlgoTools::ComputeState(const TopoDS_Vertex& theV,
const TopoDS_Solid& theRef,
const Standard_Real theTol,
Handle(BOPInt_Context)& theContext)
TopAbs_State BOPTools_AlgoTools::ComputeState
(const TopoDS_Vertex& theV,
const TopoDS_Solid& theRef,
const Standard_Real theTol,
Handle(BOPInt_Context)& theContext)
{
TopAbs_State aState;
gp_Pnt aP3D;
//
aP3D=BRep_Tool::Pnt(theV);
aState=BOPTools_AlgoTools::ComputeState(aP3D, theRef, theTol, theContext);
aState=BOPTools_AlgoTools::ComputeState(aP3D, theRef, theTol,
theContext);
return aState;
}
//=======================================================================
// function: ComputeState
// purpose:
//=======================================================================
TopAbs_State BOPTools_AlgoTools::ComputeState(const TopoDS_Edge& theE,
const TopoDS_Solid& theRef,
const Standard_Real theTol,
Handle(BOPInt_Context)& theContext)
TopAbs_State BOPTools_AlgoTools::ComputeState
(const TopoDS_Edge& theE,
const TopoDS_Solid& theRef,
const Standard_Real theTol,
Handle(BOPInt_Context)& theContext)
{
Standard_Real aT1, aT2, aT = 0.;
TopAbs_State aState;
@ -547,7 +555,8 @@ TopAbs_State BOPTools_AlgoTools::ComputeState(const TopoDS_Edge& theE,
aC3D->D0(aT, aP3D);
}
//
aState=BOPTools_AlgoTools::ComputeState(aP3D, theRef, theTol, theContext);
aState=BOPTools_AlgoTools::ComputeState(aP3D, theRef, theTol,
theContext);
//
return aState;
}
@ -555,10 +564,11 @@ TopAbs_State BOPTools_AlgoTools::ComputeState(const TopoDS_Edge& theE,
// function: ComputeState
// purpose:
//=======================================================================
TopAbs_State BOPTools_AlgoTools::ComputeState(const gp_Pnt& theP,
const TopoDS_Solid& theRef,
const Standard_Real theTol,
Handle(BOPInt_Context)& theContext)
TopAbs_State BOPTools_AlgoTools::ComputeState
(const gp_Pnt& theP,
const TopoDS_Solid& theRef,
const Standard_Real theTol,
Handle(BOPInt_Context)& theContext)
{
TopAbs_State aState;
//
@ -633,7 +643,8 @@ Standard_Integer BOPTools_AlgoTools::IsInternalFace
break;
}
//
iRet=BOPTools_AlgoTools::IsInternalFace(theFace, aE, aF1, aF1, theContext);
iRet=BOPTools_AlgoTools::IsInternalFace(theFace, aE, aF1, aF1,
theContext);
break;
}
//
@ -643,7 +654,8 @@ Standard_Integer BOPTools_AlgoTools::IsInternalFace
//
if (aF2.IsSame(aF1) && BRep_Tool::IsClosed(aE, aF1)) {
// treat as it was for 1 face
iRet=BOPTools_AlgoTools::IsInternalFace(theFace, aE, aF1, aF2, theContext);
iRet=BOPTools_AlgoTools::IsInternalFace(theFace, aE, aF1, aF2,
theContext);
break;
}
}
@ -653,7 +665,8 @@ Standard_Integer BOPTools_AlgoTools::IsInternalFace
return iRet; // it can not be so
}
else { // aNbF=2,4,6,8,...
iRet=BOPTools_AlgoTools::IsInternalFace(theFace, aE, aLF, theContext);
iRet=BOPTools_AlgoTools::IsInternalFace(theFace, aE, aLF,
theContext);
break;
}
}//for(; aExp.More(); aExp.Next()) {
@ -675,7 +688,8 @@ Standard_Integer BOPTools_AlgoTools::IsInternalFace
//
BOPTools::MapShapes(theSolid, TopAbs_EDGE, aBounds);
//
aState=BOPTools_AlgoTools::ComputeState(theFace, theSolid, theTol, aBounds, theContext);
aState=BOPTools_AlgoTools::ComputeState(theFace, theSolid,
theTol, aBounds, theContext);
//
iRet=(aState==TopAbs_IN)? 1 : 0;
//
@ -685,10 +699,11 @@ Standard_Integer BOPTools_AlgoTools::IsInternalFace
//function : IsInternalFace
//purpose :
//=======================================================================
Standard_Integer BOPTools_AlgoTools::IsInternalFace(const TopoDS_Face& theFace,
const TopoDS_Edge& theEdge,
BOPCol_ListOfShape& theLF,
Handle(BOPInt_Context)& theContext)
Standard_Integer BOPTools_AlgoTools::IsInternalFace
(const TopoDS_Face& theFace,
const TopoDS_Edge& theEdge,
BOPCol_ListOfShape& theLF,
Handle(BOPInt_Context)& theContext)
{
Standard_Integer aNbF, iRet;
//
@ -698,7 +713,8 @@ Standard_Integer BOPTools_AlgoTools::IsInternalFace(const TopoDS_Face& theFace,
if (aNbF==2) {
const TopoDS_Face& aF1=(*(TopoDS_Face*)(&theLF.First()));
const TopoDS_Face& aF2=(*(TopoDS_Face*)(&theLF.Last()));
iRet=BOPTools_AlgoTools::IsInternalFace(theFace, theEdge, aF1, aF2, theContext);
iRet=BOPTools_AlgoTools::IsInternalFace(theFace, theEdge, aF1, aF2,
theContext);
return iRet;
}
//
@ -714,7 +730,8 @@ Standard_Integer BOPTools_AlgoTools::IsInternalFace(const TopoDS_Face& theFace,
//
const TopoDS_Face& aF1=(*(TopoDS_Face*)(&aCSFF.Shape1()));
const TopoDS_Face& aF2=(*(TopoDS_Face*)(&aCSFF.Shape2()));
iRet=BOPTools_AlgoTools::IsInternalFace(theFace, theEdge, aF1, aF2, theContext);
iRet=BOPTools_AlgoTools::IsInternalFace(theFace, theEdge, aF1, aF2,
theContext);
if (iRet) {
return iRet;
}
@ -813,7 +830,8 @@ Standard_Boolean BOPTools_AlgoTools::GetFaceOff
aPL->Bounds(aUmin, aUsup, aVmin, aVsup);
aProjPL.Init(aPL, aUmin, aUsup, aVmin, aVsup);
//
GetFaceDir(theE1, theF1, aPx, aT, aDTgt, aDN1, aDBF, theContext, aProjPL);
GetFaceDir(theE1, theF1, aPx, aT, aDTgt, aDN1, aDBF, theContext,
aProjPL);
//
aDTF=aDN1^aDBF;
//
@ -825,7 +843,8 @@ Standard_Boolean BOPTools_AlgoTools::GetFaceOff
const TopoDS_Face& aF2=(*(TopoDS_Face*)(&aCS.Shape2()));
//
aDTgt2 = (aE2.Orientation()==aOr) ? aDTgt : aDTgt.Reversed();
GetFaceDir(aE2, aF2, aPx, aT, aDTgt2, aDN2, aDBF2, theContext, aProjPL);
GetFaceDir(aE2, aF2, aPx, aT, aDTgt2, aDN2, aDBF2, theContext,
aProjPL);
//Angle
aAngle=AngleWithRef(aDBF, aDBF2, aDTF);
//
@ -888,9 +907,10 @@ Standard_Boolean BOPTools_AlgoTools::GetEdgeOff(const TopoDS_Edge& theE1,
//function : AreFacesSameDomain
//purpose :
//=======================================================================
Standard_Boolean BOPTools_AlgoTools::AreFacesSameDomain(const TopoDS_Face& theF1,
const TopoDS_Face& theF2,
Handle(BOPInt_Context)& theContext)
Standard_Boolean BOPTools_AlgoTools::AreFacesSameDomain
(const TopoDS_Face& theF1,
const TopoDS_Face& theF2,
Handle(BOPInt_Context)& theContext)
{
Standard_Boolean bFlag;
Standard_Integer iErr;
@ -922,7 +942,8 @@ Standard_Boolean BOPTools_AlgoTools::AreFacesSameDomain(const TopoDS_Face& theF1
aTolF2=BRep_Tool::Tolerance(aF2);
aTol=aTolF1+aTolF2;
//
iErr = BOPTools_AlgoTools3D::PointInFace(aF1, aP, aP2D, theContext);
iErr = BOPTools_AlgoTools3D::PointInFace(aF1, aP, aP2D,
theContext);
if (!iErr) {
bFlag=theContext->IsValidPointForFace(aP, aF2, aTol);
}
@ -934,9 +955,10 @@ Standard_Boolean BOPTools_AlgoTools::AreFacesSameDomain(const TopoDS_Face& theF1
//function : CheckSameGeom
//purpose :
//=======================================================================
Standard_Boolean BOPTools_AlgoTools::CheckSameGeom(const TopoDS_Face& theF1,
const TopoDS_Face& theF2,
Handle(BOPInt_Context)& theContext)
Standard_Boolean BOPTools_AlgoTools::CheckSameGeom
(const TopoDS_Face& theF1,
const TopoDS_Face& theF2,
Handle(BOPInt_Context)& theContext)
{
Standard_Boolean bRet;
Standard_Real aTolF1, aTolF2, aTol;
@ -1009,9 +1031,10 @@ Standard_Integer BOPTools_AlgoTools::Sense (const TopoDS_Face& theF1,
// function: IsSplitToReverse
// purpose:
//=======================================================================
Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse(const TopoDS_Shape& theSp,
const TopoDS_Shape& theSr,
Handle(BOPInt_Context)& theContext)
Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse
(const TopoDS_Shape& theSp,
const TopoDS_Shape& theSr,
Handle(BOPInt_Context)& theContext)
{
Standard_Boolean bRet;
TopAbs_ShapeEnum aType;
@ -1043,9 +1066,10 @@ Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse(const TopoDS_Shape& theSp,
//function :IsSplitToReverse
//purpose :
//=======================================================================
Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse(const TopoDS_Face& theFSp,
const TopoDS_Face& theFSr,
Handle(BOPInt_Context)& theContext)
Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse
(const TopoDS_Face& theFSp,
const TopoDS_Face& theFSr,
Handle(BOPInt_Context)& theContext)
{
Standard_Boolean bRet, bFound, bInFace;
Standard_Real aT1, aT2, aT, aU, aV, aScPr;
@ -1084,7 +1108,8 @@ Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse(const TopoDS_Face& theFSp,
Standard_Integer iErr;
gp_Pnt2d aP2DFSp;
//
iErr=BOPTools_AlgoTools3D::PointInFace(theFSp, aPFSp, aP2DFSp, theContext);
iErr=BOPTools_AlgoTools3D::PointInFace(theFSp, aPFSp, aP2DFSp,
theContext);
if (iErr) {
return bRet;
}
@ -1098,7 +1123,9 @@ Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse(const TopoDS_Face& theFSp,
else {
BRep_Tool::Range(aESp, aT1, aT2);
aT=BOPTools_AlgoTools2D::IntermediatePoint(aT1, aT2);
BOPTools_AlgoTools3D::GetApproxNormalToFaceOnEdge(aESp, theFSp, aT, aPFSp, aDNFSp, theContext);
BOPTools_AlgoTools3D::GetApproxNormalToFaceOnEdge(aESp, theFSp, aT,
aPFSp, aDNFSp,
theContext);
}
//
// Parts of theContext->ComputeVS(..)
@ -1132,9 +1159,10 @@ Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse(const TopoDS_Face& theFSp,
//function :IsSplitToReverse
//purpose :
//=======================================================================
Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse(const TopoDS_Edge& aEF1,
const TopoDS_Edge& aEF2,
Handle(BOPInt_Context)& theContext)
Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse
(const TopoDS_Edge& aEF1,
const TopoDS_Edge& aEF2,
Handle(BOPInt_Context)& theContext)
{
Standard_Boolean bRet, bIsDegenerated;
//
@ -1322,7 +1350,8 @@ void BOPTools_AlgoTools::MakePCurve(const TopoDS_Edge& aE,
aTolE=BRep_Tool::Tolerance(aE);
//
const Handle(Geom_Curve)& aC3DE=BRep_Tool::Curve(aE, aT1, aT2);
Handle(Geom_TrimmedCurve)aC3DETrim=new Geom_TrimmedCurve(aC3DE, aT1, aT2);
Handle(Geom_TrimmedCurve)aC3DETrim=
new Geom_TrimmedCurve(aC3DE, aT1, aT2);
//
for (i=0; i<2; ++i) {
bPC = !i ? bPC1 : bPC2;
@ -1350,10 +1379,12 @@ void BOPTools_AlgoTools::MakePCurve(const TopoDS_Edge& aE,
}
//
if (aC3DE->IsPeriodic()) {
BOPTools_AlgoTools2D::AdjustPCurveOnFace(aFFWD, aT1, aT2, aC2D, aC2DA);
BOPTools_AlgoTools2D::AdjustPCurveOnFace(aFFWD, aT1, aT2, aC2D,
aC2DA);
}
else {
BOPTools_AlgoTools2D::AdjustPCurveOnFace(aFFWD, aC3DETrim, aC2D, aC2DA);
BOPTools_AlgoTools2D::AdjustPCurveOnFace(aFFWD, aC3DETrim, aC2D,
aC2DA);
}
//
aBB.UpdateEdge(aE, aC2DA, aFFWD, aTolE);
@ -1376,7 +1407,8 @@ void BOPTools_AlgoTools::MakeEdge(const IntTools_Curve& theIC,
Standard_Real aTolV;
BRep_Builder aBB;
//
BOPTools_AlgoTools::MakeSectEdge (theIC, theV1, theT1, theV2, theT2, theE);
BOPTools_AlgoTools::MakeSectEdge (theIC, theV1, theT1, theV2, theT2,
theE);
//
aBB.UpdateEdge(theE, theTolR3D);
//
@ -1486,9 +1518,10 @@ void BOPTools_AlgoTools::MakeVertex(BOPCol_ListOfShape& aLV,
//function : GetEdgeOnFace
//purpose :
//=======================================================================
Standard_Boolean BOPTools_AlgoTools::GetEdgeOnFace(const TopoDS_Edge& theE1,
const TopoDS_Face& theF2,
TopoDS_Edge& theE2)
Standard_Boolean BOPTools_AlgoTools::GetEdgeOnFace
(const TopoDS_Edge& theE1,
const TopoDS_Face& theF2,
TopoDS_Edge& theE2)
{
Standard_Boolean bFound;
TopoDS_Iterator aItF, aItW;
@ -1639,10 +1672,11 @@ Standard_Real AngleWithRef(const gp_Dir& theD1,
// function: IsBlockInOnFace
// purpose:
//=======================================================================
Standard_Boolean BOPTools_AlgoTools::IsBlockInOnFace (const IntTools_Range& aShrR,
const TopoDS_Face& aF,
const TopoDS_Edge& aE1,
Handle(BOPInt_Context)& aContext)
Standard_Boolean BOPTools_AlgoTools::IsBlockInOnFace
(const IntTools_Range& aShrR,
const TopoDS_Face& aF,
const TopoDS_Edge& aE1,
Handle(BOPInt_Context)& aContext)
{
Standard_Boolean bFlag;
Standard_Real f1, l1, ULD, VLD;
@ -1729,8 +1763,9 @@ Standard_Boolean BOPTools_AlgoTools::IsBlockInOnFace (const IntTools_Range& aShr
//function : IsMicroEdge
//purpose :
//=======================================================================
Standard_Boolean BOPTools_AlgoTools::IsMicroEdge(const TopoDS_Edge& aE,
const Handle(BOPInt_Context)& aCtx)
Standard_Boolean BOPTools_AlgoTools::IsMicroEdge
(const TopoDS_Edge& aE,
const Handle(BOPInt_Context)& aCtx)
{
Standard_Boolean bRet;
Standard_Integer iErr;
@ -1755,7 +1790,8 @@ Standard_Boolean BOPTools_AlgoTools::IsMicroEdge(const TopoDS_Edge& aE,
}
//
BOPInt_ShrunkRange aSR;
aSR.SetData(aE, aT1, aT2, aV1, aV2, aCtx);
aSR.SetContext(aCtx);
aSR.SetData(aE, aT1, aT2, aV1, aV2);
aSR.Perform();
iErr=aSR.ErrorStatus();
bRet = !(iErr==0);
@ -1785,7 +1821,8 @@ void GetFaceDir(const TopoDS_Edge& aE,
//
gp_Pnt aPx;
if (!FindPointInFace(aE, aF, aP, aDB, aPx, theContext, aProjPL)) {
BOPTools_AlgoTools3D::GetApproxNormalToFaceOnEdge(aE, aF, aT, aPx, aDN, theContext);
BOPTools_AlgoTools3D::GetApproxNormalToFaceOnEdge(aE, aF, aT, aPx,
aDN, theContext);
aProjPL.Perform(aPx);
aPx = aProjPL.NearestPoint();
gp_Vec aVec(aP, aPx);
@ -1882,8 +1919,7 @@ Standard_Boolean FindPointInFace(const TopoDS_Edge& aE,
//function : IsOpenShell
//purpose :
//=======================================================================
Standard_Boolean
BOPTools_AlgoTools::IsOpenShell(const TopoDS_Shell& aSh)
Standard_Boolean BOPTools_AlgoTools::IsOpenShell(const TopoDS_Shell& aSh)
{
Standard_Boolean bRet;
Standard_Integer i, aNbE, aNbF;
@ -1909,7 +1945,7 @@ Standard_Boolean
const TopoDS_Shape& aF=aItLS.Value();
aOrF=aF.Orientation();
if (aOrF==TopAbs_INTERNAL || aOrF==TopAbs_EXTERNAL) {
continue;
continue;
}
++aNbF;
}

107
src/BOPTools/BOPTools_AlgoTools_2.cxx
View File

@ -40,8 +40,9 @@ static
// function: UpdateVertex
// purpose:
//=======================================================================
void BOPTools_AlgoTools::UpdateVertex (const TopoDS_Vertex& aVF,
const TopoDS_Vertex& aNewVertex)
void BOPTools_AlgoTools::UpdateVertex
(const TopoDS_Vertex& aVF,
const TopoDS_Vertex& aNewVertex)
{
Standard_Real aTolVF, aTolNewVertex, aDist, aDTol=1.e-12, aNewTol;
//
@ -63,9 +64,9 @@ static
// function: UpdateVertex
// purpose:
//=======================================================================
void BOPTools_AlgoTools::UpdateVertex (const TopoDS_Edge& aE,
const Standard_Real aT,
const TopoDS_Vertex& aV)
void BOPTools_AlgoTools::UpdateVertex (const TopoDS_Edge& aE,
const Standard_Real aT,
const TopoDS_Vertex& aV)
{
Standard_Real aTolV, aDist, aDTol=1.e-12, aFirst, aLast;
gp_Pnt aPc;
@ -86,9 +87,9 @@ static
// function: UpdateVertex
// purpose:
//=======================================================================
void BOPTools_AlgoTools::UpdateVertex (const IntTools_Curve& aC,
const Standard_Real aT,
const TopoDS_Vertex& aV)
void BOPTools_AlgoTools::UpdateVertex (const IntTools_Curve& aC,
const Standard_Real aT,
const TopoDS_Vertex& aV)
{
Standard_Real aTolV, aDist, aDTol=1.e-12;
gp_Pnt aPc;
@ -108,12 +109,12 @@ static
// function: MakeSectEdge
// purpose:
//=======================================================================
void BOPTools_AlgoTools::MakeSectEdge(const IntTools_Curve& aIC,
const TopoDS_Vertex& aV1,
const Standard_Real aP1,
const TopoDS_Vertex& aV2,
const Standard_Real aP2,
TopoDS_Edge& aNewEdge)
void BOPTools_AlgoTools::MakeSectEdge(const IntTools_Curve& aIC,
const TopoDS_Vertex& aV1,
const Standard_Real aP1,
const TopoDS_Vertex& aV2,
const Standard_Real aP2,
TopoDS_Edge& aNewEdge)
{
Handle(Geom_Curve) aC=aIC.Curve ();
@ -133,23 +134,19 @@ static
// function: MakeSplitEdge
// purpose:
//=======================================================================
void BOPTools_AlgoTools::MakeSplitEdge(const TopoDS_Edge& aE,
const TopoDS_Vertex& aV1,
const Standard_Real aP1,
const TopoDS_Vertex& aV2,
const Standard_Real aP2,
TopoDS_Edge& aNewEdge)
void BOPTools_AlgoTools::MakeSplitEdge(const TopoDS_Edge& aE,
const TopoDS_Vertex& aV1,
const Standard_Real aP1,
const TopoDS_Vertex& aV2,
const Standard_Real aP2,
TopoDS_Edge& aNewEdge)
{
Standard_Real f, l, aTol;
Handle(Geom_Curve) aC=BRep_Tool::Curve (aE, f, l);
Standard_Real aTol;//f, l,
aTol=BRep_Tool::Tolerance(aE);
//
// MakeEdge is used for chechking all input data only
BRepBuilderAPI_MakeEdge aMakeEdge(aC, aV1, aV2, aP1, aP2);
//ZZ const TopoDS_Edge& E1=TopoDS::Edge(aMakeEdge.Shape());
TopoDS_Edge E=aE;
E.EmptyCopy();
//
BRep_Builder BB;
BB.Add (E, aV1);
BB.Add (E, aV2);
@ -162,9 +159,9 @@ static
// function: MakeNewVertex
// purpose:
//=======================================================================
void BOPTools_AlgoTools::MakeNewVertex(const TopoDS_Vertex& aV1,
const TopoDS_Vertex& aV2,
TopoDS_Vertex& aNewVertex)
void BOPTools_AlgoTools::MakeNewVertex(const TopoDS_Vertex& aV1,
const TopoDS_Vertex& aV2,
TopoDS_Vertex& aNewVertex)
{
gp_Pnt aPnt1=BRep_Tool::Pnt(aV1);
Standard_Real aTol1=BRep_Tool::Tolerance(aV1);
@ -190,9 +187,9 @@ static
// function: MakeNewVertex
// purpose:
//=======================================================================
void BOPTools_AlgoTools::MakeNewVertex(const gp_Pnt& aP,
const Standard_Real aTol,
TopoDS_Vertex& aNewVertex)
void BOPTools_AlgoTools::MakeNewVertex(const gp_Pnt& aP,
const Standard_Real aTol,
TopoDS_Vertex& aNewVertex)
{
BRep_Builder aBB;
aBB.MakeVertex (aNewVertex, aP, aTol);
@ -202,11 +199,11 @@ static
// function: MakeNewVertex
// purpose:
//=======================================================================
void BOPTools_AlgoTools::MakeNewVertex(const TopoDS_Edge& aE1,
const Standard_Real aParm1,
const TopoDS_Edge& aE2,
const Standard_Real aParm2,
TopoDS_Vertex& aNewVertex)
void BOPTools_AlgoTools::MakeNewVertex(const TopoDS_Edge& aE1,
const Standard_Real aParm1,
const TopoDS_Edge& aE2,
const Standard_Real aParm2,
TopoDS_Vertex& aNewVertex)
{
Standard_Real aTol1, aTol2, aMaxTol, aDist;
gp_Pnt aPnt1, aPnt2;
@ -233,10 +230,10 @@ static
// function: MakeNewVertex
// purpose:
//=======================================================================
void BOPTools_AlgoTools::MakeNewVertex(const TopoDS_Edge& aE1,
const Standard_Real aParm1,
const TopoDS_Face& aF1,
TopoDS_Vertex& aNewVertex)
void BOPTools_AlgoTools::MakeNewVertex(const TopoDS_Edge& aE1,
const Standard_Real aParm1,
const TopoDS_Face& aF1,
TopoDS_Vertex& aNewVertex)
{
Standard_Real aTol1, aTol2, aMaxTol, delta=1.e-12;
gp_Pnt aPnt;
@ -257,9 +254,9 @@ static
// function: PointOnEdge
// purpose:
//=======================================================================
void BOPTools_AlgoTools::PointOnEdge(const TopoDS_Edge& aE,
const Standard_Real aParm,
gp_Pnt& aPnt)
void BOPTools_AlgoTools::PointOnEdge(const TopoDS_Edge& aE,
const Standard_Real aParm,
gp_Pnt& aPnt)
{
Standard_Real f, l;
Handle(Geom_Curve) C1=BRep_Tool::Curve(aE, f, l);
@ -270,10 +267,10 @@ static
//function : CorrectRange
//purpose :
//=======================================================================
void BOPTools_AlgoTools::CorrectRange(const TopoDS_Edge& aE1,
const TopoDS_Edge& aE2,
const IntTools_Range& aSR,
IntTools_Range& aNewSR)
void BOPTools_AlgoTools::CorrectRange(const TopoDS_Edge& aE1,
const TopoDS_Edge& aE2,
const IntTools_Range& aSR,
IntTools_Range& aNewSR)
{
Standard_Integer i;
Standard_Real aRes, aTolE1, aTolE2, aTF, aTL, dT;
@ -342,10 +339,10 @@ static
//function : CorrectRange
//purpose :
//=======================================================================
void BOPTools_AlgoTools::CorrectRange(const TopoDS_Edge& aE,
const TopoDS_Face& aF,
const IntTools_Range& aSR,
IntTools_Range& aNewSR)
void BOPTools_AlgoTools::CorrectRange(const TopoDS_Edge& aE,
const TopoDS_Face& aF,
const IntTools_Range& aSR,
IntTools_Range& aNewSR)
{
Standard_Integer i;
Standard_Real aRes, aTolF, aTF, aTL, dT;
@ -408,7 +405,7 @@ static
//function : Dimension
//purpose :
//=======================================================================
Standard_Integer BOPTools_AlgoTools::Dimension(const TopoDS_Shape& theS)
Standard_Integer BOPTools_AlgoTools::Dimension(const TopoDS_Shape& theS)
{
Standard_Integer i, iRet, iRx0 = 0, iRx = 0;
TopAbs_ShapeEnum aTS;
@ -462,8 +459,8 @@ static
//function : TreatCompound
//purpose :
//=======================================================================
void TreatCompound(const TopoDS_Shape& theC1,
BOPCol_ListOfShape& theLSX)
void TreatCompound(const TopoDS_Shape& theC1,
BOPCol_ListOfShape& theLSX)
{
Standard_Integer aNbC1;
TopAbs_ShapeEnum aType;