OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-10 18:51:21 +03:00
Code

0024940: WOK: Cyclic dependency detected between: BOPInt IntTools

Browse Source 
Classes  BOPInt_Context, BOPInt_ShrunkRange, BOPInt_Tools have been removed.
Package BOPInt has been removed
Classes IntTools_Context, IntTools_ShrunkRange have been added to replace corresponding BOPInt_ classes.
The classes provide same functionality as corresponding BOPInt_ classes.
Classes :
BOPAlgo_ArgumentAnalyzer
BOPAlgo_Builder
BOPAlgo_BuilderArea
BOPAlgo_BuilderFace
BOPAlgo_BuilderSolid
BOPAlgo_CheckerSI
BOPAlgo_PaveFiller
BOPAlgo_ShellSplitter
BOPTools_AlgoTools3D
BRepFill_TrimShellCorner
IntTools_BeanFaceIntersector
IntTools_EdgeFace
IntTools_FaceFace
IntTools_Tools
have been modified to use new classes IntTools_Context IntTools_ShrunkRange

Class IntTools_Tools has been modofied to provide the functionality that was in BOPInt_Tools.
This commit is contained in:
pkv 2014-05-26 10:48:29 +04:00 committed by apn
parent 68bd84a5f0
commit 1e143abba6
45 changed files with 1798 additions and 1972 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
adm/UDLIST
View File

@ -475,4 +475,3 @@ p Font
p BOPAlgo p BOPAlgo
p BOPDS p BOPDS
p BOPCol p BOPCol
p BOPInt

1
src/BOPAlgo/BOPAlgo.cdl
View File

@ -28,7 +28,6 @@ uses
IntSurf, IntSurf,
-- --
BOPDS, BOPDS,
BOPInt,
BOPCol, BOPCol,
BOPTools BOPTools
is is

16
src/BOPAlgo/BOPAlgo_ArgumentAnalyzer.cxx
View File

@ -47,7 +47,7 @@
#include <IntTools_EdgeEdge.hxx> #include <IntTools_EdgeEdge.hxx>
#include <IntTools_CommonPrt.hxx> #include <IntTools_CommonPrt.hxx>
#include <BOPInt_Context.hxx> #include <IntTools_Context.hxx>
#include <BOPTools_AlgoTools3D.hxx> #include <BOPTools_AlgoTools3D.hxx>
#include <BOPTools_AlgoTools.hxx> #include <BOPTools_AlgoTools.hxx>
@ -76,7 +76,6 @@ myMergeEdgeMode(Standard_False),
myContinuityMode(Standard_False), myContinuityMode(Standard_False),
myEmpty1(Standard_False), myEmpty1(Standard_False),
myEmpty2(Standard_False) myEmpty2(Standard_False)
// myMergeFaceMode(Standard_False)
{ {
} }
@ -379,9 +378,9 @@ void BOPAlgo_ArgumentAnalyzer::TestSmallEdge()
{ {
Standard_Integer i = 0; Standard_Integer i = 0;
BRepExtrema_DistShapeShape aDist; BRepExtrema_DistShapeShape aDist;
Handle(BOPInt_Context) aCtx; Handle(IntTools_Context) aCtx;
// //
aCtx = new BOPInt_Context; aCtx = new IntTools_Context;
for(i = 0; i < 2; i++) { for(i = 0; i < 2; i++) {
const TopoDS_Shape& aS = (i == 0) ? myShape1 : myShape2; const TopoDS_Shape& aS = (i == 0) ? myShape1 : myShape2;
@ -816,12 +815,3 @@ void BOPAlgo_ArgumentAnalyzer::TestContinuity()
} }
} }
} }
// ================================================================================
// function: TestMergeFace
// purpose:
// ================================================================================
// void BOPAlgo_ArgumentAnalyzer::TestMergeFace()
// {
// not implemented
// }

4
src/BOPAlgo/BOPAlgo_Builder.cdl
View File

@ -32,7 +32,7 @@ uses
MapOfShape from BOPCol, MapOfShape from BOPCol,
DataMapOfShapeShape from BOPCol, DataMapOfShapeShape from BOPCol,
DataMapOfShapeListOfShape from BOPCol, DataMapOfShapeListOfShape from BOPCol,
Context from BOPInt, Context from IntTools,
PDS from BOPDS, PDS from BOPDS,
PaveFiller from BOPAlgo, PaveFiller from BOPAlgo,
PPaveFiller from BOPAlgo PPaveFiller from BOPAlgo
@ -218,7 +218,7 @@ fields
myMapFence : MapOfShape from BOPCol is protected; myMapFence : MapOfShape from BOPCol is protected;
myPaveFiller : PPaveFiller from BOPAlgo is protected; myPaveFiller : PPaveFiller from BOPAlgo is protected;
myDS : PDS from BOPDS is protected; myDS : PDS from BOPDS is protected;
myContext : Context from BOPInt is protected; myContext : Context from IntTools is protected;
myEntryPoint : Integer from Standard is protected; myEntryPoint : Integer from Standard is protected;
-- --
myImages : DataMapOfShapeListOfShape from BOPCol is protected; myImages : DataMapOfShapeListOfShape from BOPCol is protected;

42
src/BOPAlgo/BOPAlgo_BuilderArea.cdl
View File

@ -16,66 +16,64 @@
-- commercial license or contractual agreement. -- commercial license or contractual agreement.
deferred class BuilderArea from BOPAlgo deferred class BuilderArea from BOPAlgo
inherits Algo from BOPAlgo inherits Algo from BOPAlgo
---Purpose: The root class for algorithms to build ---Purpose: The root class for algorithms to build
-- faces/solids from set of edges/faces -- faces/solids from set of edges/faces
uses uses
Shape from TopoDS, Shape from TopoDS,
BaseAllocator from BOPCol, BaseAllocator from BOPCol,
ListOfShape from BOPCol, ListOfShape from BOPCol,
MapOfOrientedShape from BOPCol, MapOfOrientedShape from BOPCol,
Context from BOPInt Context from IntTools
--raises --raises
is is
Initialize Initialize
returns BuilderArea from BOPAlgo; returns BuilderArea from BOPAlgo;
---C++: alias "Standard_EXPORT virtual ~BOPAlgo_BuilderArea();" ---C++: alias "Standard_EXPORT virtual ~BOPAlgo_BuilderArea();"
Initialize(theAllocator: BaseAllocator from BOPCol) Initialize(theAllocator: BaseAllocator from BOPCol)
returns BuilderArea from BOPAlgo; returns BuilderArea from BOPAlgo;
SetContext(me:out; SetContext(me:out;
theContext:Context from BOPInt); theContext:Context from IntTools);
Shapes(me) Shapes(me)
returns ListOfShape from BOPCol; returns ListOfShape from BOPCol;
---C++: return const & ---C++: return const &
---C++: alias "Standard_EXPORT void SetShapes(const BOPCol_ListOfShape& theLS);" ---C++: alias "Standard_EXPORT void SetShapes(const BOPCol_ListOfShape& theLS);"
Loops(me) Loops(me)
returns ListOfShape from BOPCol; returns ListOfShape from BOPCol;
---C++: return const & ---C++: return const &
Areas(me) Areas(me)
returns ListOfShape from BOPCol; returns ListOfShape from BOPCol;
---C++: return const & ---C++: return const &
PerformShapesToAvoid(me:out) PerformShapesToAvoid(me:out)
is deferred protected; is deferred protected;
PerformLoops(me:out) PerformLoops(me:out)
is deferred protected; is deferred protected;
PerformAreas(me:out) PerformAreas(me:out)
is deferred protected; is deferred protected;
PerformInternalShapes(me:out) PerformInternalShapes(me:out)
is deferred protected; is deferred protected;
fields fields
myContext : Context from BOPInt is protected; myContext : Context from IntTools is protected;
myShapes : ListOfShape from BOPCol is protected; myShapes : ListOfShape from BOPCol is protected;
myLoops : ListOfShape from BOPCol is protected; myLoops : ListOfShape from BOPCol is protected;
myLoopsInternal : ListOfShape from BOPCol is protected; myLoopsInternal : ListOfShape from BOPCol is protected;
myAreas : ListOfShape from BOPCol is protected; myAreas : ListOfShape from BOPCol is protected;
myShapesToAvoid : MapOfOrientedShape from BOPCol is protected; myShapesToAvoid : MapOfOrientedShape from BOPCol is protected;
--
end BuilderArea; end BuilderArea;

46
src/BOPAlgo/BOPAlgo_BuilderArea.cxx
View File

@ -25,10 +25,9 @@
//function : //function :
//purpose : //purpose :
//======================================================================= //=======================================================================
BOPAlgo_BuilderArea::BOPAlgo_BuilderArea() BOPAlgo_BuilderArea::BOPAlgo_BuilderArea()
: :
BOPAlgo_Algo(), BOPAlgo_Algo(),
//myContext(NULL),
myShapes(myAllocator), myShapes(myAllocator),
myLoops(myAllocator), myLoops(myAllocator),
myLoopsInternal(myAllocator), myLoopsInternal(myAllocator),
@ -40,10 +39,10 @@
//function : //function :
//purpose : //purpose :
//======================================================================= //=======================================================================
BOPAlgo_BuilderArea::BOPAlgo_BuilderArea(const Handle(NCollection_BaseAllocator)& theAllocator) BOPAlgo_BuilderArea::BOPAlgo_BuilderArea
(const Handle(NCollection_BaseAllocator)& theAllocator)
: :
BOPAlgo_Algo(theAllocator), BOPAlgo_Algo(theAllocator),
//myContext(NULL),
myShapes(myAllocator), myShapes(myAllocator),
myLoops(myAllocator), myLoops(myAllocator),
myLoopsInternal(myAllocator), myLoopsInternal(myAllocator),
@ -55,14 +54,15 @@
//function : ~ //function : ~
//purpose : //purpose :
//======================================================================= //=======================================================================
BOPAlgo_BuilderArea::~BOPAlgo_BuilderArea() BOPAlgo_BuilderArea::~BOPAlgo_BuilderArea()
{ {
} }
//======================================================================= //=======================================================================
//function : SetContext //function : SetContext
//purpose : //purpose :
//======================================================================= //=======================================================================
void BOPAlgo_BuilderArea::SetContext(const Handle(BOPInt_Context)& theContext) void BOPAlgo_BuilderArea::SetContext
(const Handle(IntTools_Context)& theContext)
{ {
myContext=theContext; myContext=theContext;
} }
@ -85,7 +85,7 @@
//function : Shapes //function : Shapes
//purpose : //purpose :
//======================================================================= //=======================================================================
const BOPCol_ListOfShape& BOPAlgo_BuilderArea::Shapes()const const BOPCol_ListOfShape& BOPAlgo_BuilderArea::Shapes()const
{ {
return myShapes; return myShapes;
} }
@ -93,7 +93,7 @@
//function : Loops //function : Loops
//purpose : //purpose :
//======================================================================= //=======================================================================
const BOPCol_ListOfShape& BOPAlgo_BuilderArea::Loops()const const BOPCol_ListOfShape& BOPAlgo_BuilderArea::Loops()const
{ {
return myLoops; return myLoops;
} }
@ -105,33 +105,3 @@
{ {
return myAreas; return myAreas;
} }
/*
//=======================================================================
//function :PerformShapesToAvoid
//purpose :
//=======================================================================
void BOPAlgo_BuilderArea::PerformShapesToAvoid()
{
}
//=======================================================================
//function : PerformLoops
//purpose :
//=======================================================================
void BOPAlgo_BuilderArea::PerformLoops()
{
}
//=======================================================================
//function : PerformAreas
//purpose :
//=======================================================================
void BOPAlgo_BuilderArea::PerformAreas()
{
}
//=======================================================================
//function : PerformInternalShapes
//purpose :
//=======================================================================
void BOPAlgo_BuilderArea::PerformInternalShapes()
{
}
*/

28
src/BOPAlgo/BOPAlgo_BuilderFace.cxx
View File

@ -44,7 +44,7 @@
#include <TopExp_Explorer.hxx> #include <TopExp_Explorer.hxx>
#include <IntTools_FClass2d.hxx> #include <IntTools_FClass2d.hxx>
#include <BOPInt_Context.hxx> #include <IntTools_Context.hxx>
// //
#include <BOPTools_AlgoTools.hxx> #include <BOPTools_AlgoTools.hxx>
@ -67,13 +67,13 @@ static
static static
Standard_Boolean IsInside(const TopoDS_Shape& , Standard_Boolean IsInside(const TopoDS_Shape& ,
const TopoDS_Shape& , const TopoDS_Shape& ,
Handle(BOPInt_Context)& ); Handle(IntTools_Context)& );
static static
void MakeInternalWires(const BOPCol_MapOfShape& , void MakeInternalWires(const BOPCol_MapOfShape& ,
BOPCol_ListOfShape& ); BOPCol_ListOfShape& );
static static
void GetWire(const TopoDS_Shape& , void GetWire(const TopoDS_Shape& ,
TopoDS_Shape& ); TopoDS_Shape& );
// //
#include <NCollection_UBTreeFiller.hxx> #include <NCollection_UBTreeFiller.hxx>
#include <BOPCol_Box2DBndTree.hxx> #include <BOPCol_Box2DBndTree.hxx>
@ -199,7 +199,7 @@ void BOPAlgo_BuilderFace::CheckData()
return; return;
} }
if (myContext.IsNull()) { if (myContext.IsNull()) {
myContext = new BOPInt_Context; myContext = new IntTools_Context;
} }
} }
//======================================================================= //=======================================================================
@ -261,9 +261,6 @@ void BOPAlgo_BuilderFace::PerformShapesToAvoid()
if (!myShapesToAvoid.Contains(aE)) { if (!myShapesToAvoid.Contains(aE)) {
BOPTools::MapShapesAndAncestors(aE, TopAbs_VERTEX, TopAbs_EDGE, aMVE); BOPTools::MapShapesAndAncestors(aE, TopAbs_VERTEX, TopAbs_EDGE, aMVE);
} }
//else {
//int a=0;
//}
} }
aNbV=aMVE.Extent(); aNbV=aMVE.Extent();
// //
@ -393,7 +390,10 @@ void BOPAlgo_BuilderFace::PerformLoops()
aItM.Initialize(myShapesToAvoid); aItM.Initialize(myShapesToAvoid);
for (; aItM.More(); aItM.Next()) { for (; aItM.More(); aItM.Next()) {
const TopoDS_Shape& aEE=aItM.Key(); const TopoDS_Shape& aEE=aItM.Key();
BOPTools::MapShapesAndAncestors(aEE, TopAbs_VERTEX, TopAbs_EDGE, aVEMap); BOPTools::MapShapesAndAncestors(aEE,
TopAbs_VERTEX,
TopAbs_EDGE,
aVEMap);
} }
// //
bFlag=Standard_True; bFlag=Standard_True;
@ -492,11 +492,11 @@ void BOPAlgo_BuilderFace::PerformAreas()
bIsHole=aClsf.IsHole(); bIsHole=aClsf.IsHole();
if (bIsHole) { if (bIsHole) {
BOPTools::MapShapes(aWire, TopAbs_EDGE, aMHE); BOPTools::MapShapes(aWire, TopAbs_EDGE, aMHE);
// //
bIsHole=Standard_True; bIsHole=Standard_True;
} }
else { else {
bIsHole=Standard_False; bIsHole=Standard_False;
} }
} }
// //
@ -557,8 +557,8 @@ void BOPAlgo_BuilderFace::PerformAreas()
} }
// //
if (aInOutMap.IsBound (aHole)){ if (aInOutMap.IsBound (aHole)){
const TopoDS_Shape& aF2=aInOutMap(aHole); const TopoDS_Shape& aF2=aInOutMap(aHole);
if (IsInside(aF, aF2, myContext)) { if (IsInside(aF, aF2, myContext)) {
aInOutMap.UnBind(aHole); aInOutMap.UnBind(aHole);
aInOutMap.Bind (aHole, aF); aInOutMap.Bind (aHole, aF);
} }
@ -769,7 +769,7 @@ void MakeInternalWires(const BOPCol_MapOfShape& theME,
//======================================================================= //=======================================================================
Standard_Boolean IsInside(const TopoDS_Shape& theHole, Standard_Boolean IsInside(const TopoDS_Shape& theHole,
const TopoDS_Shape& theF2, const TopoDS_Shape& theF2,
Handle(BOPInt_Context)& theContext) Handle(IntTools_Context)& theContext)
{ {
Standard_Boolean bRet; Standard_Boolean bRet;
Standard_Real aT, aU, aV; Standard_Real aT, aU, aV;

42
src/BOPAlgo/BOPAlgo_BuilderSolid.cxx
View File

@ -66,7 +66,7 @@
#include <BOPTools_CoupleOfShape.hxx> #include <BOPTools_CoupleOfShape.hxx>
#include <BOPTools_AlgoTools.hxx> #include <BOPTools_AlgoTools.hxx>
// //
#include <BOPInt_Context.hxx> #include <IntTools_Context.hxx>
// //
#include <BOPAlgo_ShellSplitter.hxx> #include <BOPAlgo_ShellSplitter.hxx>
@ -75,11 +75,11 @@ static
const BOPCol_IndexedMapOfShape& ); const BOPCol_IndexedMapOfShape& );
static static
Standard_Boolean IsHole(const TopoDS_Shape& , Standard_Boolean IsHole(const TopoDS_Shape& ,
Handle(BOPInt_Context)& ); Handle(IntTools_Context)& );
static static
Standard_Boolean IsInside(const TopoDS_Shape& , Standard_Boolean IsInside(const TopoDS_Shape& ,
const TopoDS_Shape& , const TopoDS_Shape& ,
Handle(BOPInt_Context)& ); Handle(IntTools_Context)& );
static static
void MakeInternalShells(const BOPCol_MapOfShape& , void MakeInternalShells(const BOPCol_MapOfShape& ,
BOPCol_ListOfShape& ); BOPCol_ListOfShape& );
@ -185,7 +185,7 @@ void BOPAlgo_BuilderSolid::Perform()
myErrorStatus=0; myErrorStatus=0;
// //
if (myContext.IsNull()) { if (myContext.IsNull()) {
myContext=new BOPInt_Context; myContext=new IntTools_Context;
} }
// //
TopoDS_Compound aC; TopoDS_Compound aC;
@ -381,8 +381,8 @@ void BOPAlgo_BuilderSolid::PerformLoops()
for (; aItM.More(); aItM.Next()) { for (; aItM.More(); aItM.Next()) {
const TopoDS_Shape& aFF=aItM.Key(); const TopoDS_Shape& aFF=aItM.Key();
BOPTools::MapShapesAndAncestors(aFF, BOPTools::MapShapesAndAncestors(aFF,
TopAbs_EDGE, TopAbs_FACE, TopAbs_EDGE, TopAbs_FACE,
aEFMap); aEFMap);
} }
// //
aItM.Initialize(myShapesToAvoid); aItM.Initialize(myShapesToAvoid);
@ -472,7 +472,7 @@ void BOPAlgo_BuilderSolid::PerformAreas()
if (bIsHole) { if (bIsHole) {
aHoleShells.Append(aShell); aHoleShells.Append(aShell);
BOPTools::MapShapes(aShell, TopAbs_FACE, aMHF); BOPTools::MapShapes(aShell, TopAbs_FACE, aMHF);
aSB.SetShape(aShell); aSB.SetShape(aShell);
} }
else { else {
// make a growth solid from a shell // make a growth solid from a shell
@ -480,7 +480,7 @@ void BOPAlgo_BuilderSolid::PerformAreas()
aBB.Add (aSolid, aShell); aBB.Add (aSolid, aShell);
// //
aNewSolids.Append (aSolid); aNewSolids.Append (aSolid);
aSB.SetShape(aSolid); aSB.SetShape(aSolid);
} }
} }
// //
@ -537,8 +537,8 @@ void BOPAlgo_BuilderSolid::PerformAreas()
} }
// //
if (aInOutMap.IsBound (aHole)){ if (aInOutMap.IsBound (aHole)){
const TopoDS_Shape& aHole2=aInOutMap(aHole); const TopoDS_Shape& aHole2=aInOutMap(aHole);
if (IsInside(aHole, aHole2, myContext)) { if (IsInside(aHole, aHole2, myContext)) {
aInOutMap.UnBind(aHole); aInOutMap.UnBind(aHole);
aInOutMap.Bind (aHole, aSolid); aInOutMap.Bind (aHole, aSolid);
} }
@ -657,8 +657,8 @@ void BOPAlgo_BuilderSolid::PerformInternalShapes()
} }
aMEF.Clear(); aMEF.Clear();
BOPTools::MapShapesAndAncestors(aSolid, BOPTools::MapShapesAndAncestors(aSolid,
TopAbs_EDGE, TopAbs_FACE, TopAbs_EDGE, TopAbs_FACE,
aMEF); aMEF);
// //
// 2.1 Separate faces to process aMFP // 2.1 Separate faces to process aMFP
aMFP.Clear(); aMFP.Clear();
@ -667,10 +667,10 @@ void BOPAlgo_BuilderSolid::PerformInternalShapes()
const TopoDS_Face& aF=(*(TopoDS_Face*)(&aItMF.Key())); const TopoDS_Face& aF=(*(TopoDS_Face*)(&aItMF.Key()));
if (!aMFx.Contains(aF)) { if (!aMFx.Contains(aF)) {
if (BOPTools_AlgoTools::IsInternalFace(aF, if (BOPTools_AlgoTools::IsInternalFace(aF,
aSolid, aSolid,
aMEF, aMEF,
1.e-14, 1.e-14,
myContext)) { myContext)) {
aMFP.Add(aF); aMFP.Add(aF);
} }
} }
@ -732,8 +732,8 @@ void MakeInternalShells(const BOPCol_MapOfShape& theMF,
for (; aItM.More(); aItM.Next()) { for (; aItM.More(); aItM.Next()) {
const TopoDS_Shape& aF=aItM.Key(); const TopoDS_Shape& aF=aItM.Key();
BOPTools::MapShapesAndAncestors(aF, BOPTools::MapShapesAndAncestors(aF,
TopAbs_EDGE, TopAbs_FACE, TopAbs_EDGE, TopAbs_FACE,
aMEF); aMEF);
} }
// //
aItM.Initialize(theMF); aItM.Initialize(theMF);
@ -775,7 +775,7 @@ void MakeInternalShells(const BOPCol_MapOfShape& theMF,
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean IsHole(const TopoDS_Shape& theS2, Standard_Boolean IsHole(const TopoDS_Shape& theS2,
Handle(BOPInt_Context)& theContext) Handle(IntTools_Context)& theContext)
{ {
TopoDS_Solid *pS2=(TopoDS_Solid *)&theS2; TopoDS_Solid *pS2=(TopoDS_Solid *)&theS2;
BRepClass3d_SolidClassifier& aClsf=theContext->SolidClassifier(*pS2); BRepClass3d_SolidClassifier& aClsf=theContext->SolidClassifier(*pS2);
@ -790,7 +790,7 @@ Standard_Boolean IsHole(const TopoDS_Shape& theS2,
//======================================================================= //=======================================================================
Standard_Boolean IsInside(const TopoDS_Shape& theS1, Standard_Boolean IsInside(const TopoDS_Shape& theS1,
const TopoDS_Shape& theS2, const TopoDS_Shape& theS2,
Handle(BOPInt_Context)& theContext) Handle(IntTools_Context)& theContext)
{ {
TopExp_Explorer aExp; TopExp_Explorer aExp;
TopAbs_State aState; TopAbs_State aState;
@ -808,7 +808,7 @@ Standard_Boolean IsInside(const TopoDS_Shape& theS1,
BOPTools::MapShapes(*pS2, TopAbs_EDGE, aBounds); BOPTools::MapShapes(*pS2, TopAbs_EDGE, aBounds);
const TopoDS_Face& aF = (*(TopoDS_Face*)(&aExp.Current())); const TopoDS_Face& aF = (*(TopoDS_Face*)(&aExp.Current()));
aState=BOPTools_AlgoTools::ComputeState(aF, *pS2, 1.e-14, aState=BOPTools_AlgoTools::ComputeState(aF, *pS2, 1.e-14,
aBounds, theContext); aBounds, theContext);
} }
return (aState==TopAbs_IN); return (aState==TopAbs_IN);
} }

18
src/BOPAlgo/BOPAlgo_Builder_2.cxx
View File

@ -38,7 +38,7 @@
#include <BOPCol_NCVector.hxx> #include <BOPCol_NCVector.hxx>
#include <BOPCol_TBB.hxx> #include <BOPCol_TBB.hxx>
// //
#include <BOPInt_Context.hxx> #include <IntTools_Context.hxx>
// //
#include <BOPDS_PaveBlock.hxx> #include <BOPDS_PaveBlock.hxx>
#include <BOPDS_ShapeInfo.hxx> #include <BOPDS_ShapeInfo.hxx>
@ -132,9 +132,9 @@ class BOPAlgo_BuilderSDFaceFunctor {
void operator()( const flexible_range<Standard_Integer>& aBR ) const { void operator()( const flexible_range<Standard_Integer>& aBR ) const {
Standard_Boolean bFlag; Standard_Boolean bFlag;
Standard_Integer i, iBeg, iEnd; Standard_Integer i, iBeg, iEnd;
Handle(BOPInt_Context) aContext; Handle(IntTools_Context) aContext;
// //
aContext=new BOPInt_Context; aContext=new IntTools_Context;
// //
BOPAlgo_VectorOfPairOfShapeBoolean& aVPSB=*myPVPSB; BOPAlgo_VectorOfPairOfShapeBoolean& aVPSB=*myPVPSB;
// //
@ -223,11 +223,11 @@ class BOPAlgo_VFI {
return myFlag; return myFlag;
} }
// //
void SetContext(const Handle(BOPInt_Context)& aContext) { void SetContext(const Handle(IntTools_Context)& aContext) {
myContext=aContext; myContext=aContext;
} }
// //
const Handle(BOPInt_Context)& Context()const { const Handle(IntTools_Context)& Context()const {
return myContext; return myContext;
} }
// //
@ -241,7 +241,7 @@ class BOPAlgo_VFI {
Standard_Integer myFlag; Standard_Integer myFlag;
TopoDS_Vertex myV; TopoDS_Vertex myV;
TopoDS_Face myF; TopoDS_Face myF;
Handle(BOPInt_Context) myContext; Handle(IntTools_Context) myContext;
}; };
// //
typedef BOPCol_NCVector<BOPAlgo_VFI> BOPAlgo_VectorOfVFI; typedef BOPCol_NCVector<BOPAlgo_VFI> BOPAlgo_VectorOfVFI;
@ -249,13 +249,13 @@ typedef BOPCol_NCVector<BOPAlgo_VFI> BOPAlgo_VectorOfVFI;
typedef BOPCol_TBBContextFunctor typedef BOPCol_TBBContextFunctor
<BOPAlgo_VFI, <BOPAlgo_VFI,
BOPAlgo_VectorOfVFI, BOPAlgo_VectorOfVFI,
Handle(BOPInt_Context), Handle(IntTools_Context),
BOPInt_Context> BOPAlgo_VFIFunctor; IntTools_Context> BOPAlgo_VFIFunctor;
// //
typedef BOPCol_TBBContextCnt typedef BOPCol_TBBContextCnt
<BOPAlgo_VFIFunctor, <BOPAlgo_VFIFunctor,
BOPAlgo_VectorOfVFI, BOPAlgo_VectorOfVFI,
Handle(BOPInt_Context)> BOPAlgo_VFICnt; Handle(IntTools_Context)> BOPAlgo_VFICnt;
// //
//======================================================================= //=======================================================================
//function : FillImagesFaces //function : FillImagesFaces

7
src/BOPAlgo/BOPAlgo_Builder_3.cxx
View File

@ -52,7 +52,7 @@
#include <BOPCol_NCVector.hxx> #include <BOPCol_NCVector.hxx>
#include <BOPCol_TBB.hxx> #include <BOPCol_TBB.hxx>
// //
#include <BOPInt_Context.hxx> #include <IntTools_Context.hxx>
// //
#include <BOPDS_DS.hxx> #include <BOPDS_DS.hxx>
#include <BOPDS_ShapeInfo.hxx> #include <BOPDS_ShapeInfo.hxx>
@ -434,9 +434,8 @@ void BOPAlgo_Builder::BuildDraftSolid(const TopoDS_Shape& theSolid,
theLIF.Append(aFSDx); theLIF.Append(aFSDx);
} }
else { else {
bToReverse=BOPTools_AlgoTools::IsSplitToReverse(aFSDx, bToReverse=BOPTools_AlgoTools::IsSplitToReverse
aF, (aFSDx, aF, myContext);
myContext);
if (bToReverse) { if (bToReverse) {
aFSDx.Reverse(); aFSDx.Reverse();
} }

4
src/BOPAlgo/BOPAlgo_CheckerSI.cxx
View File

@ -39,7 +39,7 @@
#include <BOPDS_VectorOfInterfEF.hxx> #include <BOPDS_VectorOfInterfEF.hxx>
#include <BOPDS_VectorOfInterfFF.hxx> #include <BOPDS_VectorOfInterfFF.hxx>
#include <BOPInt_Context.hxx> #include <IntTools_Context.hxx>
#include <BOPTools.hxx> #include <BOPTools.hxx>
#include <BOPTools_AlgoTools.hxx> #include <BOPTools_AlgoTools.hxx>
@ -115,7 +115,7 @@ void BOPAlgo_CheckerSI::Init()
myIterator=theIterSI; myIterator=theIterSI;
// //
// 3 myContext // 3 myContext
myContext=new BOPInt_Context; myContext=new IntTools_Context;
// //
myErrorStatus=0; myErrorStatus=0;
} }

2
src/BOPAlgo/BOPAlgo_CheckerSI_1.cxx
View File

@ -20,7 +20,7 @@
#include <BOPDS_DS.hxx> #include <BOPDS_DS.hxx>
#include <BOPDS_IteratorSI.hxx> #include <BOPDS_IteratorSI.hxx>
#include <BOPInt_Context.hxx> #include <IntTools_Context.hxx>
#include <BOPDS_Interf.hxx> #include <BOPDS_Interf.hxx>
#include <TopoDS_Solid.hxx> #include <TopoDS_Solid.hxx>

32
src/BOPAlgo/BOPAlgo_PaveFiller.cdl
View File

@ -38,7 +38,7 @@ uses
DataMapOfIntegerReal from BOPCol, DataMapOfIntegerReal from BOPCol,
DataMapOfIntegerInteger from BOPCol, DataMapOfIntegerInteger from BOPCol,
-- --
Context from BOPInt, Context from IntTools,
-- --
SectionAttribute from BOPAlgo, SectionAttribute from BOPAlgo,
@ -68,7 +68,7 @@ is
Create (theAllocator: BaseAllocator from BOPCol) Create (theAllocator: BaseAllocator from BOPCol)
returns PaveFiller from BOPAlgo; returns PaveFiller from BOPAlgo;
DS(me:out) DS(me:out)
returns DS from BOPDS; returns DS from BOPDS;
---C++:return const & ---C++:return const &
@ -87,7 +87,7 @@ is
---C++: alias "Standard_EXPORT void SetArguments(const BOPCol_ListOfShape& theLS);" ---C++: alias "Standard_EXPORT void SetArguments(const BOPCol_ListOfShape& theLS);"
Context(me:out) Context(me:out)
returns Context from BOPInt; returns Context from IntTools;
SetSectionAttribute(me:out; SetSectionAttribute(me:out;
theSecAttr : SectionAttribute from BOPAlgo); theSecAttr : SectionAttribute from BOPAlgo);
@ -114,10 +114,10 @@ is
PerformVF(me:out) PerformVF(me:out)
is virtual protected; is virtual protected;
PerformEE(me:out) PerformEE(me:out)
is virtual protected; is virtual protected;
PerformEF(me:out) PerformEF(me:out)
is virtual protected; is virtual protected;
@ -133,10 +133,10 @@ is
MakeBlocks(me:out) MakeBlocks(me:out)
is protected; is protected;
MakePCurves(me:out) MakePCurves(me:out)
is protected; is protected;
ProcessDE(me:out) ProcessDE(me:out)
is protected; is protected;
@ -147,14 +147,14 @@ is
FillShrunkData(me:out; FillShrunkData(me:out;
theType1: ShapeEnum from TopAbs; theType1: ShapeEnum from TopAbs;
theType2: ShapeEnum from TopAbs) theType2: ShapeEnum from TopAbs)
is protected; is protected;
PerformVerticesEE(me:out; PerformVerticesEE(me:out;
theMVCPB:out IndexedDataMapOfShapeCoupleOfPaveBlocks from BOPDS; theMVCPB:out IndexedDataMapOfShapeCoupleOfPaveBlocks from BOPDS;
theAllocator:out BaseAllocator from BOPCol) theAllocator:out BaseAllocator from BOPCol)
returns Integer from Standard returns Integer from Standard
is protected; is protected;
PerformVerticesEF(me:out; PerformVerticesEF(me:out;
theMVCPB:out IndexedDataMapOfShapeCoupleOfPaveBlocks from BOPDS; theMVCPB:out IndexedDataMapOfShapeCoupleOfPaveBlocks from BOPDS;
theAllocator:out BaseAllocator from BOPCol) theAllocator:out BaseAllocator from BOPCol)
@ -166,14 +166,14 @@ is
theMIF:MapOfInteger from BOPCol) theMIF:MapOfInteger from BOPCol)
returns Boolean from Standard returns Boolean from Standard
is protected; is protected;
CheckFacePaves(myclass; CheckFacePaves(myclass;
theN:Integer from Standard; theN:Integer from Standard;
theMIFOn:MapOfInteger from BOPCol; theMIFOn:MapOfInteger from BOPCol;
theMIFIn:MapOfInteger from BOPCol) theMIFIn:MapOfInteger from BOPCol)
returns Boolean from Standard returns Boolean from Standard
is protected; is protected;
IsExistingVertex(me; IsExistingVertex(me;
theP:Pnt from gp; theP:Pnt from gp;
theTol:Real from Standard; theTol:Real from Standard;
@ -210,7 +210,7 @@ is
-- 1 - checks only EE; -- 1 - checks only EE;
-- 2 - checks only EF; -- 2 - checks only EF;
-- other - checks both types of intersections. -- other - checks both types of intersections.
PutBoundPaveOnCurve(me:out; PutBoundPaveOnCurve(me:out;
theF1: Face from TopoDS; theF1: Face from TopoDS;
theF2: Face from TopoDS; theF2: Face from TopoDS;
@ -263,12 +263,12 @@ is
theLPB: ListOfPaveBlock from BOPDS; theLPB: ListOfPaveBlock from BOPDS;
thePB: PaveBlock from BOPDS) thePB: PaveBlock from BOPDS)
is protected; is protected;
MakeSplitEdge(me:out; MakeSplitEdge(me:out;
theV:Integer from Standard; theV:Integer from Standard;
theF:Integer from Standard) theF:Integer from Standard)
is protected; is protected;
GetEFPnts(me:out; GetEFPnts(me:out;
nF1 : Integer from Standard; nF1 : Integer from Standard;
nF2 : Integer from Standard; nF2 : Integer from Standard;
@ -348,7 +348,7 @@ is
theMVB : MapOfInteger from BOPCol; theMVB : MapOfInteger from BOPCol;
theMPB : out MapOfPaveBlock from BOPDS) theMPB : out MapOfPaveBlock from BOPDS)
is protected; is protected;
---Purpose: ---Purpose:
-- Adds the existing edges from the map <theMPBOnIn> which interfere -- Adds the existing edges from the map <theMPBOnIn> which interfere
-- with the vertices from <theMVB> map to the post treatment of section edges. -- with the vertices from <theMVB> map to the post treatment of section edges.
@ -449,7 +449,7 @@ fields
myArguments : ListOfShape from BOPCol is protected; myArguments : ListOfShape from BOPCol is protected;
myDS : PDS from BOPDS is protected; myDS : PDS from BOPDS is protected;
myIterator : PIterator from BOPDS is protected; myIterator : PIterator from BOPDS is protected;
myContext : Context from BOPInt is protected; myContext : Context from IntTools is protected;
mySectionAttribute : SectionAttribute from BOPAlgo is protected; mySectionAttribute : SectionAttribute from BOPAlgo is protected;
end PaveFiller; end PaveFiller;

6
src/BOPAlgo/BOPAlgo_PaveFiller.cxx
View File

@ -22,7 +22,7 @@
#include <NCollection_BaseAllocator.hxx> #include <NCollection_BaseAllocator.hxx>
#include <BOPInt_Context.hxx> #include <IntTools_Context.hxx>
#include <BOPDS_DS.hxx> #include <BOPDS_DS.hxx>
#include <BOPDS_Iterator.hxx> #include <BOPDS_Iterator.hxx>
@ -93,7 +93,7 @@ BOPDS_PDS BOPAlgo_PaveFiller::PDS()
//function : Context //function : Context
//purpose : //purpose :
//======================================================================= //=======================================================================
Handle(BOPInt_Context) BOPAlgo_PaveFiller::Context() Handle(IntTools_Context) BOPAlgo_PaveFiller::Context()
{ {
return myContext; return myContext;
} }
@ -150,7 +150,7 @@ void BOPAlgo_PaveFiller::Init()
myIterator->Prepare(); myIterator->Prepare();
// //
// 3 myContext // 3 myContext
myContext=new BOPInt_Context; myContext=new IntTools_Context;
// //
myErrorStatus=0; myErrorStatus=0;
} }

14
src/BOPAlgo/BOPAlgo_PaveFiller_2.cxx
View File

@ -24,7 +24,7 @@
#include <BOPCol_NCVector.hxx> #include <BOPCol_NCVector.hxx>
#include <BOPCol_TBB.hxx> #include <BOPCol_TBB.hxx>
#include <BOPInt_Context.hxx> #include <IntTools_Context.hxx>
#include <BOPDS_Iterator.hxx> #include <BOPDS_Iterator.hxx>
#include <BOPDS_VectorOfInterfVE.hxx> #include <BOPDS_VectorOfInterfVE.hxx>
@ -87,11 +87,11 @@ class BOPAlgo_VertexEdge {
return myT; return myT;
} }
// //
void SetContext(const Handle(BOPInt_Context)& aContext) { void SetContext(const Handle(IntTools_Context)& aContext) {
myContext=aContext; myContext=aContext;
} }
// //
const Handle(BOPInt_Context)& Context()const { const Handle(IntTools_Context)& Context()const {
return myContext; return myContext;
} }
// //
@ -107,7 +107,7 @@ class BOPAlgo_VertexEdge {
Standard_Real myT; Standard_Real myT;
TopoDS_Vertex myV; TopoDS_Vertex myV;
TopoDS_Edge myE; TopoDS_Edge myE;
Handle(BOPInt_Context) myContext; Handle(IntTools_Context) myContext;
}; };
//======================================================================= //=======================================================================
typedef BOPCol_NCVector typedef BOPCol_NCVector
@ -116,13 +116,13 @@ typedef BOPCol_NCVector
typedef BOPCol_TBBContextFunctor typedef BOPCol_TBBContextFunctor
<BOPAlgo_VertexEdge, <BOPAlgo_VertexEdge,
BOPAlgo_VectorOfVertexEdge, BOPAlgo_VectorOfVertexEdge,
Handle(BOPInt_Context), Handle(IntTools_Context),
BOPInt_Context> BOPAlgo_VertexEdgeFunctor; IntTools_Context> BOPAlgo_VertexEdgeFunctor;
// //
typedef BOPCol_TBBContextCnt typedef BOPCol_TBBContextCnt
<BOPAlgo_VertexEdgeFunctor, <BOPAlgo_VertexEdgeFunctor,
BOPAlgo_VectorOfVertexEdge, BOPAlgo_VectorOfVertexEdge,
Handle(BOPInt_Context)> BOPAlgo_VertexEdgeCnt; Handle(IntTools_Context)> BOPAlgo_VertexEdgeCnt;
// //
//======================================================================= //=======================================================================
// function: PerformVE // function: PerformVE

38
src/BOPAlgo/BOPAlgo_PaveFiller_3.cxx
View File

@ -49,9 +49,9 @@
#include <BOPCol_NCVector.hxx> #include <BOPCol_NCVector.hxx>
#include <BOPCol_TBB.hxx> #include <BOPCol_TBB.hxx>
// //
#include <BOPInt_Context.hxx> #include <IntTools_Context.hxx>
#include <BOPInt_ShrunkRange.hxx> #include <IntTools_ShrunkRange.hxx>
#include <BOPInt_Tools.hxx> #include <IntTools_Tools.hxx>
// //
#include <BOPDS_DataMapOfPaveBlockListOfPaveBlock.hxx> #include <BOPDS_DataMapOfPaveBlockListOfPaveBlock.hxx>
#include <BOPDS_MapOfPaveBlock.hxx> #include <BOPDS_MapOfPaveBlock.hxx>
@ -216,11 +216,11 @@ class BOPAlgo_PVE {
return myT; return myT;
} }
// //
void SetContext(const Handle(BOPInt_Context)& aContext) { void SetContext(const Handle(IntTools_Context)& aContext) {
myContext=aContext; myContext=aContext;
} }
// //
const Handle(BOPInt_Context)& Context()const { const Handle(IntTools_Context)& Context()const {
return myContext; return myContext;
} }
// //
@ -236,7 +236,7 @@ class BOPAlgo_PVE {
TopoDS_Vertex myV; TopoDS_Vertex myV;
TopoDS_Edge myE; TopoDS_Edge myE;
Handle(BOPDS_PaveBlock) myPB; Handle(BOPDS_PaveBlock) myPB;
Handle(BOPInt_Context) myContext; Handle(IntTools_Context) myContext;
}; };
//======================================================================= //=======================================================================
typedef BOPCol_NCVector typedef BOPCol_NCVector
@ -245,13 +245,13 @@ typedef BOPCol_NCVector
typedef BOPCol_TBBContextFunctor typedef BOPCol_TBBContextFunctor
<BOPAlgo_PVE, <BOPAlgo_PVE,
BOPAlgo_VectorOfPVE, BOPAlgo_VectorOfPVE,
Handle(BOPInt_Context), Handle(IntTools_Context),
BOPInt_Context> BOPAlgo_PVEFunctor; IntTools_Context> BOPAlgo_PVEFunctor;
// //
typedef BOPCol_TBBContextCnt typedef BOPCol_TBBContextCnt
<BOPAlgo_PVEFunctor, <BOPAlgo_PVEFunctor,
BOPAlgo_VectorOfPVE, BOPAlgo_VectorOfPVE,
Handle(BOPInt_Context)> BOPAlgo_PVECnt; Handle(IntTools_Context)> BOPAlgo_PVECnt;
///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
//======================================================================= //=======================================================================
// function: PerformEE // function: PerformEE
@ -394,20 +394,20 @@ void BOPAlgo_PaveFiller::PerformEE()
TopoDS_Vertex aVnew; TopoDS_Vertex aVnew;
IntTools_Range aCR1, aCR2; IntTools_Range aCR1, aCR2;
// //
BOPInt_Tools::VertexParameters(aCPart, aT1, aT2); IntTools_Tools::VertexParameters(aCPart, aT1, aT2);
aTol = Precision::Confusion(); aTol = Precision::Confusion();
aCR1 = aCPart.Range1(); aCR1 = aCPart.Range1();
aCR2 = aCPart.Ranges2()(1); aCR2 = aCPart.Ranges2()(1);
// //
//decide to keep the pave or not //decide to keep the pave or not
bIsOnPave[0] = BOPInt_Tools::IsOnPave1(aT1, aR11, aTol) || bIsOnPave[0] = IntTools_Tools::IsOnPave1(aT1, aR11, aTol) ||
BOPInt_Tools::IsOnPave1(aR11.First(), aCR1, aTol); IntTools_Tools::IsOnPave1(aR11.First(), aCR1, aTol);
bIsOnPave[1] = BOPInt_Tools::IsOnPave1(aT1, aR12, aTol) || bIsOnPave[1] = IntTools_Tools::IsOnPave1(aT1, aR12, aTol) ||
BOPInt_Tools::IsOnPave1(aR12.Last(), aCR1, aTol); IntTools_Tools::IsOnPave1(aR12.Last(), aCR1, aTol);
bIsOnPave[2] = BOPInt_Tools::IsOnPave1(aT2, aR21, aTol) || bIsOnPave[2] = IntTools_Tools::IsOnPave1(aT2, aR21, aTol) ||
BOPInt_Tools::IsOnPave1(aR21.First(), aCR2, aTol); IntTools_Tools::IsOnPave1(aR21.First(), aCR2, aTol);
bIsOnPave[3] = BOPInt_Tools::IsOnPave1(aT2, aR22, aTol) || bIsOnPave[3] = IntTools_Tools::IsOnPave1(aT2, aR22, aTol) ||
BOPInt_Tools::IsOnPave1(aR22.Last(), aCR2, aTol); IntTools_Tools::IsOnPave1(aR22.Last(), aCR2, aTol);
// //
aPB1->Indices(nV[0], nV[1]); aPB1->Indices(nV[0], nV[1]);
aPB2->Indices(nV[2], nV[3]); aPB2->Indices(nV[2], nV[3]);
@ -824,7 +824,7 @@ void BOPAlgo_PaveFiller::FillShrunkData(Handle(BOPDS_PaveBlock)& thePB)
{ {
Standard_Integer nE, nV1, nV2, iErr; Standard_Integer nE, nV1, nV2, iErr;
Standard_Real aT1, aT2, aTS1, aTS2; Standard_Real aT1, aT2, aTS1, aTS2;
BOPInt_ShrunkRange aSR; IntTools_ShrunkRange aSR;
// //
myErrorStatus=0; myErrorStatus=0;
myWarningStatus = 0; myWarningStatus = 0;

14
src/BOPAlgo/BOPAlgo_PaveFiller_4.cxx
View File

@ -29,7 +29,7 @@
#include <BOPCol_NCVector.hxx> #include <BOPCol_NCVector.hxx>
#include <BOPCol_TBB.hxx> #include <BOPCol_TBB.hxx>
// //
#include <BOPInt_Context.hxx> #include <IntTools_Context.hxx>
// //
#include <BOPDS_Iterator.hxx> #include <BOPDS_Iterator.hxx>
#include <BOPDS_VectorOfInterfVF.hxx> #include <BOPDS_VectorOfInterfVF.hxx>
@ -94,11 +94,11 @@ class BOPAlgo_VertexFace {
aT2=myT2; aT2=myT2;
} }
// //
void SetContext(const Handle(BOPInt_Context)& aContext) { void SetContext(const Handle(IntTools_Context)& aContext) {
myContext=aContext; myContext=aContext;
} }
// //
const Handle(BOPInt_Context)& Context()const { const Handle(IntTools_Context)& Context()const {
return myContext; return myContext;
} }
// //
@ -115,7 +115,7 @@ class BOPAlgo_VertexFace {
Standard_Real myT2; Standard_Real myT2;
TopoDS_Vertex myV; TopoDS_Vertex myV;
TopoDS_Face myF; TopoDS_Face myF;
Handle(BOPInt_Context) myContext; Handle(IntTools_Context) myContext;
}; };
//======================================================================= //=======================================================================
typedef BOPCol_NCVector<BOPAlgo_VertexFace> typedef BOPCol_NCVector<BOPAlgo_VertexFace>
@ -124,13 +124,13 @@ typedef BOPCol_NCVector<BOPAlgo_VertexFace>
typedef BOPCol_TBBContextFunctor typedef BOPCol_TBBContextFunctor
<BOPAlgo_VertexFace, <BOPAlgo_VertexFace,
BOPAlgo_VectorOfVertexFace, BOPAlgo_VectorOfVertexFace,
Handle(BOPInt_Context), Handle(IntTools_Context),
BOPInt_Context> BOPAlgo_VertexFaceFunctor; IntTools_Context> BOPAlgo_VertexFaceFunctor;
// //
typedef BOPCol_TBBContextCnt typedef BOPCol_TBBContextCnt
<BOPAlgo_VertexFaceFunctor, <BOPAlgo_VertexFaceFunctor,
BOPAlgo_VectorOfVertexFace, BOPAlgo_VectorOfVertexFace,
Handle(BOPInt_Context)> BOPAlgo_VertexFaceCnt; Handle(IntTools_Context)> BOPAlgo_VertexFaceCnt;
// //
//======================================================================= //=======================================================================
// function: PerformVF // function: PerformVF

16
src/BOPAlgo/BOPAlgo_PaveFiller_5.cxx
View File

@ -40,8 +40,8 @@
#include <BOPCol_NCVector.hxx> #include <BOPCol_NCVector.hxx>
#include <BOPCol_TBB.hxx> #include <BOPCol_TBB.hxx>
// //
#include <BOPInt_Context.hxx> #include <IntTools_Context.hxx>
#include <BOPInt_Tools.hxx> #include <IntTools_Tools.hxx>
// //
#include <BOPDS_Interf.hxx> #include <BOPDS_Interf.hxx>
#include <BOPDS_Iterator.hxx> #include <BOPDS_Iterator.hxx>
@ -110,13 +110,13 @@ typedef BOPCol_NCVector<BOPAlgo_EdgeFace> BOPAlgo_VectorOfEdgeFace;
typedef BOPCol_TBBContextFunctor typedef BOPCol_TBBContextFunctor
<BOPAlgo_EdgeFace, <BOPAlgo_EdgeFace,
BOPAlgo_VectorOfEdgeFace, BOPAlgo_VectorOfEdgeFace,
Handle(BOPInt_Context), Handle(IntTools_Context),
BOPInt_Context> BOPAlgo_EdgeFaceFunctor; IntTools_Context> BOPAlgo_EdgeFaceFunctor;
// //
typedef BOPCol_TBBContextCnt typedef BOPCol_TBBContextCnt
<BOPAlgo_EdgeFaceFunctor, <BOPAlgo_EdgeFaceFunctor,
BOPAlgo_VectorOfEdgeFace, BOPAlgo_VectorOfEdgeFace,
Handle(BOPInt_Context)> BOPAlgo_EdgeFaceCnt; Handle(IntTools_Context)> BOPAlgo_EdgeFaceCnt;
// //
//======================================================================= //=======================================================================
//function : PerformEF //function : PerformEF
@ -270,7 +270,7 @@ void BOPAlgo_PaveFiller::PerformEF()
Standard_Real aT, aTolToDecide; Standard_Real aT, aTolToDecide;
TopoDS_Vertex aVnew; TopoDS_Vertex aVnew;
// //
BOPInt_Tools::VertexParameter(aCPart, aT); IntTools_Tools::VertexParameter(aCPart, aT);
BOPTools_AlgoTools::MakeNewVertex(aE, aT, aF, aVnew); BOPTools_AlgoTools::MakeNewVertex(aE, aT, aF, aVnew);
// //
const IntTools_Range& aR=aCPart.Range1(); const IntTools_Range& aR=aCPart.Range1();
@ -278,8 +278,8 @@ void BOPAlgo_PaveFiller::PerformEF()
// //
IntTools_Range aR1(aT1,anewSR.First()),aR2(anewSR.Last(), aT2); IntTools_Range aR1(aT1,anewSR.First()),aR2(anewSR.Last(), aT2);
// //
bIsOnPave[0]=BOPInt_Tools::IsInRange(aR1, aR, aTolToDecide); bIsOnPave[0]=IntTools_Tools::IsInRange(aR1, aR, aTolToDecide);
bIsOnPave[1]=BOPInt_Tools::IsInRange(aR2, aR, aTolToDecide); bIsOnPave[1]=IntTools_Tools::IsInRange(aR2, aR, aTolToDecide);
// //
if (bIsOnPave[0] && bIsOnPave[1]) { if (bIsOnPave[0] && bIsOnPave[1]) {
bV[0]=CheckFacePaves(nV[0], aMIFOn, aMIFIn); bV[0]=CheckFacePaves(nV[0], aMIFOn, aMIFIn);

8
src/BOPAlgo/BOPAlgo_PaveFiller_6.cxx
View File

@ -65,8 +65,8 @@
#include <BOPCol_NCVector.hxx> #include <BOPCol_NCVector.hxx>
#include <BOPCol_TBB.hxx> #include <BOPCol_TBB.hxx>
#include <BOPInt_Context.hxx> #include <IntTools_Context.hxx>
#include <BOPInt_Tools.hxx> #include <IntTools_Tools.hxx>
#include <BOPDS_Interf.hxx> #include <BOPDS_Interf.hxx>
#include <BOPDS_Iterator.hxx> #include <BOPDS_Iterator.hxx>
@ -89,7 +89,7 @@
#include <BOPAlgo_Tools.hxx> #include <BOPAlgo_Tools.hxx>
#include <BRepBuilderAPI_MakeVertex.hxx> #include <BRepBuilderAPI_MakeVertex.hxx>
#include <TopExp.hxx> #include <TopExp.hxx>
#include <BOPInt_ShrunkRange.hxx> #include <IntTools_ShrunkRange.hxx>
#include <BOPDS_DataMapOfPaveBlockListOfPaveBlock.hxx> #include <BOPDS_DataMapOfPaveBlockListOfPaveBlock.hxx>
static void ToleranceFF(const BRepAdaptor_Surface& aBAS1, static void ToleranceFF(const BRepAdaptor_Surface& aBAS1,
@ -313,7 +313,7 @@ void BOPAlgo_PaveFiller::PerformFF()
// //
const IntTools_Curve& aIC=aCvsX(i); const IntTools_Curve& aIC=aCvsX(i);
const Handle(Geom_Curve)& aC3D= aIC.Curve(); const Handle(Geom_Curve)& aC3D= aIC.Curve();
bValid=BOPInt_Tools::CheckCurve(aC3D, aTolR3D, aBox); bValid=IntTools_Tools::CheckCurve(aC3D, aTolR3D, aBox);
if (bValid) { if (bValid) {
iC=aVNC.Append()-1; iC=aVNC.Append()-1;
BOPDS_Curve& aNC=aVNC(iC); BOPDS_Curve& aNC=aVNC(iC);

14
src/BOPAlgo/BOPAlgo_PaveFiller_9.cxx
View File

@ -28,16 +28,16 @@
#include <BOPDS_Iterator.hxx> #include <BOPDS_Iterator.hxx>
#include <BOPDS_ListOfPaveBlock.hxx> #include <BOPDS_ListOfPaveBlock.hxx>
#include <BOPInt_ShrunkRange.hxx> #include <IntTools_ShrunkRange.hxx>
//======================================================================= //=======================================================================
//class : BOPAlgo_ShrunkRange //class : BOPAlgo_ShrunkRange
//purpose : //purpose :
//======================================================================= //=======================================================================
class BOPAlgo_ShrunkRange : public BOPInt_ShrunkRange { class BOPAlgo_ShrunkRange : public IntTools_ShrunkRange {
public: public:
BOPAlgo_ShrunkRange() BOPAlgo_ShrunkRange()
: BOPInt_ShrunkRange(), : IntTools_ShrunkRange(),
myWarningStatus(0) { myWarningStatus(0) {
} }
// //
@ -56,7 +56,7 @@ class BOPAlgo_ShrunkRange : public BOPInt_ShrunkRange {
// //
myWarningStatus=0; myWarningStatus=0;
// //
BOPInt_ShrunkRange::Perform(); IntTools_ShrunkRange::Perform();
if (myErrorStatus) { if (myErrorStatus) {
myWarningStatus=1; myWarningStatus=1;
} }
@ -78,13 +78,13 @@ typedef BOPCol_NCVector
typedef BOPCol_TBBContextFunctor typedef BOPCol_TBBContextFunctor
<BOPAlgo_ShrunkRange, <BOPAlgo_ShrunkRange,
BOPAlgo_VectorOfShrunkRange, BOPAlgo_VectorOfShrunkRange,
Handle(BOPInt_Context), Handle(IntTools_Context),
BOPInt_Context> BOPAlgo_ShrunkRangeFunctor; IntTools_Context> BOPAlgo_ShrunkRangeFunctor;
// //
typedef BOPCol_TBBContextCnt typedef BOPCol_TBBContextCnt
<BOPAlgo_ShrunkRangeFunctor, <BOPAlgo_ShrunkRangeFunctor,
BOPAlgo_VectorOfShrunkRange, BOPAlgo_VectorOfShrunkRange,
Handle(BOPInt_Context)> BOPAlgo_ShrunkRangeCnt; Handle(IntTools_Context)> BOPAlgo_ShrunkRangeCnt;
// //
//======================================================================= //=======================================================================
// function: FillShrunkData // function: FillShrunkData

4
src/BOPAlgo/BOPAlgo_ShellSplitter.cxx
View File

@ -32,7 +32,7 @@
#include <BOPCol_NCVector.hxx> #include <BOPCol_NCVector.hxx>
#include <BOPCol_IndexedDataMapOfShapeListOfShape.hxx> #include <BOPCol_IndexedDataMapOfShapeListOfShape.hxx>
// //
#include <BOPInt_Context.hxx> #include <IntTools_Context.hxx>
// //
#include <BOPTools.hxx> #include <BOPTools.hxx>
#include <BOPTools_AlgoTools.hxx> #include <BOPTools_AlgoTools.hxx>
@ -320,7 +320,7 @@ void BOPAlgo_ShellSplitter::SplitBlock(BOPTools_ConnexityBlock& aCB)
BOPCol_MapOfOrientedShape AddedFacesMap; BOPCol_MapOfOrientedShape AddedFacesMap;
BOPCol_IndexedDataMapOfShapeListOfShape aEFMap, aMEFP; BOPCol_IndexedDataMapOfShapeListOfShape aEFMap, aMEFP;
// //
Handle (BOPInt_Context) aContext=new BOPInt_Context; Handle (IntTools_Context) aContext=new IntTools_Context;
// //
const BOPCol_ListOfShape& myShapes=aCB.Shapes(); const BOPCol_ListOfShape& myShapes=aCB.Shapes();
// //

46
src/BOPInt/BOPInt.cdl
View File

@ -1,46 +0,0 @@
-- 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.
package BOPInt
---Purpose:
uses
gp,
Bnd,
TopAbs,
Geom,
GeomAPI,
Geom2dHatch,
BRepClass3d,
TopoDS,
TopTools,
IntTools,
--
BOPCol
is
--
-- classes
--
class Context;
--class Range;
class ShrunkRange;
class Tools;
--
-- pointers
--
end BOPInt;

84
src/BOPInt/BOPInt_Tools.cdl
View File

@ -1,84 +0,0 @@
-- 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.
class Tools from BOPInt
---Purpose:
uses
Box from Bnd,
Lin from gp,
Pln from gp,
Pnt from gp,
Curve from Geom,
Edge from TopoDS,
Face from TopoDS,
Range from IntTools,
CommonPrt from IntTools
--raises
is
CheckCurve(myclass;
theC:Curve from Geom;
theTol:Real from Standard;
theBox:out Box from Bnd)
returns Boolean from Standard;
IsOnPave(myclass;
theT:Real from Standard;
theRange:Range from IntTools;
theTol: Real from Standard)
returns Boolean from Standard;
VertexParameters(myclass;
theCP:CommonPrt from IntTools;
theT1:out Real from Standard;
theT2:out Real from Standard);
VertexParameter(myclass;
theCP:CommonPrt from IntTools;
theT:out Real from Standard);
IsOnPave1(myclass;
theT:Real from Standard;
theRange:Range from IntTools;
theTol: Real from Standard)
returns Boolean from Standard;
IsInRange(myclass;
theRRef : Range from IntTools;
theR : Range from IntTools;
theTol : Real from Standard)
returns Boolean from Standard;
---Purpose: Checks if the range <theR> interfere with the range <theRRef>
SegPln(myclass;
theLin : Lin from gp;
theTLin1 : Real from Standard;
theTLin2 : Real from Standard;
theTolLin: Real from Standard;
thePln : Pln from gp;
theTolPln: Real from Standard;
theP :out Pnt from gp;
theT :out Real from Standard;
theTolP :out Real from Standard;
theTmin :out Real from Standard;
theTmax :out Real from Standard)
returns Integer from Standard;
--fields
end Tools;

218
src/BOPInt/BOPInt_Tools.cxx
View File

@ -1,218 +0,0 @@
// 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 <BOPInt_Tools.ixx>
#include <gp_Pnt.hxx>
#include <BndLib_Add3dCurve.hxx>
#include <Bnd_Box.hxx>
#include <Geom_Curve.hxx>
#include <GeomAdaptor_Curve.hxx>
//=======================================================================
//function : CheckCurve
//purpose :
//=======================================================================
Standard_Boolean BOPInt_Tools::CheckCurve(const Handle (Geom_Curve)& aC3D,
const Standard_Real aTolR3D,
Bnd_Box& aBox)
{
Standard_Boolean bRet;
Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax, dX, dY, dZ;
Standard_Real dS, aTol;
GeomAdaptor_Curve aGAC;
//
aGAC.Load(aC3D);
BndLib_Add3dCurve::Add(aGAC, aTolR3D, aBox);
// 910/B1
aBox.Get(aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
dX=aXmax-aXmin;
dY=aYmax-aYmin;
dZ=aZmax-aZmin;
dS=1.e-12;
aTol=2.*aTolR3D+dS;
bRet=(dX>aTol || dY>aTol || dZ>aTol);
//
return bRet;
}
//=======================================================================
//function : IsOnPave
//purpose :
//=======================================================================
Standard_Boolean BOPInt_Tools::IsOnPave(const Standard_Real aT1,
const IntTools_Range& aRange,
const Standard_Real aTolerance)
{
Standard_Boolean firstisonpave1, firstisonpave2, bIsOnPave;
//
firstisonpave1 = (Abs(aRange.First() - aT1) < aTolerance);
firstisonpave2 = (Abs(aRange.Last() - aT1) < aTolerance);
bIsOnPave=(firstisonpave1 || firstisonpave2);
return bIsOnPave;
}
//=======================================================================
// function: VertexParameters
// purpose:
//=======================================================================
void BOPInt_Tools::VertexParameters(const IntTools_CommonPrt& aCPart,
Standard_Real& aT1,
Standard_Real& aT2)
{
const IntTools_Range& aR1=aCPart.Range1();
aT1=0.5*(aR1.First()+aR1.Last());
//
if((aCPart.VertexParameter1() >= aR1.First()) &&
(aCPart.VertexParameter1() <= aR1.Last())) {
aT1 = aCPart.VertexParameter1();
}
//
const IntTools_SequenceOfRanges& aRanges2=aCPart.Ranges2();
const IntTools_Range& aR2=aRanges2(1);
aT2=0.5*(aR2.First()+aR2.Last());
//
if((aCPart.VertexParameter2() >= aR2.First()) &&
(aCPart.VertexParameter2() <= aR2.Last())) {
aT2 = aCPart.VertexParameter2();
}
}
//=======================================================================
// function: VertexParameter
// purpose:
//=======================================================================
void BOPInt_Tools::VertexParameter(const IntTools_CommonPrt& aCPart,
Standard_Real& aT)
{
const IntTools_Range& aR=aCPart.Range1();
aT=0.5*(aR.First()+aR.Last());
if((aCPart.VertexParameter1() >= aR.First()) &&
(aCPart.VertexParameter1() <= aR.Last())) {
aT = aCPart.VertexParameter1();
}
}
//=======================================================================
// function: IsOnPave1
// purpose:
//=======================================================================
Standard_Boolean BOPInt_Tools::IsOnPave1(const Standard_Real aTR,
const IntTools_Range& aCPRange,
const Standard_Real aTolerance)
{
Standard_Boolean bIsOnPave;
Standard_Real aT1, aT2, dT1, dT2;
//
aT1=aCPRange.First();
aT2=aCPRange.Last();
bIsOnPave=(aTR>=aT1 && aTR<=aT1);
if (bIsOnPave) {
return bIsOnPave;
}
//
dT1=Abs(aTR-aT1);
dT2=Abs(aTR-aT2);
bIsOnPave=(dT1<=aTolerance || dT2<=aTolerance);
return bIsOnPave;
}
//=======================================================================
// function: IsInRange
// purpose:
//=======================================================================
Standard_Boolean BOPInt_Tools::IsInRange(const IntTools_Range& aRRef,
const IntTools_Range& aR,
const Standard_Real aTolerance)
{
Standard_Boolean bIsIn;
Standard_Real aT1, aT2, aTRef1, aTRef2;
//
aR.Range(aT1, aT2);
aRRef.Range(aTRef1, aTRef2);
//
aTRef1-=aTolerance;
aTRef2+=aTolerance;
//
bIsIn = (aT1>=aTRef1 && aT1<=aTRef2) ||
(aT2>=aTRef1 && aT2<=aTRef2);
//
return bIsIn;
}
//=======================================================================
//function : SegPln
//purpose :
//=======================================================================
Standard_Integer BOPInt_Tools::SegPln(const gp_Lin& theLin,
const Standard_Real theTLin1,
const Standard_Real theTLin2,
const Standard_Real theTolLin,
const gp_Pln& thePln,
const Standard_Real theTolPln,
gp_Pnt& theP,
Standard_Real& theTP,
Standard_Real& theTolP,
Standard_Real& theTPmin,
Standard_Real& theTPmax)
{
Standard_Integer iRet;
Standard_Real aTol, aA, aB, aC, aD, aE, aH, aTP, aDist1, aDist2;
gp_Pnt aP1, aP2;
//
iRet=0;
aTol=theTolLin+theTolPln;
//
const gp_Ax3& aPosPln=thePln.Position();
const gp_Dir& aDirPln=aPosPln.Direction();
const gp_Pnt& aLocPln=aPosPln.Location();
//
const gp_Dir& aDirLin=theLin.Direction();
const gp_Pnt& aLocLin=theLin.Location();
//
aP1.SetXYZ(aLocLin.XYZ()+theTLin1*aDirLin.XYZ());
aDist1=aDirPln.X()*(aP1.X()-aLocPln.X())+
aDirPln.Y()*(aP1.Y()-aLocPln.Y())+
aDirPln.Z()*(aP1.Z()-aLocPln.Z());
//
aP2.SetXYZ(aLocLin.XYZ()+theTLin2*aDirLin.XYZ());
aDist2=aDirPln.X()*(aP2.X()-aLocPln.X())+
aDirPln.Y()*(aP2.Y()-aLocPln.Y())+
aDirPln.Z()*(aP2.Z()-aLocPln.Z());
//
if (aDist1<aTol && aDist2<aTol){
iRet=1; // common block
return iRet;
}
//
if (aDist1*aDist2 > 0.) {
iRet=2; // segment lays on one side to the Plane
return iRet;
}
//
thePln.Coefficients(aA, aB, aC, aD);
aE=aA*aLocLin.X()+aB*aLocLin.Y()+aC*aLocLin.Z()+aD;
aH=aA*aDirLin.X()+aB*aDirLin.Y()+aC*aDirLin.Z();
aTP=-aE/aH;
if (aTP < theTLin1-aTol || aTP > theTLin2+aTol) {
iRet=3; // no intersections due to range of the Line
return iRet;
}
//
theTP=aTP;
theP.SetXYZ(aLocLin.XYZ()+aTP*aDirLin.XYZ());
theTolP=aTol;
theTPmin=theTP-theTolPln;
theTPmax=theTP+theTolPln;
iRet=0; // intersection point
return iRet;
}

3
src/BOPTools/BOPTools.cdl
View File

@ -29,8 +29,7 @@ uses
IntTools, IntTools,
ProjLib, ProjLib,
-- --
BOPCol, BOPCol
BOPInt
is is
-- --

34
src/BOPTools/BOPTools_AlgoTools.cdl
View File

@ -38,7 +38,7 @@ uses
ListOfShape from BOPCol, ListOfShape from BOPCol,
IndexedMapOfShape from BOPCol, IndexedMapOfShape from BOPCol,
IndexedDataMapOfShapeListOfShape from BOPCol, IndexedDataMapOfShapeListOfShape from BOPCol,
Context from BOPInt, Context from IntTools,
ListOfCoupleOfShape from BOPTools, ListOfCoupleOfShape from BOPTools,
Range from IntTools Range from IntTools
@ -90,7 +90,7 @@ is
IsSplitToReverse(myclass; IsSplitToReverse(myclass;
theSplit : Shape from TopoDS; theSplit : Shape from TopoDS;
theShape : Shape from TopoDS; theShape : Shape from TopoDS;
theContext:out Context from BOPInt) theContext:out Context from IntTools)
---Purpose: Returns True if the shape theSplit has opposite ---Purpose: Returns True if the shape theSplit has opposite
-- direction than theShape -- direction than theShape
-- theContext - cashed geometrical tools -- theContext - cashed geometrical tools
@ -99,7 +99,7 @@ is
IsSplitToReverse(myclass; IsSplitToReverse(myclass;
theSplit : Face from TopoDS; theSplit : Face from TopoDS;
theShape : Face from TopoDS; theShape : Face from TopoDS;
theContext:out Context from BOPInt) theContext:out Context from IntTools)
---Purpose: Returns True if normal direction of the face ---Purpose: Returns True if normal direction of the face
-- theShape is not the same as for the face -- theShape is not the same as for the face
-- theSplit -- theSplit
@ -109,20 +109,20 @@ is
IsSplitToReverse (myclass; IsSplitToReverse (myclass;
aE1: Edge from TopoDS; aE1: Edge from TopoDS;
aE2: Edge from TopoDS; aE2: Edge from TopoDS;
aContext:out Context from BOPInt) aContext:out Context from IntTools)
returns Boolean from Standard; returns Boolean from Standard;
AreFacesSameDomain(myclass; AreFacesSameDomain(myclass;
theF1: Face from TopoDS; theF1: Face from TopoDS;
theF2: Face from TopoDS; theF2: Face from TopoDS;
theContext:out Context from BOPInt) theContext:out Context from IntTools)
returns Boolean from Standard; returns Boolean from Standard;
CheckSameGeom (myclass; CheckSameGeom (myclass;
theF1: Face from TopoDS; theF1: Face from TopoDS;
theF2: Face from TopoDS; theF2: Face from TopoDS;
theContext:out Context from BOPInt) theContext:out Context from IntTools)
returns Boolean from Standard; returns Boolean from Standard;
Sense (myclass; Sense (myclass;
@ -145,7 +145,7 @@ is
theFace :Face from TopoDS; theFace :Face from TopoDS;
theLCEF :out ListOfCoupleOfShape from BOPTools; theLCEF :out ListOfCoupleOfShape from BOPTools;
theFaceOff :out Face from TopoDS; theFaceOff :out Face from TopoDS;
theContext :out Context from BOPInt) theContext :out Context from IntTools)
returns Boolean from Standard; returns Boolean from Standard;
---Purpose: For the face theFace and its edge theEdge ---Purpose: For the face theFace and its edge theEdge
@ -158,7 +158,7 @@ is
theEdge :Edge from TopoDS; theEdge :Edge from TopoDS;
theFace1 :Face from TopoDS; theFace1 :Face from TopoDS;
theFace2 :Face from TopoDS; theFace2 :Face from TopoDS;
theContext:out Context from BOPInt) theContext:out Context from IntTools)
---Purpose: Returns True if the face theFace is inside of the ---Purpose: Returns True if the face theFace is inside of the
-- couple of faces theFace1, theFace2. -- couple of faces theFace1, theFace2.
-- The faces theFace, theFace1, theFace2 must -- The faces theFace, theFace1, theFace2 must
@ -169,7 +169,7 @@ is
theFace :Face from TopoDS; theFace :Face from TopoDS;
theEdge :Edge from TopoDS; theEdge :Edge from TopoDS;
theLF :out ListOfShape from BOPCol; theLF :out ListOfShape from BOPCol;
theContext:out Context from BOPInt) theContext:out Context from IntTools)
---Purpose: Returns True if the face theFace is inside of the ---Purpose: Returns True if the face theFace is inside of the
-- appropriate couple of faces (from the set theLF) . -- appropriate couple of faces (from the set theLF) .
-- The faces of the set theLF and theFace must -- The faces of the set theLF and theFace must
@ -181,7 +181,7 @@ is
theSolid :Solid from TopoDS; theSolid :Solid from TopoDS;
theMEF :out IndexedDataMapOfShapeListOfShape from BOPCol; theMEF :out IndexedDataMapOfShapeListOfShape from BOPCol;
theTol :Real from Standard; theTol :Real from Standard;
theContext:out Context from BOPInt) theContext:out Context from IntTools)
---Purpose: Returns True if the face theFace is inside the ---Purpose: Returns True if the face theFace is inside the
-- solid theSolid. -- solid theSolid.
-- theMEF - Map Edge/Faces for theSolid -- theMEF - Map Edge/Faces for theSolid
@ -204,7 +204,7 @@ is
thePoint :Pnt from gp; thePoint :Pnt from gp;
theSolid :Solid from TopoDS; theSolid :Solid from TopoDS;
theTol :Real from Standard; theTol :Real from Standard;
theContext:out Context from BOPInt) theContext:out Context from IntTools)
---Purpose: Computes the 3-D state of the point thePoint ---Purpose: Computes the 3-D state of the point thePoint
-- toward solid theSolid. -- toward solid theSolid.
-- theTol - value of precision of computation -- theTol - value of precision of computation
@ -216,7 +216,7 @@ is
theVertex:Vertex from TopoDS; theVertex:Vertex from TopoDS;
theSolid :Solid from TopoDS; theSolid :Solid from TopoDS;
theTol :Real from Standard; theTol :Real from Standard;
theContext:out Context from BOPInt) theContext:out Context from IntTools)
---Purpose: Computes the 3-D state of the vertex theVertex ---Purpose: Computes the 3-D state of the vertex theVertex
-- toward solid theSolid. -- toward solid theSolid.
-- theTol - value of precision of computation -- theTol - value of precision of computation
@ -228,7 +228,7 @@ is
theEdge :Edge from TopoDS; theEdge :Edge from TopoDS;
theSolid :Solid from TopoDS; theSolid :Solid from TopoDS;
theTol :Real from Standard; theTol :Real from Standard;
theContext:out Context from BOPInt) theContext:out Context from IntTools)
---Purpose: Computes the 3-D state of the edge theEdge ---Purpose: Computes the 3-D state of the edge theEdge
-- toward solid theSolid. -- toward solid theSolid.
-- theTol - value of precision of computation -- theTol - value of precision of computation
@ -241,7 +241,7 @@ is
theSolid :Solid from TopoDS; theSolid :Solid from TopoDS;
theTol :Real from Standard; theTol :Real from Standard;
theBounds:out IndexedMapOfShape from BOPCol; theBounds:out IndexedMapOfShape from BOPCol;
theContext:out Context from BOPInt) theContext:out Context from IntTools)
---Purpose: Computes the 3-D state of the face theFace ---Purpose: Computes the 3-D state of the face theFace
-- toward solid theSolid. -- toward solid theSolid.
-- theTol - value of precision of computation -- theTol - value of precision of computation
@ -254,7 +254,7 @@ is
theShape :Shape from TopoDS; theShape :Shape from TopoDS;
theSolid :Solid from TopoDS; theSolid :Solid from TopoDS;
theTol :Real from Standard; theTol :Real from Standard;
theContext:out Context from BOPInt) theContext:out Context from IntTools)
---Purpose: Computes the 3-D state of the shape theShape ---Purpose: Computes the 3-D state of the shape theShape
-- toward solid theSolid. -- toward solid theSolid.
-- theTol - value of precision of computation -- theTol - value of precision of computation
@ -426,7 +426,7 @@ is
aShR : Range from IntTools; aShR : Range from IntTools;
aF : Face from TopoDS; aF : Face from TopoDS;
aE : Edge from TopoDS; aE : Edge from TopoDS;
aContext:out Context from BOPInt) aContext:out Context from IntTools)
returns Boolean from Standard; returns Boolean from Standard;
---Purpose: ---Purpose:
--- Returns TRUE if PaveBlock <aPB> lays on the face <aF>, i.e --- Returns TRUE if PaveBlock <aPB> lays on the face <aF>, i.e
@ -434,7 +434,7 @@ is
IsMicroEdge(myclass; IsMicroEdge(myclass;
theEdge : Edge from TopoDS; theEdge : Edge from TopoDS;
theContext : Context from BOPInt) theContext : Context from IntTools)
returns Boolean from Standard; returns Boolean from Standard;
---Purpose: ---Purpose:
--- Checks if it is possible to compute shrunk range for the edge <aE>. --- Checks if it is possible to compute shrunk range for the edge <aE>.

48
src/BOPTools/BOPTools_AlgoTools.cxx
View File

@ -64,7 +64,7 @@
#include <BOPCol_IndexedMapOfShape.hxx> #include <BOPCol_IndexedMapOfShape.hxx>
#include <BOPCol_MapOfShape.hxx> #include <BOPCol_MapOfShape.hxx>
// //
#include <BOPInt_ShrunkRange.hxx> #include <IntTools_ShrunkRange.hxx>
// //
static static
@ -76,7 +76,7 @@ static
Standard_Boolean FindFacePairs (const TopoDS_Edge& theE, Standard_Boolean FindFacePairs (const TopoDS_Edge& theE,
const BOPCol_ListOfShape& thLF, const BOPCol_ListOfShape& thLF,
BOPTools_ListOfCoupleOfShape& theLCFF, BOPTools_ListOfCoupleOfShape& theLCFF,
Handle(BOPInt_Context)& theContext); Handle(IntTools_Context)& theContext);
static static
TopAbs_Orientation Orientation(const TopoDS_Edge& anE, TopAbs_Orientation Orientation(const TopoDS_Edge& anE,
const TopoDS_Face& aF); const TopoDS_Face& aF);
@ -89,7 +89,7 @@ static
const gp_Dir& aDTgt, const gp_Dir& aDTgt,
gp_Dir& aDN, gp_Dir& aDN,
gp_Dir& aDB, gp_Dir& aDB,
Handle(BOPInt_Context)& theContext, Handle(IntTools_Context)& theContext,
GeomAPI_ProjectPointOnSurf& aProjPL, GeomAPI_ProjectPointOnSurf& aProjPL,
const Standard_Real aDt); const Standard_Real aDt);
static static
@ -97,7 +97,7 @@ static
const gp_Pnt& aP, const gp_Pnt& aP,
gp_Dir& aDB, gp_Dir& aDB,
gp_Pnt& aPOut, gp_Pnt& aPOut,
Handle(BOPInt_Context)& theContext, Handle(IntTools_Context)& theContext,
GeomAPI_ProjectPointOnSurf& aProjPL, GeomAPI_ProjectPointOnSurf& aProjPL,
const Standard_Real aDt); const Standard_Real aDt);
static static
@ -432,7 +432,7 @@ TopAbs_State BOPTools_AlgoTools::ComputeStateByOnePoint
(const TopoDS_Shape& theS, (const TopoDS_Shape& theS,
const TopoDS_Solid& theRef, const TopoDS_Solid& theRef,
const Standard_Real theTol, const Standard_Real theTol,
Handle(BOPInt_Context)& theContext) Handle(IntTools_Context)& theContext)
{ {
TopAbs_State aState; TopAbs_State aState;
TopAbs_ShapeEnum aType; TopAbs_ShapeEnum aType;
@ -459,7 +459,7 @@ TopAbs_State BOPTools_AlgoTools::ComputeState
const TopoDS_Solid& theRef, const TopoDS_Solid& theRef,
const Standard_Real theTol, const Standard_Real theTol,
BOPCol_IndexedMapOfShape& theBounds, BOPCol_IndexedMapOfShape& theBounds,
Handle(BOPInt_Context)& theContext) Handle(IntTools_Context)& theContext)
{ {
TopAbs_State aState; TopAbs_State aState;
TopExp_Explorer aExp; TopExp_Explorer aExp;
@ -504,7 +504,7 @@ TopAbs_State BOPTools_AlgoTools::ComputeState
(const TopoDS_Vertex& theV, (const TopoDS_Vertex& theV,
const TopoDS_Solid& theRef, const TopoDS_Solid& theRef,
const Standard_Real theTol, const Standard_Real theTol,
Handle(BOPInt_Context)& theContext) Handle(IntTools_Context)& theContext)
{ {
TopAbs_State aState; TopAbs_State aState;
gp_Pnt aP3D; gp_Pnt aP3D;
@ -522,7 +522,7 @@ TopAbs_State BOPTools_AlgoTools::ComputeState
(const TopoDS_Edge& theE, (const TopoDS_Edge& theE,
const TopoDS_Solid& theRef, const TopoDS_Solid& theRef,
const Standard_Real theTol, const Standard_Real theTol,
Handle(BOPInt_Context)& theContext) Handle(IntTools_Context)& theContext)
{ {
Standard_Real aT1, aT2, aT = 0.; Standard_Real aT1, aT2, aT = 0.;
TopAbs_State aState; TopAbs_State aState;
@ -574,7 +574,7 @@ TopAbs_State BOPTools_AlgoTools::ComputeState
(const gp_Pnt& theP, (const gp_Pnt& theP,
const TopoDS_Solid& theRef, const TopoDS_Solid& theRef,
const Standard_Real theTol, const Standard_Real theTol,
Handle(BOPInt_Context)& theContext) Handle(IntTools_Context)& theContext)
{ {
TopAbs_State aState; TopAbs_State aState;
// //
@ -594,7 +594,7 @@ Standard_Integer BOPTools_AlgoTools::IsInternalFace
const TopoDS_Solid& theSolid, const TopoDS_Solid& theSolid,
BOPCol_IndexedDataMapOfShapeListOfShape& theMEF, BOPCol_IndexedDataMapOfShapeListOfShape& theMEF,
const Standard_Real theTol, const Standard_Real theTol,
Handle(BOPInt_Context)& theContext) Handle(IntTools_Context)& theContext)
{ {
Standard_Boolean bDegenerated; Standard_Boolean bDegenerated;
Standard_Integer aNbF, iRet, iFound; Standard_Integer aNbF, iRet, iFound;
@ -709,7 +709,7 @@ Standard_Integer BOPTools_AlgoTools::IsInternalFace
(const TopoDS_Face& theFace, (const TopoDS_Face& theFace,
const TopoDS_Edge& theEdge, const TopoDS_Edge& theEdge,
BOPCol_ListOfShape& theLF, BOPCol_ListOfShape& theLF,
Handle(BOPInt_Context)& theContext) Handle(IntTools_Context)& theContext)
{ {
Standard_Integer aNbF, iRet; Standard_Integer aNbF, iRet;
// //
@ -754,7 +754,7 @@ Standard_Integer BOPTools_AlgoTools::IsInternalFace
const TopoDS_Edge& theEdge, const TopoDS_Edge& theEdge,
const TopoDS_Face& theFace1, const TopoDS_Face& theFace1,
const TopoDS_Face& theFace2, const TopoDS_Face& theFace2,
Handle(BOPInt_Context)& theContext) Handle(IntTools_Context)& theContext)
{ {
Standard_Boolean bRet; Standard_Boolean bRet;
Standard_Integer iRet; Standard_Integer iRet;
@ -808,7 +808,7 @@ Standard_Boolean BOPTools_AlgoTools::GetFaceOff
const TopoDS_Face& theF1, const TopoDS_Face& theF1,
BOPTools_ListOfCoupleOfShape& theLCSOff, BOPTools_ListOfCoupleOfShape& theLCSOff,
TopoDS_Face& theFOff, TopoDS_Face& theFOff,
Handle(BOPInt_Context)& theContext) Handle(IntTools_Context)& theContext)
{ {
Standard_Boolean bRet; Standard_Boolean bRet;
Standard_Real aT, aT1, aT2, aAngle, aTwoPI, aAngleMin, aDt3D; Standard_Real aT, aT1, aT2, aAngle, aTwoPI, aAngleMin, aDt3D;
@ -917,7 +917,7 @@ Standard_Boolean BOPTools_AlgoTools::GetEdgeOff(const TopoDS_Edge& theE1,
Standard_Boolean BOPTools_AlgoTools::AreFacesSameDomain Standard_Boolean BOPTools_AlgoTools::AreFacesSameDomain
(const TopoDS_Face& theF1, (const TopoDS_Face& theF1,
const TopoDS_Face& theF2, const TopoDS_Face& theF2,
Handle(BOPInt_Context)& theContext) Handle(IntTools_Context)& theContext)
{ {
Standard_Boolean bFlag; Standard_Boolean bFlag;
Standard_Integer iErr; Standard_Integer iErr;
@ -965,7 +965,7 @@ Standard_Boolean BOPTools_AlgoTools::AreFacesSameDomain
Standard_Boolean BOPTools_AlgoTools::CheckSameGeom Standard_Boolean BOPTools_AlgoTools::CheckSameGeom
(const TopoDS_Face& theF1, (const TopoDS_Face& theF1,
const TopoDS_Face& theF2, const TopoDS_Face& theF2,
Handle(BOPInt_Context)& theContext) Handle(IntTools_Context)& theContext)
{ {
Standard_Boolean bRet; Standard_Boolean bRet;
Standard_Real aTolF1, aTolF2, aTol; Standard_Real aTolF1, aTolF2, aTol;
@ -1041,7 +1041,7 @@ Standard_Integer BOPTools_AlgoTools::Sense (const TopoDS_Face& theF1,
Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse
(const TopoDS_Shape& theSp, (const TopoDS_Shape& theSp,
const TopoDS_Shape& theSr, const TopoDS_Shape& theSr,
Handle(BOPInt_Context)& theContext) Handle(IntTools_Context)& theContext)
{ {
Standard_Boolean bRet; Standard_Boolean bRet;
TopAbs_ShapeEnum aType; TopAbs_ShapeEnum aType;
@ -1076,7 +1076,7 @@ Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse
Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse
(const TopoDS_Face& theFSp, (const TopoDS_Face& theFSp,
const TopoDS_Face& theFSr, const TopoDS_Face& theFSr,
Handle(BOPInt_Context)& theContext) Handle(IntTools_Context)& theContext)
{ {
Standard_Boolean bRet, bFound, bInFace; Standard_Boolean bRet, bFound, bInFace;
Standard_Real aT1, aT2, aT, aU, aV, aScPr; Standard_Real aT1, aT2, aT, aU, aV, aScPr;
@ -1169,7 +1169,7 @@ Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse
Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse Standard_Boolean BOPTools_AlgoTools::IsSplitToReverse
(const TopoDS_Edge& aEF1, (const TopoDS_Edge& aEF1,
const TopoDS_Edge& aEF2, const TopoDS_Edge& aEF2,
Handle(BOPInt_Context)& theContext) Handle(IntTools_Context)& theContext)
{ {
Standard_Boolean bRet, bIsDegenerated; Standard_Boolean bRet, bIsDegenerated;
// //
@ -1557,7 +1557,7 @@ Standard_Boolean BOPTools_AlgoTools::GetEdgeOnFace
Standard_Boolean FindFacePairs (const TopoDS_Edge& theE, Standard_Boolean FindFacePairs (const TopoDS_Edge& theE,
const BOPCol_ListOfShape& thLF, const BOPCol_ListOfShape& thLF,
BOPTools_ListOfCoupleOfShape& theLCFF, BOPTools_ListOfCoupleOfShape& theLCFF,
Handle(BOPInt_Context)& theContext) Handle(IntTools_Context)& theContext)
{ {
Standard_Boolean bFound; Standard_Boolean bFound;
Standard_Integer i, aNbCEF; Standard_Integer i, aNbCEF;
@ -1683,7 +1683,7 @@ Standard_Boolean BOPTools_AlgoTools::IsBlockInOnFace
(const IntTools_Range& aShrR, (const IntTools_Range& aShrR,
const TopoDS_Face& aF, const TopoDS_Face& aF,
const TopoDS_Edge& aE1, const TopoDS_Edge& aE1,
Handle(BOPInt_Context)& aContext) Handle(IntTools_Context)& aContext)
{ {
Standard_Boolean bFlag; Standard_Boolean bFlag;
Standard_Real f1, l1, ULD, VLD; Standard_Real f1, l1, ULD, VLD;
@ -1772,7 +1772,7 @@ Standard_Boolean BOPTools_AlgoTools::IsBlockInOnFace
//======================================================================= //=======================================================================
Standard_Boolean BOPTools_AlgoTools::IsMicroEdge Standard_Boolean BOPTools_AlgoTools::IsMicroEdge
(const TopoDS_Edge& aE, (const TopoDS_Edge& aE,
const Handle(BOPInt_Context)& aCtx) const Handle(IntTools_Context)& aCtx)
{ {
Standard_Boolean bRet; Standard_Boolean bRet;
Standard_Integer iErr; Standard_Integer iErr;
@ -1796,7 +1796,7 @@ Standard_Boolean BOPTools_AlgoTools::IsMicroEdge
aT2=aTmp; aT2=aTmp;
} }
// //
BOPInt_ShrunkRange aSR; IntTools_ShrunkRange aSR;
aSR.SetContext(aCtx); aSR.SetContext(aCtx);
aSR.SetData(aE, aT1, aT2, aV1, aV2); aSR.SetData(aE, aT1, aT2, aV1, aV2);
aSR.Perform(); aSR.Perform();
@ -1817,7 +1817,7 @@ void GetFaceDir(const TopoDS_Edge& aE,
const gp_Dir& aDTgt, const gp_Dir& aDTgt,
gp_Dir& aDN, gp_Dir& aDN,
gp_Dir& aDB, gp_Dir& aDB,
Handle(BOPInt_Context)& theContext, Handle(IntTools_Context)& theContext,
GeomAPI_ProjectPointOnSurf& aProjPL, GeomAPI_ProjectPointOnSurf& aProjPL,
const Standard_Real aDt) const Standard_Real aDt)
{ {
@ -1846,7 +1846,7 @@ Standard_Boolean FindPointInFace(const TopoDS_Face& aF,
const gp_Pnt& aP, const gp_Pnt& aP,
gp_Dir& aDB, gp_Dir& aDB,
gp_Pnt& aPOut, gp_Pnt& aPOut,
Handle(BOPInt_Context)& theContext, Handle(IntTools_Context)& theContext,
GeomAPI_ProjectPointOnSurf& aProjPL, GeomAPI_ProjectPointOnSurf& aProjPL,
const Standard_Real aDt) const Standard_Real aDt)
{ {

10
src/BOPTools/BOPTools_AlgoTools3D.cdl
View File

@ -38,7 +38,7 @@ uses
ListOfShape from BOPCol, ListOfShape from BOPCol,
Context from BOPInt, Context from IntTools,
IndexedDataMapOfShapeListOfShape from BOPCol IndexedDataMapOfShapeListOfShape from BOPCol
@ -95,7 +95,7 @@ is
aT: Real from Standard; aT: Real from Standard;
aPx:out Pnt from gp; aPx:out Pnt from gp;
aD:out Dir from gp; aD:out Dir from gp;
theContext:out Context from BOPInt); theContext:out Context from IntTools);
---Purpose: ---Purpose:
--- Computes normal to the face <aF> for the 3D-point that --- Computes normal to the face <aF> for the 3D-point that
--- belonds to the edge <aE> at parameter <aT>. --- belonds to the edge <aE> at parameter <aT>.
@ -136,7 +136,7 @@ is
aT: Real from Standard; aT: Real from Standard;
aP2D:out Pnt2d from gp; aP2D:out Pnt2d from gp;
aPx:out Pnt from gp; aPx:out Pnt from gp;
theContext:out Context from BOPInt); theContext:out Context from IntTools);
---Purpose: ---Purpose:
--- Computes the point <aPx>, (<aP2D>) that is near to --- Computes the point <aPx>, (<aP2D>) that is near to
--- the edge <aE> at parameter <aT> towards to the --- the edge <aE> at parameter <aT> towards to the
@ -148,7 +148,7 @@ is
aF: Face from TopoDS; aF: Face from TopoDS;
aP2D:out Pnt2d from gp; aP2D:out Pnt2d from gp;
aPx:out Pnt from gp; aPx:out Pnt from gp;
theContext:out Context from BOPInt); theContext:out Context from IntTools);
---Purpose: ---Purpose:
--- Compute the point <aPx>, (<aP2D>) that is near to --- Compute the point <aPx>, (<aP2D>) that is near to
--- the edge <aE> at arbitrary parameter towards to the --- the edge <aE> at arbitrary parameter towards to the
@ -183,7 +183,7 @@ is
theF:Face from TopoDS; theF:Face from TopoDS;
theP:out Pnt from gp; theP:out Pnt from gp;
theP2D:out Pnt2d from gp; theP2D:out Pnt2d from gp;
theContext:out Context from BOPInt) theContext:out Context from IntTools)
returns Integer from Standard; returns Integer from Standard;
---Purpose: Computes a point <theP> inside the face <theF>. <br> ---Purpose: Computes a point <theP> inside the face <theF>. <br>
-- <theP2D> - 2D representation of <theP> <br> -- <theP2D> - 2D representation of <theP> <br>

10
src/BOPTools/BOPTools_AlgoTools3D.cxx
View File

@ -68,7 +68,7 @@
#include <BRep_TFace.hxx> #include <BRep_TFace.hxx>
#include <Poly_Triangulation.hxx> #include <Poly_Triangulation.hxx>
#include <BRep_Builder.hxx> #include <BRep_Builder.hxx>
#include <BOPInt_Context.hxx> #include <IntTools_Context.hxx>
#include <Geom2dAdaptor_Curve.hxx> #include <Geom2dAdaptor_Curve.hxx>
#include <Geom2dHatch_Hatcher.hxx> #include <Geom2dHatch_Hatcher.hxx>
#include <HatchGen_Domain.hxx> #include <HatchGen_Domain.hxx>
@ -355,7 +355,7 @@ void BOPTools_AlgoTools3D::GetApproxNormalToFaceOnEdge
const Standard_Real aT, const Standard_Real aT,
gp_Pnt& aPNear, gp_Pnt& aPNear,
gp_Dir& aDNF, gp_Dir& aDNF,
Handle(BOPInt_Context)& theContext) Handle(IntTools_Context)& theContext)
{ {
Standard_Real aFirst, aLast; Standard_Real aFirst, aLast;
Handle(Geom2d_Curve) aC2D= Handle(Geom2d_Curve) aC2D=
@ -471,7 +471,7 @@ void BOPTools_AlgoTools3D::PointNearEdge
const Standard_Real aT, const Standard_Real aT,
gp_Pnt2d& aPx2DNear, gp_Pnt2d& aPx2DNear,
gp_Pnt& aPxNear, gp_Pnt& aPxNear,
Handle(BOPInt_Context)& theContext) Handle(IntTools_Context)& theContext)
{ {
Standard_Real aTolE, aTolF, dTx, dT2D; Standard_Real aTolE, aTolF, dTx, dT2D;
Handle(Geom_Surface) aS; Handle(Geom_Surface) aS;
@ -530,7 +530,7 @@ void BOPTools_AlgoTools3D::PointNearEdge
const TopoDS_Face& aF, const TopoDS_Face& aF,
gp_Pnt2d& aPInFace2D, gp_Pnt2d& aPInFace2D,
gp_Pnt& aPInFace, gp_Pnt& aPInFace,
Handle(BOPInt_Context)& theContext) Handle(IntTools_Context)& theContext)
{ {
Standard_Real aT, aT1, aT2; Standard_Real aT, aT1, aT2;
// //
@ -718,7 +718,7 @@ Standard_Integer BOPTools_AlgoTools3D::PointInFace
(const TopoDS_Face& aF, (const TopoDS_Face& aF,
gp_Pnt& theP, gp_Pnt& theP,
gp_Pnt2d& theP2D, gp_Pnt2d& theP2D,
Handle(BOPInt_Context)& theContext) Handle(IntTools_Context)& theContext)
{ {
Standard_Boolean bIsDone, bHasFirstPoint, bHasSecondPoint; Standard_Boolean bIsDone, bHasFirstPoint, bHasSecondPoint;
Standard_Integer iErr, aIx, aNbDomains; Standard_Integer iErr, aIx, aNbDomains;

10
src/BRepFill/BRepFill_TrimShellCorner.cxx
View File

@ -25,7 +25,7 @@
#include <TopoDS_Compound.hxx> #include <TopoDS_Compound.hxx>
#include <IntTools_BeanFaceIntersector.hxx> #include <IntTools_BeanFaceIntersector.hxx>
#include <BOPInt_Context.hxx> #include <IntTools_Context.hxx>
#include <IntTools_Range.hxx> #include <IntTools_Range.hxx>
#include <Geom_Curve.hxx> #include <Geom_Curve.hxx>
@ -58,7 +58,7 @@
#include <TColgp_SequenceOfPnt.hxx> #include <TColgp_SequenceOfPnt.hxx>
#include <gce_MakeLin.hxx> #include <gce_MakeLin.hxx>
#include <BOPInt_Tools.hxx> #include <IntTools_Tools.hxx>
#include <BOPAlgo_PaveFiller.hxx> #include <BOPAlgo_PaveFiller.hxx>
#include <BOPDS_DS.hxx> #include <BOPDS_DS.hxx>
#include <BOPAlgo_BOP.hxx> #include <BOPAlgo_BOP.hxx>
@ -971,9 +971,9 @@ Standard_Boolean FindCommonVertex(const BOPDS_PDS& theDS,
if(aCP.Type() == TopAbs_VERTEX) { if(aCP.Type() == TopAbs_VERTEX) {
theCommonVertex = *(TopoDS_Vertex*)&theDS->Shape(aEE.IndexNew()); theCommonVertex = *(TopoDS_Vertex*)&theDS->Shape(aEE.IndexNew());
if (theEIndex1 == aEE.Index1()) { if (theEIndex1 == aEE.Index1()) {
BOPInt_Tools::VertexParameters(aCP, theParamOnE1, theParamOnE2); IntTools_Tools::VertexParameters(aCP, theParamOnE1, theParamOnE2);
} else { } else {
BOPInt_Tools::VertexParameters(aCP, theParamOnE2, theParamOnE1); IntTools_Tools::VertexParameters(aCP, theParamOnE2, theParamOnE1);
} }
// //
bvertexfound = Standard_True; bvertexfound = Standard_True;
@ -1931,7 +1931,7 @@ Standard_Boolean FilterSectionEdges(const BOPDS_VectorOfCurve& theBCurves,
BRep_Tool::Range(anEdge, f, l); BRep_Tool::Range(anEdge, f, l);
anIntersector.SetBeanParameters(f, l); anIntersector.SetBeanParameters(f, l);
// //
Handle(BOPInt_Context) aContext = new BOPInt_Context; Handle(IntTools_Context) aContext = new IntTools_Context;
anIntersector.SetContext(aContext); anIntersector.SetContext(aContext);
// //
anIntersector.Perform(); anIntersector.Perform();

167
src/IntTools/IntTools.cdl
View File

@ -15,8 +15,8 @@
package IntTools package IntTools
---Purpose: Contains classes for intersection and classification ---Purpose: Contains classes for intersection and classification
--- purposes and accompanying classes --- purposes and accompanying classes
uses uses
TCollection, TCollection,
@ -43,186 +43,191 @@ uses
BRepClass3d, BRepClass3d,
TColgp, TColgp,
MMgt, MMgt,
BOPInt Geom2dHatch,
BOPCol
is is
class Context;
class Range; class ShrunkRange;
class CommonPrt; --
class Root; class Range;
class Compare; class CommonPrt;
class CompareRange; class Root;
class Compare;
class CompareRange;
class EdgeEdge; class EdgeEdge;
---Purpose: class provides the Edge/Edge algorithm ---Purpose: class provides the Edge/Edge algorithm
class EdgeFace; class EdgeFace;
---Purpose: class provides the Edge/Face algorithm ---Purpose: class provides the Edge/Face algorithm
class FClass2d; class FClass2d;
---Purpose: class provides classification of a point in a face ---Purpose: class provides classification of a point in a face
class LineConstructor; class LineConstructor;
---Purpose: class provides post-processing of results of ---Purpose: class provides post-processing of results of
--- surfaces intersection --- surfaces intersection
----- -----
class MarkedRangeSet; class MarkedRangeSet;
---Purpose: auxiliary class for range management ---Purpose: auxiliary class for range management
class BaseRangeSample; class BaseRangeSample;
---Purpose: base class for range index management ---Purpose: base class for range index management
class CurveRangeSample; class CurveRangeSample;
---Purpose: class for range index management of curve ---Purpose: class for range index management of curve
class SurfaceRangeSample; class SurfaceRangeSample;
---Purpose: class for range index management of surface ---Purpose: class for range index management of surface
class CurveRangeLocalizeData; class CurveRangeLocalizeData;
class SurfaceRangeLocalizeData; class SurfaceRangeLocalizeData;
class BeanFaceIntersector; class BeanFaceIntersector;
---Purpose: class provides computing ranges of parameters ---Purpose: class provides computing ranges of parameters
--- of edge/face intersection. --- of edge/face intersection.
----- -----
class Curve; class Curve;
---Purpose: class is a container of ---Purpose: class is a container of
--- one 3d curve --- one 3d curve
--- two 2d curves --- two 2d curves
----- -----
class PntOnFace; class PntOnFace;
class PntOn2Faces; class PntOn2Faces;
class TopolTool; class TopolTool;
---Purpose: class redefines TopolTool from Adaptor3d ---Purpose: class redefines TopolTool from Adaptor3d
class FaceFace; class FaceFace;
---Purpose: class provides the Face/Face algorithm ---Purpose: class provides the Face/Face algorithm
--- ---
class Tools; class Tools;
---Purpose: class is a container of usefull geometrical and ---Purpose: class is a container of usefull geometrical and
--- topological algorithms --- topological algorithms
generic class CArray1; generic class CArray1;
--- ---
--- I n s t a n t i a t i o n s --- I n s t a n t i a t i o n s
--- ---
class SequenceOfPntOn2Faces instantiates class SequenceOfPntOn2Faces instantiates
Sequence from TCollection(PntOn2Faces from IntTools); Sequence from TCollection(PntOn2Faces from IntTools);
-- --
class SequenceOfCurves instantiates class SequenceOfCurves instantiates
Sequence from TCollection(Curve from IntTools); Sequence from TCollection(Curve from IntTools);
class SequenceOfRanges instantiates class SequenceOfRanges instantiates
Sequence from TCollection(Range from IntTools); Sequence from TCollection(Range from IntTools);
class CArray1OfInteger instantiates class CArray1OfInteger instantiates
CArray1(Integer from Standard); CArray1(Integer from Standard);
class CArray1OfReal instantiates class CArray1OfReal instantiates
CArray1(Real from Standard); CArray1(Real from Standard);
class SequenceOfRoots instantiates class SequenceOfRoots instantiates
Sequence from TCollection(Root from IntTools); Sequence from TCollection(Root from IntTools);
class Array1OfRoots instantiates class Array1OfRoots instantiates
Array1 from TCollection (Root from IntTools); Array1 from TCollection (Root from IntTools);
class Array1OfRange instantiates class Array1OfRange instantiates
Array1 from TCollection (Range from IntTools); Array1 from TCollection (Range from IntTools);
class QuickSort instantiates class QuickSort instantiates
QuickSort from SortTools (Root from IntTools, QuickSort from SortTools (Root from IntTools,
Array1OfRoots from IntTools, Array1OfRoots from IntTools,
Compare from IntTools); Compare from IntTools);
class QuickSortRange instantiates class QuickSortRange instantiates
QuickSort from SortTools (Range from IntTools, QuickSort from SortTools (Range from IntTools,
Array1OfRange from IntTools, Array1OfRange from IntTools,
CompareRange from IntTools); CompareRange from IntTools);
class SequenceOfCommonPrts instantiates class SequenceOfCommonPrts instantiates
Sequence from TCollection(CommonPrt from IntTools); Sequence from TCollection(CommonPrt from IntTools);
class IndexedDataMapOfTransientAddress instantiates class IndexedDataMapOfTransientAddress instantiates
IndexedDataMap from TCollection(Transient from Standard, IndexedDataMap from TCollection(Transient from Standard,
Address from Standard, Address from Standard,
MapTransientHasher from TColStd); MapTransientHasher from TColStd);
--modified by NIZHNY-MKK Wed Oct 5 18:06:39 2005
class ListOfCurveRangeSample instantiates class ListOfCurveRangeSample instantiates
List from TCollection(CurveRangeSample from IntTools); List from TCollection(CurveRangeSample from IntTools);
class ListOfSurfaceRangeSample instantiates class ListOfSurfaceRangeSample instantiates
List from TCollection(SurfaceRangeSample from IntTools); List from TCollection(SurfaceRangeSample from IntTools);
class ListOfBox instantiates class ListOfBox instantiates
List from TCollection(Box from Bnd); List from TCollection(Box from Bnd);
class CurveRangeSampleMapHasher; class CurveRangeSampleMapHasher;
---Purpose: class for range index management of curve ---Purpose: class for range index management of curve
class SurfaceRangeSampleMapHasher; class SurfaceRangeSampleMapHasher;
class MapOfCurveSample instantiates class MapOfCurveSample instantiates
Map from TCollection(CurveRangeSample from IntTools, Map from TCollection(CurveRangeSample from IntTools,
CurveRangeSampleMapHasher from IntTools); CurveRangeSampleMapHasher from IntTools);
class MapOfSurfaceSample instantiates class MapOfSurfaceSample instantiates
Map from TCollection(SurfaceRangeSample from IntTools, Map from TCollection(SurfaceRangeSample from IntTools,
SurfaceRangeSampleMapHasher from IntTools); SurfaceRangeSampleMapHasher from IntTools);
class DataMapOfCurveSampleBox instantiates class DataMapOfCurveSampleBox instantiates
DataMap from TCollection(CurveRangeSample from IntTools, DataMap from TCollection(CurveRangeSample from IntTools,
Box from Bnd, Box from Bnd,
CurveRangeSampleMapHasher from IntTools); CurveRangeSampleMapHasher from IntTools);
class DataMapOfSurfaceSampleBox instantiates class DataMapOfSurfaceSampleBox instantiates
DataMap from TCollection(SurfaceRangeSample from IntTools, DataMap from TCollection(SurfaceRangeSample from IntTools,
Box from Bnd, Box from Bnd,
SurfaceRangeSampleMapHasher from IntTools); SurfaceRangeSampleMapHasher from IntTools);
----------------------------------------------------- -----------------------------------------------------
-- Block of static functions -- Block of static functions
----------------------------------------------------- -----------------------------------------------------
Length (E : Edge from TopoDS) Length (E : Edge from TopoDS)
returns Real from Standard; returns Real from Standard;
---Purpose: returns the length of the edge; ---Purpose: returns the length of the edge;
RemoveIdenticalRoots (aSeq :out SequenceOfRoots from IntTools; RemoveIdenticalRoots (aSeq :out SequenceOfRoots from IntTools;
anEpsT: Real from Standard); anEpsT: Real from Standard);
---Purpose: Remove from the sequence aSeq the Roots that have ---Purpose: Remove from the sequence aSeq the Roots that have
-- values ti and tj such as |ti-tj] < anEpsT. -- values ti and tj such as |ti-tj] < anEpsT.
SortRoots (aSeq :out SequenceOfRoots from IntTools; SortRoots (aSeq :out SequenceOfRoots from IntTools;
anEpsT: Real from Standard); anEpsT: Real from Standard);
---Purpose: Sort the sequence aSeq of the Roots to arrange the ---Purpose: Sort the sequence aSeq of the Roots to arrange the
-- Roons in increasing order -- Roons in increasing order
FindRootStates (aSeq :out SequenceOfRoots from IntTools; FindRootStates (aSeq :out SequenceOfRoots from IntTools;
anEpsNull: Real from Standard); anEpsNull: Real from Standard);
---Purpose: Find the states (before and after) for each Root ---Purpose: Find the states (before and after) for each Root
-- from the sequence aSeq -- from the sequence aSeq
Parameter (P : Pnt from gp; Parameter (P : Pnt from gp;
Curve : Curve from Geom; Curve : Curve from Geom;
aParm : out Real from Standard) aParm : out Real from Standard)
returns Integer from Standard; returns Integer from Standard;
GetRadius(C: Curve from BRepAdaptor; GetRadius(C: Curve from BRepAdaptor;
t1,t3:Real from Standard; t1,t3:Real from Standard;
R:out Real from Standard) R:out Real from Standard)
returns Integer from Standard; returns Integer from Standard;
PrepareArgs(C: in out Curve from BRepAdaptor; PrepareArgs(C: in out Curve from BRepAdaptor;
tMax,tMin: Real from Standard; tMax,tMin: Real from Standard;
Discret : Integer from Standard; Discret : Integer from Standard;
Deflect : Real from Standard; Deflect : Real from Standard;
anArgs : out CArray1OfReal from IntTools) anArgs : out CArray1OfReal from IntTools)
returns Integer from Standard; returns Integer from Standard;
end IntTools; end IntTools;

246
src/IntTools/IntTools_BeanFaceIntersector.cdl
View File

@ -28,14 +28,14 @@ uses
SequenceOfRoots from IntTools, SequenceOfRoots from IntTools,
MarkedRangeSet from IntTools, MarkedRangeSet from IntTools,
SequenceOfRanges from IntTools, SequenceOfRanges from IntTools,
Context from BOPInt, Context from IntTools,
ExtCS from Extrema, ExtCS from Extrema,
ProjectPointOnSurf from GeomAPI, ProjectPointOnSurf from GeomAPI,
Edge from TopoDS, Edge from TopoDS,
Face from TopoDS, Face from TopoDS,
Curve from BRepAdaptor, Curve from BRepAdaptor,
Surface from BRepAdaptor, Surface from BRepAdaptor,
Box from Bnd, Box from Bnd,
CurveRangeSample from IntTools, CurveRangeSample from IntTools,
SurfaceRangeSample from IntTools, SurfaceRangeSample from IntTools,
ListOfCurveRangeSample from IntTools, ListOfCurveRangeSample from IntTools,
@ -48,176 +48,176 @@ is
Create returns BeanFaceIntersector from IntTools; Create returns BeanFaceIntersector from IntTools;
Create(theEdge: Edge from TopoDS; Create(theEdge: Edge from TopoDS;
theFace: Face from TopoDS) theFace: Face from TopoDS)
returns BeanFaceIntersector from IntTools; returns BeanFaceIntersector from IntTools;
---Purpose: ---Purpose:
--- Initializes the algorithm --- Initializes the algorithm
--- ---
-- Warning: -- Warning:
--- The parts of the edge which are on --- The parts of the edge which are on
--- the surface of the face and belong to --- the surface of the face and belong to
--- the whole in the face (if there is) --- the whole in the face (if there is)
--- is considered as result --- is considered as result
--- ---
Create(theCurve : Curve from BRepAdaptor; Create(theCurve : Curve from BRepAdaptor;
theSurface : Surface from BRepAdaptor; theSurface : Surface from BRepAdaptor;
theBeanTolerance: Real from Standard; theBeanTolerance: Real from Standard;
theFaceTolerance: Real from Standard) theFaceTolerance: Real from Standard)
returns BeanFaceIntersector from IntTools; returns BeanFaceIntersector from IntTools;
---Purpose: ---Purpose:
--- Initializes the algorithm --- Initializes the algorithm
--- ---
Create(theCurve : Curve from BRepAdaptor; Create(theCurve : Curve from BRepAdaptor;
theSurface : Surface from BRepAdaptor; theSurface : Surface from BRepAdaptor;
theFirstParOnCurve: Real from Standard; theFirstParOnCurve: Real from Standard;
theLastParOnCurve : Real from Standard; theLastParOnCurve : Real from Standard;
theUMinParameter : Real from Standard; theUMinParameter : Real from Standard;
theUMaxParameter : Real from Standard; theUMaxParameter : Real from Standard;
theVMinParameter : Real from Standard; theVMinParameter : Real from Standard;
theVMaxParameter : Real from Standard; theVMaxParameter : Real from Standard;
theBeanTolerance : Real from Standard; theBeanTolerance : Real from Standard;
theFaceTolerance : Real from Standard) theFaceTolerance : Real from Standard)
returns BeanFaceIntersector from IntTools; returns BeanFaceIntersector from IntTools;
---Purpose: ---Purpose:
--- Initializes the algorithm --- Initializes the algorithm
--- theUMinParameter, ... are used for --- theUMinParameter, ... are used for
--- optimization purposes --- optimization purposes
--- ---
Init(me: in out;theEdge: Edge from TopoDS; Init(me: in out;theEdge: Edge from TopoDS;
theFace: Face from TopoDS); theFace: Face from TopoDS);
---Purpose: ---Purpose:
--- Initializes the algorithm --- Initializes the algorithm
--- ---
-- Warning: -- Warning:
--- The parts of the edge which are on --- The parts of the edge which are on
--- the surface of the face and belong to --- the surface of the face and belong to
--- the whole in the face (if there is) --- the whole in the face (if there is)
--- is considered as result --- is considered as result
--- ---
Init(me: in out;theCurve : Curve from BRepAdaptor; Init(me: in out;theCurve : Curve from BRepAdaptor;
theSurface : Surface from BRepAdaptor; theSurface : Surface from BRepAdaptor;
theBeanTolerance: Real from Standard; theBeanTolerance: Real from Standard;
theFaceTolerance: Real from Standard); theFaceTolerance: Real from Standard);
---Purpose: ---Purpose:
--- Initializes the algorithm --- Initializes the algorithm
--- ---
Init(me: in out;theCurve : Curve from BRepAdaptor; Init(me: in out;theCurve : Curve from BRepAdaptor;
theSurface : Surface from BRepAdaptor; theSurface : Surface from BRepAdaptor;
theFirstParOnCurve: Real from Standard; theFirstParOnCurve: Real from Standard;
theLastParOnCurve : Real from Standard; theLastParOnCurve : Real from Standard;
theUMinParameter : Real from Standard; theUMinParameter : Real from Standard;
theUMaxParameter : Real from Standard; theUMaxParameter : Real from Standard;
theVMinParameter : Real from Standard; theVMinParameter : Real from Standard;
theVMaxParameter : Real from Standard; theVMaxParameter : Real from Standard;
theBeanTolerance : Real from Standard; theBeanTolerance : Real from Standard;
theFaceTolerance : Real from Standard); theFaceTolerance : Real from Standard);
---Purpose: ---Purpose:
--- Initializes the algorithm --- Initializes the algorithm
--- theUMinParameter, ... are used for --- theUMinParameter, ... are used for
--- optimization purposes --- optimization purposes
--- ---
SetContext(me: in out; SetContext(me: in out;
theContext: Context from BOPInt); theContext: Context from IntTools);
---Purpose:
--- Sets the intersecton context
---
Context(me)
returns Context from BOPInt;
---C++: return const &
---Purpose: ---Purpose:
--- Gets the intersecton context --- Sets the intersecton context
--- ---
Context(me)
returns Context from IntTools;
---C++: return const &
---Purpose:
--- Gets the intersecton context
---
SetBeanParameters(me: in out;theFirstParOnCurve : Real from Standard; SetBeanParameters(me: in out;theFirstParOnCurve : Real from Standard;
theLastParOnCurve : Real from Standard); theLastParOnCurve : Real from Standard);
---Purpose: ---Purpose:
--- Set restrictions for curve --- Set restrictions for curve
--- ---
SetSurfaceParameters(me: in out;theUMinParameter : Real from Standard; SetSurfaceParameters(me: in out;theUMinParameter : Real from Standard;
theUMaxParameter : Real from Standard; theUMaxParameter : Real from Standard;
theVMinParameter : Real from Standard; theVMinParameter : Real from Standard;
theVMaxParameter : Real from Standard); theVMaxParameter : Real from Standard);
---Purpose: ---Purpose:
--- Set restrictions for surface --- Set restrictions for surface
--- ---
Perform(me: in out); Perform(me: in out);
---Purpose: ---Purpose:
--- Launches the algorithm --- Launches the algorithm
--- ---
IsDone(me) returns Boolean from Standard; IsDone(me) returns Boolean from Standard;
---C++: inline ---C++: inline
Result(me) Result(me)
returns SequenceOfRanges from IntTools; returns SequenceOfRanges from IntTools;
---C++: return const & ---C++: return const &
Result(me; theResults: out SequenceOfRanges from IntTools); Result(me; theResults: out SequenceOfRanges from IntTools);
-- private -- private
ComputeAroundExactIntersection(me: in out) ComputeAroundExactIntersection(me: in out)
is private; is private;
ComputeLinePlane(me: in out) ComputeLinePlane(me: in out)
is private; is private;
FastComputeExactIntersection(me: in out) FastComputeExactIntersection(me: in out)
returns Integer from Standard is private; returns Integer from Standard is private;
ComputeUsingExtremum(me: in out) ComputeUsingExtremum(me: in out)
is private; is private;
ComputeNearRangeBoundaries(me: in out) ComputeNearRangeBoundaries(me: in out)
is private; is private;
ComputeLocalized(me: in out) ComputeLocalized(me: in out)
returns Boolean from Standard is private; returns Boolean from Standard is private;
ComputeRangeFromStartPoint(me: in out; ToIncreaseParameter : Boolean from Standard; ComputeRangeFromStartPoint(me: in out; ToIncreaseParameter : Boolean from Standard;
theParameter : Real from Standard; theParameter : Real from Standard;
theUParameter : Real from Standard; theUParameter : Real from Standard;
theVParameter : Real from Standard) theVParameter : Real from Standard)
is private; is private;
ComputeRangeFromStartPoint(me: in out; ToIncreaseParameter : Boolean from Standard; ComputeRangeFromStartPoint(me: in out; ToIncreaseParameter : Boolean from Standard;
theParameter : Real from Standard; theParameter : Real from Standard;
theUParameter : Real from Standard; theUParameter : Real from Standard;
theVParameter : Real from Standard; theVParameter : Real from Standard;
theIndex : Integer from Standard) theIndex : Integer from Standard)
is private; is private;
Distance(me: in out; theArg : Real from Standard; Distance(me: in out; theArg : Real from Standard;
theUParameter: out Real from Standard; theUParameter: out Real from Standard;
theVParameter: out Real from Standard) theVParameter: out Real from Standard)
returns Real from Standard returns Real from Standard
is private; is private;
Distance(me: in out; theArg: Real from Standard) Distance(me: in out; theArg: Real from Standard)
returns Real from Standard returns Real from Standard
is private; is private;
LocalizeSolutions(me: in out; theCurveRange : CurveRangeSample from IntTools; LocalizeSolutions(me: in out; theCurveRange : CurveRangeSample from IntTools;
theBoxCurve : Box from Bnd; theBoxCurve : Box from Bnd;
theSurfaceRange: SurfaceRangeSample from IntTools; theSurfaceRange: SurfaceRangeSample from IntTools;
theBoxSurface : Box from Bnd; theBoxSurface : Box from Bnd;
theCurveData : in out CurveRangeLocalizeData from IntTools; theCurveData : in out CurveRangeLocalizeData from IntTools;
theSurfaceData : in out SurfaceRangeLocalizeData from IntTools; theSurfaceData : in out SurfaceRangeLocalizeData from IntTools;
theListCurveRange: in out ListOfCurveRangeSample from IntTools; theListCurveRange: in out ListOfCurveRangeSample from IntTools;
theListSurfaceRange: in out ListOfSurfaceRangeSample from IntTools) theListSurfaceRange: in out ListOfSurfaceRangeSample from IntTools)
returns Boolean from Standard returns Boolean from Standard
is private; is private;
TestComputeCoinside(me: in out) TestComputeCoinside(me: in out)
returns Boolean from Standard returns Boolean from Standard
is private; is private;
fields fields
@ -242,7 +242,7 @@ fields
myProjector : ProjectPointOnSurf from GeomAPI; myProjector : ProjectPointOnSurf from GeomAPI;
myRangeManager : MarkedRangeSet from IntTools; myRangeManager : MarkedRangeSet from IntTools;
myDeflection : Real from Standard; myDeflection : Real from Standard;
myContext : Context from BOPInt; myContext : Context from IntTools;
-- results -- results
myResults : SequenceOfRanges from IntTools; myResults : SequenceOfRanges from IntTools;

1496
src/IntTools/IntTools_BeanFaceIntersector.cxx
View File

File diff suppressed because it is too large Load Diff

38
src/BOPInt/BOPInt_Context.cdl → src/IntTools/IntTools_Context.cdl
View File

@ -12,7 +12,8 @@
-- Alternatively, this file may be used under the terms of Open CASCADE -- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement. -- commercial license or contractual agreement.
class Context from BOPInt
class Context from IntTools
inherits TShared from MMgt inherits TShared from MMgt
@ -48,11 +49,12 @@ uses
is is
Create Create
returns Context from BOPInt;
---C++: alias "Standard_EXPORT virtual ~BOPInt_Context();" returns Context from IntTools;
---C++: alias "Standard_EXPORT virtual ~IntTools_Context();"
Create (theAllocator: BaseAllocator from BOPCol) Create (theAllocator: BaseAllocator from BOPCol)
returns Context from BOPInt;
returns Context from IntTools;
FClass2d(me:mutable; FClass2d(me:mutable;
aF: Face from TopoDS) aF: Face from TopoDS)
@ -150,32 +152,6 @@ is
--- 2. the edge does not contain 3d curve and pcurves (-2) --- 2. the edge does not contain 3d curve and pcurves (-2)
--- 3. projection algorithm failed (-3) --- 3. projection algorithm failed (-3)
--- ---
--ComputeVE (me:mutable;
--aV : Vertex from TopoDS;
--aE : Edge from TopoDS;
--aT :out Real from Standard;
--bToUpdateVertex:out Boolean from Standard;
--aDist :out Real from Standard)
--returns Integer from Standard;
---Purpose:
--- Computes parameter aT of the vertex aV on
--- the edge aE.
--- Returns zero if the distance between vertex
--- and edge is less than sum of tolerances,
--- otherwise and for following conditions returns
--- negative value
--- 1. the edge is degenerated (-1)
--- 2. the edge does not contain 3d curve and pcurves (-2)
--- 3. projection algorithm failed (-3)
---
--- Output parameters
--- bToUpdateVertex - the flag that indicates whether the
--- vertex tolerance should be modified or not
--- aDist - the value of the distance between the vertex
--- and the edge
ComputeVF (me:mutable; ComputeVF (me:mutable;
aV : Vertex from TopoDS; aV : Vertex from TopoDS;

141
src/BOPInt/BOPInt_Context.cxx → src/IntTools/IntTools_Context.cxx
View File

@ -12,7 +12,7 @@
// Alternatively, this file may be used under the terms of Open CASCADE // Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement. // commercial license or contractual agreement.
#include <BOPInt_Context.ixx> #include <IntTools_Context.ixx>
#include <Precision.hxx> #include <Precision.hxx>
@ -46,7 +46,7 @@
//function : //function :
//purpose : //purpose :
//======================================================================= //=======================================================================
BOPInt_Context::BOPInt_Context() IntTools_Context::IntTools_Context()
: :
myAllocator(new NCollection_IncAllocator()), myAllocator(new NCollection_IncAllocator()),
myFClass2dMap(100, myAllocator), myFClass2dMap(100, myAllocator),
@ -63,7 +63,8 @@
//function : //function :
//purpose : //purpose :
//======================================================================= //=======================================================================
BOPInt_Context::BOPInt_Context(const Handle(NCollection_BaseAllocator)& theAllocator) IntTools_Context::IntTools_Context
(const Handle(NCollection_BaseAllocator)& theAllocator)
: :
myAllocator(theAllocator), myAllocator(theAllocator),
myFClass2dMap(100, myAllocator), myFClass2dMap(100, myAllocator),
@ -80,7 +81,7 @@
//function : ~ //function : ~
//purpose : //purpose :
//======================================================================= //=======================================================================
BOPInt_Context::~BOPInt_Context() IntTools_Context::~IntTools_Context()
{ {
Standard_Address anAdr; Standard_Address anAdr;
BOPCol_DataMapIteratorOfDataMapOfShapeAddress aIt; BOPCol_DataMapIteratorOfDataMapOfShapeAddress aIt;
@ -162,7 +163,7 @@
//function : FClass2d //function : FClass2d
//purpose : //purpose :
//======================================================================= //=======================================================================
IntTools_FClass2d& BOPInt_Context::FClass2d(const TopoDS_Face& aF) IntTools_FClass2d& IntTools_Context::FClass2d(const TopoDS_Face& aF)
{ {
Standard_Address anAdr; Standard_Address anAdr;
IntTools_FClass2d* pFClass2d; IntTools_FClass2d* pFClass2d;
@ -191,7 +192,7 @@
//function : ProjPS //function : ProjPS
//purpose : //purpose :
//======================================================================= //=======================================================================
GeomAPI_ProjectPointOnSurf& BOPInt_Context::ProjPS(const TopoDS_Face& aF) GeomAPI_ProjectPointOnSurf& IntTools_Context::ProjPS(const TopoDS_Face& aF)
{ {
Standard_Address anAdr; Standard_Address anAdr;
GeomAPI_ProjectPointOnSurf* pProjPS; GeomAPI_ProjectPointOnSurf* pProjPS;
@ -228,7 +229,7 @@
//function : ProjPC //function : ProjPC
//purpose : //purpose :
//======================================================================= //=======================================================================
GeomAPI_ProjectPointOnCurve& BOPInt_Context::ProjPC(const TopoDS_Edge& aE) GeomAPI_ProjectPointOnCurve& IntTools_Context::ProjPC(const TopoDS_Edge& aE)
{ {
Standard_Address anAdr; Standard_Address anAdr;
GeomAPI_ProjectPointOnCurve* pProjPC; GeomAPI_ProjectPointOnCurve* pProjPC;
@ -257,7 +258,8 @@
//function : ProjPT //function : ProjPT
//purpose : //purpose :
//======================================================================= //=======================================================================
GeomAPI_ProjectPointOnCurve& BOPInt_Context::ProjPT(const Handle(Geom_Curve)& aC3D) GeomAPI_ProjectPointOnCurve& IntTools_Context::ProjPT
(const Handle(Geom_Curve)& aC3D)
{ {
Standard_Address anAdr; Standard_Address anAdr;
@ -286,7 +288,8 @@
//function : SolidClassifier //function : SolidClassifier
//purpose : //purpose :
//======================================================================= //=======================================================================
BRepClass3d_SolidClassifier& BOPInt_Context::SolidClassifier(const TopoDS_Solid& aSolid) BRepClass3d_SolidClassifier& IntTools_Context::SolidClassifier
(const TopoDS_Solid& aSolid)
{ {
Standard_Address anAdr; Standard_Address anAdr;
BRepClass3d_SolidClassifier* pSC; BRepClass3d_SolidClassifier* pSC;
@ -311,7 +314,7 @@
//function : Hatcher //function : Hatcher
//purpose : //purpose :
//======================================================================= //=======================================================================
Geom2dHatch_Hatcher& BOPInt_Context::Hatcher(const TopoDS_Face& aF) Geom2dHatch_Hatcher& IntTools_Context::Hatcher(const TopoDS_Face& aF)
{ {
Standard_Address anAdr; Standard_Address anAdr;
Geom2dHatch_Hatcher* pHatcher; Geom2dHatch_Hatcher* pHatcher;
@ -375,16 +378,18 @@
//function : SurfaceData //function : SurfaceData
//purpose : //purpose :
//======================================================================= //=======================================================================
IntTools_SurfaceRangeLocalizeData& BOPInt_Context::SurfaceData(const TopoDS_Face& aF) IntTools_SurfaceRangeLocalizeData& IntTools_Context::SurfaceData
(const TopoDS_Face& aF)
{ {
Standard_Address anAdr; Standard_Address anAdr;
IntTools_SurfaceRangeLocalizeData* pSData; IntTools_SurfaceRangeLocalizeData* pSData;
// //
if (!myProjSDataMap.IsBound(aF)) { if (!myProjSDataMap.IsBound(aF)) {
pSData=new IntTools_SurfaceRangeLocalizeData(3, pSData=new IntTools_SurfaceRangeLocalizeData
3, (3,
10. * Precision::PConfusion(), 3,
10. * Precision::PConfusion()); 10. * Precision::PConfusion(),
10. * Precision::PConfusion());
// //
anAdr=(Standard_Address)pSData; anAdr=(Standard_Address)pSData;
myProjSDataMap.Bind(aF, anAdr); myProjSDataMap.Bind(aF, anAdr);
@ -402,10 +407,11 @@
//function : ComputePE //function : ComputePE
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Integer BOPInt_Context::ComputePE(const gp_Pnt& aP1, Standard_Integer IntTools_Context::ComputePE
const Standard_Real aTolP1, (const gp_Pnt& aP1,
const TopoDS_Edge& aE2, const Standard_Real aTolP1,
Standard_Real& aT) const TopoDS_Edge& aE2,
Standard_Real& aT)
{ {
if (!BRep_Tool::IsGeometric(aE2)) { if (!BRep_Tool::IsGeometric(aE2)) {
return -2; return -2;
@ -436,9 +442,10 @@
//function : ComputeVE //function : ComputeVE
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Integer BOPInt_Context::ComputeVE(const TopoDS_Vertex& aV1, Standard_Integer IntTools_Context::ComputeVE
const TopoDS_Edge& aE2, (const TopoDS_Vertex& aV1,
Standard_Real& aT) const TopoDS_Edge& aE2,
Standard_Real& aT)
{ {
if (BRep_Tool::Degenerated(aE2)) { if (BRep_Tool::Degenerated(aE2)) {
return -1; return -1;
@ -479,10 +486,11 @@
//function : ComputeVS //function : ComputeVS
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Integer BOPInt_Context::ComputeVF(const TopoDS_Vertex& aV1, Standard_Integer IntTools_Context::ComputeVF
const TopoDS_Face& aF2, (const TopoDS_Vertex& aV1,
Standard_Real& U, const TopoDS_Face& aF2,
Standard_Real& V) Standard_Real& U,
Standard_Real& V)
{ {
Standard_Real aTolV1, aTolF2, aTolSum, aDist; Standard_Real aTolV1, aTolF2, aTolSum, aDist;
gp_Pnt aP; gp_Pnt aP;
@ -521,8 +529,9 @@
//function : StatePointFace //function : StatePointFace
//purpose : //purpose :
//======================================================================= //=======================================================================
TopAbs_State BOPInt_Context::StatePointFace(const TopoDS_Face& aF, TopAbs_State IntTools_Context::StatePointFace
const gp_Pnt2d& aP2d) (const TopoDS_Face& aF,
const gp_Pnt2d& aP2d)
{ {
TopAbs_State aState; TopAbs_State aState;
IntTools_FClass2d& aClass2d=FClass2d(aF); IntTools_FClass2d& aClass2d=FClass2d(aF);
@ -533,8 +542,9 @@
//function : IsPointInFace //function : IsPointInFace
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean BOPInt_Context::IsPointInFace(const TopoDS_Face& aF, Standard_Boolean IntTools_Context::IsPointInFace
const gp_Pnt2d& aP2d) (const TopoDS_Face& aF,
const gp_Pnt2d& aP2d)
{ {
TopAbs_State aState=StatePointFace(aF, aP2d); TopAbs_State aState=StatePointFace(aF, aP2d);
if (aState==TopAbs_OUT || aState==TopAbs_ON) { if (aState==TopAbs_OUT || aState==TopAbs_ON) {
@ -546,7 +556,7 @@
//function : IsPointInOnFace //function : IsPointInOnFace
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean BOPInt_Context::IsPointInOnFace(const TopoDS_Face& aF, Standard_Boolean IntTools_Context::IsPointInOnFace(const TopoDS_Face& aF,
const gp_Pnt2d& aP2d) const gp_Pnt2d& aP2d)
{ {
TopAbs_State aState=StatePointFace(aF, aP2d); TopAbs_State aState=StatePointFace(aF, aP2d);
@ -559,9 +569,10 @@
//function : IsValidPointForFace //function : IsValidPointForFace
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean BOPInt_Context::IsValidPointForFace(const gp_Pnt& aP, Standard_Boolean IntTools_Context::IsValidPointForFace
const TopoDS_Face& aF, (const gp_Pnt& aP,
const Standard_Real aTol) const TopoDS_Face& aF,
const Standard_Real aTol)
{ {
Standard_Boolean bFlag; Standard_Boolean bFlag;
Standard_Real Umin, U, V; Standard_Real Umin, U, V;
@ -588,10 +599,11 @@
//function : IsValidPointForFaces //function : IsValidPointForFaces
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean BOPInt_Context::IsValidPointForFaces (const gp_Pnt& aP, Standard_Boolean IntTools_Context::IsValidPointForFaces
const TopoDS_Face& aF1, (const gp_Pnt& aP,
const TopoDS_Face& aF2, const TopoDS_Face& aF1,
const Standard_Real aTol) const TopoDS_Face& aF2,
const Standard_Real aTol)
{ {
Standard_Boolean bFlag1, bFlag2; Standard_Boolean bFlag1, bFlag2;
@ -606,11 +618,12 @@
//function : IsValidBlockForFace //function : IsValidBlockForFace
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean BOPInt_Context::IsValidBlockForFace (const Standard_Real aT1, Standard_Boolean IntTools_Context::IsValidBlockForFace
const Standard_Real aT2, (const Standard_Real aT1,
const IntTools_Curve& aC, const Standard_Real aT2,
const TopoDS_Face& aF, const IntTools_Curve& aC,
const Standard_Real aTol) const TopoDS_Face& aF,
const Standard_Real aTol)
{ {
Standard_Boolean bFlag; Standard_Boolean bFlag;
Standard_Real aTInterm; Standard_Real aTInterm;
@ -629,12 +642,13 @@
//function : IsValidBlockForFaces //function : IsValidBlockForFaces
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean BOPInt_Context::IsValidBlockForFaces (const Standard_Real aT1, Standard_Boolean IntTools_Context::IsValidBlockForFaces
const Standard_Real aT2, (const Standard_Real aT1,
const IntTools_Curve& aC, const Standard_Real aT2,
const TopoDS_Face& aF1, const IntTools_Curve& aC,
const TopoDS_Face& aF2, const TopoDS_Face& aF1,
const Standard_Real aTol) const TopoDS_Face& aF2,
const Standard_Real aTol)
{ {
Standard_Boolean bFlag1, bFlag2; Standard_Boolean bFlag1, bFlag2;
// //
@ -668,16 +682,17 @@
//function : IsVertexOnLine //function : IsVertexOnLine
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean BOPInt_Context::IsVertexOnLine (const TopoDS_Vertex& aV, Standard_Boolean IntTools_Context::IsVertexOnLine
const IntTools_Curve& aC, (const TopoDS_Vertex& aV,
const Standard_Real aTolC, const IntTools_Curve& aC,
Standard_Real& aT) const Standard_Real aTolC,
Standard_Real& aT)
{ {
Standard_Boolean bRet; Standard_Boolean bRet;
Standard_Real aTolV; Standard_Real aTolV;
// //
aTolV=BRep_Tool::Tolerance(aV); aTolV=BRep_Tool::Tolerance(aV);
bRet=BOPInt_Context::IsVertexOnLine(aV, aTolV, aC, aTolC , aT); bRet=IntTools_Context::IsVertexOnLine(aV, aTolV, aC, aTolC , aT);
// //
return bRet; return bRet;
} }
@ -685,11 +700,12 @@
//function : IsVertexOnLine //function : IsVertexOnLine
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean BOPInt_Context::IsVertexOnLine (const TopoDS_Vertex& aV, Standard_Boolean IntTools_Context::IsVertexOnLine
const Standard_Real aTolV, (const TopoDS_Vertex& aV,
const IntTools_Curve& aC, const Standard_Real aTolV,
const Standard_Real aTolC, const IntTools_Curve& aC,
Standard_Real& aT) const Standard_Real aTolC,
Standard_Real& aT)
{ {
Standard_Real aFirst, aLast, aDist, aTolSum; Standard_Real aFirst, aLast, aDist, aTolSum;
Standard_Integer aNbProj; Standard_Integer aNbProj;
@ -811,9 +827,10 @@
//function : ProjectPointOnEdge //function : ProjectPointOnEdge
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean BOPInt_Context::ProjectPointOnEdge(const gp_Pnt& aP, Standard_Boolean IntTools_Context::ProjectPointOnEdge
const TopoDS_Edge& anEdge, (const gp_Pnt& aP,
Standard_Real& aT) const TopoDS_Edge& anEdge,
Standard_Real& aT)
{ {
Standard_Integer aNbPoints; Standard_Integer aNbPoints;

10
src/IntTools/IntTools_EdgeFace.cdl
View File

@ -31,7 +31,7 @@ uses
FClass2d from IntTools, FClass2d from IntTools,
SequenceOfRoots from IntTools, SequenceOfRoots from IntTools,
SequenceOfCommonPrts from IntTools, SequenceOfCommonPrts from IntTools,
Context from BOPInt, Context from IntTools,
Range from IntTools Range from IntTools
--raises --raises
@ -118,12 +118,12 @@ is
--- The algorithm processes edge inside these boundaries. --- The algorithm processes edge inside these boundaries.
SetContext (me: in out; SetContext (me: in out;
theContext: Context from BOPInt); theContext: Context from IntTools);
---Purpose: ---Purpose:
--- Sets the intersecton context --- Sets the intersecton context
Context (me) Context (me)
returns Context from BOPInt; returns Context from IntTools;
---C++:return const & ---C++:return const &
---Purpose: ---Purpose:
--- Gets the intersecton context --- Gets the intersecton context
@ -234,7 +234,7 @@ is
t,f:CArray1OfReal from IntTools) t,f:CArray1OfReal from IntTools)
is protected; is protected;
RemoveIdenticalRoots(me:out) RemoveIdenticalRoots(me:out)
is protected; is protected;
CheckTouch (me: out; CheckTouch (me: out;
@ -276,7 +276,7 @@ fields
myErrorStatus : Integer from Standard; myErrorStatus : Integer from Standard;
--- internal members --- internal members
myContext : Context from BOPInt; myContext : Context from IntTools;
myProjectableRanges: SequenceOfRanges from IntTools; myProjectableRanges: SequenceOfRanges from IntTools;
myFClass2d : FClass2d from IntTools; myFClass2d : FClass2d from IntTools;
myFuncArray : CArray1OfReal from IntTools; myFuncArray : CArray1OfReal from IntTools;

8
src/IntTools/IntTools_EdgeFace.cxx
View File

@ -28,7 +28,7 @@
#include <IntTools_CommonPrt.hxx> #include <IntTools_CommonPrt.hxx>
#include <IntTools_Root.hxx> #include <IntTools_Root.hxx>
#include <IntTools_BeanFaceIntersector.hxx> #include <IntTools_BeanFaceIntersector.hxx>
#include <BOPInt_Context.hxx> #include <IntTools_Context.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>
@ -100,7 +100,7 @@ static
//function : SetContext //function : SetContext
//purpose : //purpose :
//======================================================================= //=======================================================================
void IntTools_EdgeFace::SetContext(const Handle(BOPInt_Context)& theContext) void IntTools_EdgeFace::SetContext(const Handle(IntTools_Context)& theContext)
{ {
myContext = theContext; myContext = theContext;
} }
@ -109,7 +109,7 @@ void IntTools_EdgeFace::SetContext(const Handle(BOPInt_Context)& theContext)
//function : Context //function : Context
//purpose : //purpose :
//======================================================================= //=======================================================================
const Handle(BOPInt_Context)& IntTools_EdgeFace::Context()const const Handle(IntTools_Context)& IntTools_EdgeFace::Context()const
{ {
return myContext; return myContext;
} }
@ -1221,7 +1221,7 @@ void IntTools_EdgeFace::Perform()
} }
// //
if (myContext.IsNull()) { if (myContext.IsNull()) {
myContext=new BOPInt_Context; myContext=new IntTools_Context;
} }
// //
myIsDone = Standard_False; myIsDone = Standard_False;

171
src/IntTools/IntTools_FaceFace.cdl
View File

@ -15,8 +15,8 @@
class FaceFace from IntTools class FaceFace from IntTools
---Purpose: This class provides the intersection of ---Purpose: This class provides the intersection of
--- face's underlying surfaces. --- face's underlying surfaces.
uses uses
@ -28,7 +28,7 @@ uses
SequenceOfCurves from IntTools, SequenceOfCurves from IntTools,
LineConstructor from IntTools, LineConstructor from IntTools,
SequenceOfPntOn2Faces from IntTools, SequenceOfPntOn2Faces from IntTools,
Context from BOPInt Context from IntTools
@ -36,117 +36,114 @@ raises NotDone from StdFail
is is
Create Create
returns FaceFace from IntTools; returns FaceFace from IntTools;
---Purpose: ---Purpose:
--- Empty constructor. --- Empty constructor.
---
SetParameters(me: in out; SetParameters(me: in out;
ApproxCurves : Boolean from Standard; ApproxCurves : Boolean from Standard;
ComputeCurveOnS1: Boolean from Standard; ComputeCurveOnS1: Boolean from Standard;
ComputeCurveOnS2: Boolean from Standard; ComputeCurveOnS2: Boolean from Standard;
ApproximationTolerance: Real from Standard); ApproximationTolerance: Real from Standard);
---Purpose: ---Purpose:
--- Modifier --- Modifier
--- ---
Perform(me: in out; Perform(me: in out;
F1: Face from TopoDS; F1: Face from TopoDS;
F2: Face from TopoDS); F2: Face from TopoDS);
---Purpose: ---Purpose:
--- Intersects underliing surfaces of F1 and F2 --- Intersects underliing surfaces of F1 and F2
--- Use sum of tolerance of F1 and F2 as intersection --- Use sum of tolerance of F1 and F2 as intersection
--- criteria --- criteria
---
IsDone(me) IsDone(me)
returns Boolean from Standard; returns Boolean from Standard;
---Purpose: ---Purpose:
--- Returns True if the intersection was successful --- Returns True if the intersection was successful
--- ---
Lines(me) Lines(me)
returns SequenceOfCurves from IntTools; returns SequenceOfCurves from IntTools;
---C++: return const& ---C++: return const&
---Purpose: ---Purpose:
--- Returns sequence of 3d curves as result of intersection --- Returns sequence of 3d curves as result of intersection
--- ---
Points(me) Points(me)
returns SequenceOfPntOn2Faces from IntTools; returns SequenceOfPntOn2Faces from IntTools;
---C++: return const& ---C++: return const&
---Purpose: ---Purpose:
--- Returns sequence of 3d curves as result of intersection --- Returns sequence of 3d curves as result of intersection
--- ---
TolReached3d(me) TolReached3d(me)
returns Real from Standard; returns Real from Standard;
---Purpose: ---Purpose:
--- Returns tolerance reached during approximation. --- Returns tolerance reached during approximation.
--- If approximation was not done, returns zero. --- If approximation was not done, returns zero.
---
TolReached2d(me) TolReached2d(me)
returns Real from Standard; returns Real from Standard;
---Purpose: ---Purpose:
--- Returns tolerance reached during approximation. --- Returns tolerance reached during approximation.
--- If approximation was not done, returns zero. --- If approximation was not done, returns zero.
--- ---
Face1 (me) Face1 (me)
returns Face from TopoDS; returns Face from TopoDS;
---C++: return const& ---C++: return const&
---Purpose: ---Purpose:
--- Returns first of processed faces --- Returns first of processed faces
--- ---
Face2 (me) Face2 (me)
returns Face from TopoDS; returns Face from TopoDS;
---C++: return const& ---C++: return const&
---Purpose: ---Purpose:
--- Returns second of processed faces --- Returns second of processed faces
--- ---
TangentFaces (me) TangentFaces (me)
returns Boolean from Standard; returns Boolean from Standard;
---Purpose: ---Purpose:
--- Returns True if faces are tangent --- Returns True if faces are tangent
--- ---
PrepareLines3D (me:out; PrepareLines3D (me:out;
bToSplit: Boolean from Standard=Standard_True); bToSplit: Boolean from Standard=Standard_True);
---Purpose: ---Purpose:
--- Provides post-processing the result lines. --- Provides post-processing the result lines.
--- <bToSplit> - the flag. --- <bToSplit> - the flag.
-- In case of <bToSplit> is true the closed 3D-curves will be splitted -- In case of <bToSplit> is true the closed 3D-curves will be splitted
-- on parts. -- on parts.
-- In case of <bToSplit> is false the closed 3D-curves remain untouched. -- In case of <bToSplit> is false the closed 3D-curves remain untouched.
SetList (me: in out; SetList (me: in out;
ListOfPnts: in out ListOfPntOn2S from IntSurf); ListOfPnts: in out ListOfPntOn2S from IntSurf);
---------------------------------------------------------- ----------------------------------------------------------
-- private block -- private block
---------------------------------------------------------- ----------------------------------------------------------
MakeCurve(me: in out; Index : Integer from Standard; MakeCurve(me: in out; Index : Integer from Standard;
D1 : TopolTool from Adaptor3d; D1 : TopolTool from Adaptor3d;
D2 : TopolTool from Adaptor3d) D2 : TopolTool from Adaptor3d)
is protected; is protected;
ComputeTolReached3d(me:out) ComputeTolReached3d(me:out)
is protected; is protected;
SetContext(me:out; SetContext(me:out;
aContext : Context from BOPInt); aContext : Context from IntTools);
---Purpose: ---Purpose:
--- Sets the intersecton context --- Sets the intersecton context
Context(me) Context(me)
returns Context from BOPInt; returns Context from IntTools;
---C++: return const & ---C++: return const &
---Purpose: ---Purpose:
--- Gets the intersecton context --- Gets the intersecton context
---
fields fields
myIsDone : Boolean from Standard; myIsDone : Boolean from Standard;
@ -173,7 +170,7 @@ fields
myListOfPnts : ListOfPntOn2S from IntSurf; myListOfPnts : ListOfPntOn2S from IntSurf;
myContext : Context from BOPInt; myContext : Context from IntTools;
end FaceFace from IntTools; end FaceFace from IntTools;

28
src/IntTools/IntTools_FaceFace.cxx
View File

@ -111,7 +111,7 @@
#include <IntTools_TopolTool.hxx> #include <IntTools_TopolTool.hxx>
#include <IntTools_PntOnFace.hxx> #include <IntTools_PntOnFace.hxx>
#include <IntTools_PntOn2Faces.hxx> #include <IntTools_PntOn2Faces.hxx>
#include <BOPInt_Context.hxx> #include <IntTools_Context.hxx>
#include <IntSurf_ListIteratorOfListOfPntOn2S.hxx> #include <IntSurf_ListIteratorOfListOfPntOn2S.hxx>
static static
@ -186,7 +186,7 @@ static
const Standard_Boolean theAvoidLConstructor, const Standard_Boolean theAvoidLConstructor,
IntPatch_SequenceOfLine& theNewLines, IntPatch_SequenceOfLine& theNewLines,
Standard_Real& theReachedTol3d, Standard_Real& theReachedTol3d,
const Handle(BOPInt_Context)& ); const Handle(IntTools_Context)& );
static static
Standard_Boolean ParameterOutOfBoundary(const Standard_Real theParameter, Standard_Boolean ParameterOutOfBoundary(const Standard_Real theParameter,
@ -196,7 +196,7 @@ static
const Standard_Real theOtherParameter, const Standard_Real theOtherParameter,
const Standard_Boolean bIncreasePar, const Standard_Boolean bIncreasePar,
Standard_Real& theNewParameter, Standard_Real& theNewParameter,
const Handle(BOPInt_Context)& ); const Handle(IntTools_Context)& );
static static
Standard_Boolean IsCurveValid(Handle(Geom2d_Curve)& thePCurve); Standard_Boolean IsCurveValid(Handle(Geom2d_Curve)& thePCurve);
@ -225,7 +225,7 @@ static
Handle(TColgp_HArray1OfPnt2d)& theResultOnS1, Handle(TColgp_HArray1OfPnt2d)& theResultOnS1,
Handle(TColgp_HArray1OfPnt2d)& theResultOnS2, Handle(TColgp_HArray1OfPnt2d)& theResultOnS2,
Handle(TColStd_HArray1OfReal)& theResultRadius, Handle(TColStd_HArray1OfReal)& theResultRadius,
const Handle(BOPInt_Context)& ); const Handle(IntTools_Context)& );
static static
Standard_Boolean FindPoint(const gp_Pnt2d& theFirstPoint, Standard_Boolean FindPoint(const gp_Pnt2d& theFirstPoint,
@ -296,7 +296,7 @@ static
const Handle(GeomAdaptor_HSurface) myHS2, const Handle(GeomAdaptor_HSurface) myHS2,
const TopoDS_Face& aF1, const TopoDS_Face& aF1,
const TopoDS_Face& aF2, const TopoDS_Face& aF2,
const Handle(BOPInt_Context)& aCtx); const Handle(IntTools_Context)& aCtx);
static static
Standard_Boolean CheckPCurve(const Handle(Geom2d_Curve)& aPC, Standard_Boolean CheckPCurve(const Handle(Geom2d_Curve)& aPC,
@ -314,7 +314,7 @@ static
const Handle(GeomAdaptor_HSurface)& myHS2, const Handle(GeomAdaptor_HSurface)& myHS2,
const TopoDS_Face& aF1, const TopoDS_Face& aF1,
const TopoDS_Face& aF2, const TopoDS_Face& aF2,
const Handle(BOPInt_Context)& aCtx); const Handle(IntTools_Context)& aCtx);
//======================================================================= //=======================================================================
//function : //function :
@ -336,7 +336,7 @@ IntTools_FaceFace::IntTools_FaceFace()
//function : SetContext //function : SetContext
//purpose : //purpose :
//======================================================================= //=======================================================================
void IntTools_FaceFace::SetContext(const Handle(BOPInt_Context)& aContext) void IntTools_FaceFace::SetContext(const Handle(IntTools_Context)& aContext)
{ {
myContext=aContext; myContext=aContext;
} }
@ -344,7 +344,7 @@ void IntTools_FaceFace::SetContext(const Handle(BOPInt_Context)& aContext)
//function : Context //function : Context
//purpose : //purpose :
//======================================================================= //=======================================================================
const Handle(BOPInt_Context)& IntTools_FaceFace::Context()const const Handle(IntTools_Context)& IntTools_FaceFace::Context()const
{ {
return myContext; return myContext;
} }
@ -522,7 +522,7 @@ static Standard_Boolean isTreatAnalityc(const TopoDS_Face& theF1,
Standard_Boolean RestrictLine = Standard_False, hasCone = Standard_False; Standard_Boolean RestrictLine = Standard_False, hasCone = Standard_False;
if (myContext.IsNull()) { if (myContext.IsNull()) {
myContext=new BOPInt_Context; myContext=new IntTools_Context;
} }
mySeqOfCurve.Clear(); mySeqOfCurve.Clear();
@ -3396,7 +3396,7 @@ Standard_Integer ComputeTangentZones( const Handle(GeomAdaptor_HSurface)& theSur
Handle(TColgp_HArray1OfPnt2d)& theResultOnS1, Handle(TColgp_HArray1OfPnt2d)& theResultOnS1,
Handle(TColgp_HArray1OfPnt2d)& theResultOnS2, Handle(TColgp_HArray1OfPnt2d)& theResultOnS2,
Handle(TColStd_HArray1OfReal)& theResultRadius, Handle(TColStd_HArray1OfReal)& theResultRadius,
const Handle(BOPInt_Context)& aContext) const Handle(IntTools_Context)& aContext)
{ {
Standard_Integer aResult = 0; Standard_Integer aResult = 0;
if ( !CheckTangentZonesExist( theSurface1, theSurface2 ) ) if ( !CheckTangentZonesExist( theSurface1, theSurface2 ) )
@ -3608,7 +3608,7 @@ Standard_Boolean DecompositionOfWLine(const Handle(IntPatch_WLine)& theWLine,
const Standard_Boolean theAvoidLConstructor, const Standard_Boolean theAvoidLConstructor,
IntPatch_SequenceOfLine& theNewLines, IntPatch_SequenceOfLine& theNewLines,
Standard_Real& theReachedTol3d, Standard_Real& theReachedTol3d,
const Handle(BOPInt_Context)& aContext) const Handle(IntTools_Context)& aContext)
{ {
Standard_Boolean bRet, bAvoidLineConstructor; Standard_Boolean bRet, bAvoidLineConstructor;
@ -4333,7 +4333,7 @@ Standard_Boolean ParameterOutOfBoundary(const Standard_Real theParameter,
const Standard_Real theOtherParameter, const Standard_Real theOtherParameter,
const Standard_Boolean bIncreasePar, const Standard_Boolean bIncreasePar,
Standard_Real& theNewParameter, Standard_Real& theNewParameter,
const Handle(BOPInt_Context)& aContext) const Handle(IntTools_Context)& aContext)
{ {
Standard_Boolean bIsComputed = Standard_False; Standard_Boolean bIsComputed = Standard_False;
theNewParameter = theParameter; theNewParameter = theParameter;
@ -4965,7 +4965,7 @@ Standard_Real FindMaxSquareDistance (const Standard_Real aT1,
const Handle(GeomAdaptor_HSurface)& myHS2, const Handle(GeomAdaptor_HSurface)& myHS2,
const TopoDS_Face& myFace1, const TopoDS_Face& myFace1,
const TopoDS_Face& myFace2, const TopoDS_Face& myFace2,
const Handle(BOPInt_Context)& myContext) const Handle(IntTools_Context)& myContext)
{ {
Standard_Real aA, aB, aCf, aX1, aX2, aF1, aF2, aX, aF; Standard_Real aA, aB, aCf, aX1, aX2, aF1, aF2, aX, aF;
// //
@ -5019,7 +5019,7 @@ Standard_Real MaxSquareDistance (const Standard_Real aT,
const Handle(GeomAdaptor_HSurface) myHS2, const Handle(GeomAdaptor_HSurface) myHS2,
const TopoDS_Face& aF1, const TopoDS_Face& aF1,
const TopoDS_Face& aF2, const TopoDS_Face& aF2,
const Handle(BOPInt_Context)& aCtx) const Handle(IntTools_Context)& aCtx)
{ {
Standard_Boolean bIsDone; Standard_Boolean bIsDone;
Standard_Integer i; Standard_Integer i;

14
src/BOPInt/BOPInt_ShrunkRange.cdl → src/IntTools/IntTools_ShrunkRange.cdl
View File

@ -12,7 +12,7 @@
-- Alternatively, this file may be used under the terms of Open CASCADE -- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement. -- commercial license or contractual agreement.
class ShrunkRange from BOPInt class ShrunkRange from IntTools
---Purpose: ---Purpose:
--- The class provides the computation of --- The class provides the computation of
@ -23,14 +23,14 @@ uses
Box from Bnd, Box from Bnd,
Edge from TopoDS, Edge from TopoDS,
Vertex from TopoDS, Vertex from TopoDS,
Context from BOPInt Context from IntTools
--raises --raises
is is
Create Create
returns ShrunkRange from BOPInt; returns ShrunkRange from IntTools;
---C++: alias "Standard_EXPORT virtual ~BOPInt_ShrunkRange();" ---C++: alias "Standard_EXPORT virtual ~IntTools_ShrunkRange();"
SetData (me:out; SetData (me:out;
aE : Edge from TopoDS; aE : Edge from TopoDS;
@ -40,10 +40,10 @@ is
aV2 : Vertex from TopoDS); aV2 : Vertex from TopoDS);
SetContext(me:out; SetContext(me:out;
aCtx: Context from BOPInt); aCtx: Context from IntTools);
Context(me) Context(me)
returns Context from BOPInt; returns Context from IntTools;
---C++: return const & ---C++: return const &
SetShrunkRange(me:out; SetShrunkRange(me:out;
@ -89,7 +89,7 @@ fields
myTS1 : Real from Standard is protected; myTS1 : Real from Standard is protected;
myTS2 : Real from Standard is protected; myTS2 : Real from Standard is protected;
myBndBox : Box from Bnd is protected; myBndBox : Box from Bnd is protected;
myCtx : Context from BOPInt is protected; myCtx : Context from IntTools is protected;
myErrorStatus : Integer from Standard is protected; myErrorStatus : Integer from Standard is protected;
end ShrunkRange; end ShrunkRange;

38
src/BOPInt/BOPInt_ShrunkRange.cxx → src/IntTools/IntTools_ShrunkRange.cxx
View File

@ -12,7 +12,7 @@
// Alternatively, this file may be used under the terms of Open CASCADE // Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement. // commercial license or contractual agreement.
#include <BOPInt_ShrunkRange.ixx> #include <IntTools_ShrunkRange.ixx>
#include <Precision.hxx> #include <Precision.hxx>
@ -25,7 +25,7 @@
#include <BRepBuilderAPI_MakeVertex.hxx> #include <BRepBuilderAPI_MakeVertex.hxx>
#include <BRepAdaptor_Curve.hxx> #include <BRepAdaptor_Curve.hxx>
#include <BndLib_Add3dCurve.hxx> #include <BndLib_Add3dCurve.hxx>
#include <BOPInt_Context.hxx> #include <IntTools_Context.hxx>
#include <gp_Lin.hxx> #include <gp_Lin.hxx>
#include <ElCLib.hxx> #include <ElCLib.hxx>
@ -33,7 +33,7 @@
//function : //function :
//purpose : //purpose :
//======================================================================= //=======================================================================
BOPInt_ShrunkRange::BOPInt_ShrunkRange () IntTools_ShrunkRange::IntTools_ShrunkRange ()
{ {
myT1=-99; myT1=-99;
myT2=myT1; myT2=myT1;
@ -45,18 +45,18 @@
//function : ~ //function : ~
//purpose : //purpose :
//======================================================================= //=======================================================================
BOPInt_ShrunkRange::~BOPInt_ShrunkRange () IntTools_ShrunkRange::~IntTools_ShrunkRange ()
{ {
} }
//======================================================================= //=======================================================================
//function : SetData //function : SetData
//purpose : //purpose :
//======================================================================= //=======================================================================
void BOPInt_ShrunkRange::SetData(const TopoDS_Edge& aE, void IntTools_ShrunkRange::SetData(const TopoDS_Edge& aE,
const Standard_Real aT1, const Standard_Real aT1,
const Standard_Real aT2, const Standard_Real aT2,
const TopoDS_Vertex& aV1, const TopoDS_Vertex& aV1,
const TopoDS_Vertex& aV2) const TopoDS_Vertex& aV2)
{ {
myEdge=aE; myEdge=aE;
myV1=aV1; myV1=aV1;
@ -69,7 +69,7 @@ void BOPInt_ShrunkRange::SetData(const TopoDS_Edge& aE,
//function : SetContext //function : SetContext
//purpose : //purpose :
//======================================================================= //=======================================================================
void BOPInt_ShrunkRange::SetContext(const Handle(BOPInt_Context)& aCtx) void IntTools_ShrunkRange::SetContext(const Handle(IntTools_Context)& aCtx)
{ {
myCtx=aCtx; myCtx=aCtx;
} }
@ -77,7 +77,7 @@ void BOPInt_ShrunkRange::SetContext(const Handle(BOPInt_Context)& aCtx)
//function : Context //function : Context
//purpose : //purpose :
//======================================================================= //=======================================================================
const Handle(BOPInt_Context)& BOPInt_ShrunkRange::Context()const const Handle(IntTools_Context)& IntTools_ShrunkRange::Context()const
{ {
return myCtx; return myCtx;
} }
@ -85,7 +85,7 @@ const Handle(BOPInt_Context)& BOPInt_ShrunkRange::Context()const
//function : Edge //function : Edge
//purpose : //purpose :
//======================================================================= //=======================================================================
const TopoDS_Edge& BOPInt_ShrunkRange::Edge() const const TopoDS_Edge& IntTools_ShrunkRange::Edge() const
{ {
return myEdge; return myEdge;
} }
@ -93,8 +93,8 @@ const TopoDS_Edge& BOPInt_ShrunkRange::Edge() const
//function : ShrunkRange //function : ShrunkRange
//purpose : //purpose :
//======================================================================= //=======================================================================
void BOPInt_ShrunkRange::ShrunkRange(Standard_Real& aT1, void IntTools_ShrunkRange::ShrunkRange(Standard_Real& aT1,
Standard_Real& aT2) const Standard_Real& aT2) const
{ {
aT1=myTS1; aT1=myTS1;
aT2=myTS2; aT2=myTS2;
@ -103,7 +103,7 @@ void BOPInt_ShrunkRange::ShrunkRange(Standard_Real& aT1,
//function : BndBox //function : BndBox
//purpose : //purpose :
//======================================================================= //=======================================================================
const Bnd_Box& BOPInt_ShrunkRange::BndBox() const const Bnd_Box& IntTools_ShrunkRange::BndBox() const
{ {
return myBndBox; return myBndBox;
} }
@ -111,7 +111,7 @@ const Bnd_Box& BOPInt_ShrunkRange::BndBox() const
//function : ErrorStatus //function : ErrorStatus
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Integer BOPInt_ShrunkRange::ErrorStatus() const Standard_Integer IntTools_ShrunkRange::ErrorStatus() const
{ {
return myErrorStatus; return myErrorStatus;
} }
@ -120,8 +120,8 @@ Standard_Integer BOPInt_ShrunkRange::ErrorStatus() const
//function : SetShrunkRange //function : SetShrunkRange
//purpose : //purpose :
//======================================================================= //=======================================================================
void BOPInt_ShrunkRange::SetShrunkRange(const Standard_Real aT1, void IntTools_ShrunkRange::SetShrunkRange(const Standard_Real aT1,
const Standard_Real aT2) const Standard_Real aT2)
{ {
myTS1=aT1; myTS1=aT1;
myTS2=aT2; myTS2=aT2;
@ -134,7 +134,7 @@ void BOPInt_ShrunkRange::SetShrunkRange(const Standard_Real aT1,
//function : Perform //function : Perform
//purpose : //purpose :
//======================================================================= //=======================================================================
void BOPInt_ShrunkRange::Perform() void IntTools_ShrunkRange::Perform()
{ {
Standard_Real aCF, aCL, aTolE, aTolV1; Standard_Real aCF, aCL, aTolE, aTolV1;
Standard_Real aTolV2, t1, t11, t1C, t2, t12, t2C; Standard_Real aTolV2, t1, t11, t1C, t2, t12, t2C;

320
src/IntTools/IntTools_Tools.cdl
View File

@ -15,9 +15,9 @@
class Tools from IntTools class Tools from IntTools
---Purpose: ---Purpose:
--- The class contains handy static functions --- The class contains handy static functions
--- dealing with the geometry and topology. --- dealing with the geometry and topology.
uses uses
Shape from TopoDS, Shape from TopoDS,
@ -28,160 +28,214 @@ uses
Pnt2d from gp, Pnt2d from gp,
Pnt from gp, Pnt from gp,
Dir from gp, Dir from gp,
Lin from gp,
Pln from gp,
CommonPrt from IntTools, CommonPrt from IntTools,
Curve from IntTools, Curve from IntTools,
Range from IntTools,
SequenceOfCurves from IntTools, SequenceOfCurves from IntTools,
Curve from Geom, Curve from Geom,
State from TopAbs State from TopAbs,
Box from Bnd
is is
ComputeVV (myclass;V1,V2:Vertex from TopoDS) ComputeVV (myclass;V1,V2:Vertex from TopoDS)
returns Integer from Standard; returns Integer from Standard;
---Purpose: ---Purpose:
--- Computes distance between vertex V1 and vertex V2, --- Computes distance between vertex V1 and vertex V2,
--- if the distance is less than sum of vertex tolerances --- if the distance is less than sum of vertex tolerances
--- returns zero, --- returns zero,
--- otherwise returns negative value --- otherwise returns negative value
--- ---
HasInternalEdge (myclass; HasInternalEdge (myclass;
aW: Wire from TopoDS) aW: Wire from TopoDS)
returns Boolean from Standard; returns Boolean from Standard;
---Purpose: ---Purpose:
--- Returns True if wire aW contains edges --- Returns True if wire aW contains edges
--- with INTERNAL orientation --- with INTERNAL orientation
--- ---
MakeFaceFromWireAndFace (myclass; MakeFaceFromWireAndFace (myclass;
aW: Wire from TopoDS; aW: Wire from TopoDS;
aF: Face from TopoDS; aF: Face from TopoDS;
aFNew:out Face from TopoDS); aFNew:out Face from TopoDS);
---Purpose: ---Purpose:
--- Build a face based on surface of given face aF --- Build a face based on surface of given face aF
--- and bounded by wire aW --- and bounded by wire aW
--- ---
ClassifyPointByFace (myclass; ClassifyPointByFace (myclass;
aF: Face from TopoDS; aF: Face from TopoDS;
P: Pnt2d from gp) P: Pnt2d from gp)
returns State from TopAbs; returns State from TopAbs;
---Purpose: ---Purpose:
--- ---
--- ---
IsVertex (myclass; E: Edge from TopoDS; IsVertex (myclass; E: Edge from TopoDS;
t: Real from Standard) t: Real from Standard)
returns Boolean from Standard;
---Purpose:
--- Computes square distance between a point on the edge E
--- corresponded to parameter t and vertices of edge E.
--- Returns True if this distance is less than square
--- tolerance of vertex, otherwise returns false.
---
IsVertex (myclass; E: Edge from TopoDS;
V: Vertex from TopoDS;
t: Real from Standard)
returns Boolean from Standard;
---Purpose:
--- Returns True if square distance between vertex V
--- and a point on the edge E corresponded to parameter t
--- is less than square tolerance of V
---
IsVertex (myclass; aCmnPrt: CommonPrt from IntTools)
returns Boolean from Standard;
---Purpose:
--- Returns True if IsVertx for middle parameter of fist range
--- and first edge returns True
--- and if IsVertex for middle parameter of second range and
--- second range returns True,
--- otherwise returns False
---
IsMiddlePointsEqual(myclass;
E1: Edge from TopoDS;
E2: Edge from TopoDS)
returns Boolean from Standard; returns Boolean from Standard;
---Purpose: ---Purpose:
--- Gets boundary of parameters of E1 and E2. --- Computes square distance between a point on the edge E
--- Computes 3d points on each corresponded to average parameters. --- corresponded to parameter t and vertices of edge E.
--- Returns True if distance between computed points is less than --- Returns True if this distance is less than square
--- sum of edge tolerance, otherwise returns False. --- tolerance of vertex, otherwise returns false.
--- ---
IsVertex (myclass; E: Edge from TopoDS;
V: Vertex from TopoDS;
t: Real from Standard)
returns Boolean from Standard;
---Purpose:
--- Returns True if square distance between vertex V
--- and a point on the edge E corresponded to parameter t
--- is less than square tolerance of V
---
IsVertex (myclass; aCmnPrt: CommonPrt from IntTools)
returns Boolean from Standard;
---Purpose:
--- Returns True if IsVertx for middle parameter of fist range
--- and first edge returns True
--- and if IsVertex for middle parameter of second range and
--- second range returns True,
--- otherwise returns False
---
IsMiddlePointsEqual(myclass;
E1: Edge from TopoDS;
E2: Edge from TopoDS)
returns Boolean from Standard;
---Purpose:
--- Gets boundary of parameters of E1 and E2.
--- Computes 3d points on each corresponded to average parameters.
--- Returns True if distance between computed points is less than
--- sum of edge tolerance, otherwise returns False.
---
IsVertex (myclass; IsVertex (myclass;
aP : Pnt from gp; aP : Pnt from gp;
aTolPV: Real from Standard; aTolPV: Real from Standard;
aV: Vertex from TopoDS) aV: Vertex from TopoDS)
returns Boolean from Standard; returns Boolean from Standard;
---Purpose: ---Purpose:
--- Returns True if the distance between point aP and --- Returns True if the distance between point aP and
--- vertex aV is less or equal to sum of aTolPV and --- vertex aV is less or equal to sum of aTolPV and
--- vertex tolerance, otherwise returns False --- vertex tolerance, otherwise returns False
--- ---
IntermediatePoint (myclass; IntermediatePoint (myclass;
aFirst: Real from Standard; aFirst: Real from Standard;
aLast : Real from Standard) aLast : Real from Standard)
returns Real from Standard; returns Real from Standard;
---Purpose: ---Purpose:
--- Returns some value between aFirst and aLast --- Returns some value between aFirst and aLast
--- ---
SplitCurve (myclass; SplitCurve (myclass;
aC : Curve from IntTools; aC : Curve from IntTools;
aS :out SequenceOfCurves from IntTools) aS :out SequenceOfCurves from IntTools)
returns Integer from Standard; returns Integer from Standard;
---Purpose: ---Purpose:
--- Split aC by average parameter if aC is closed in 3D. --- Split aC by average parameter if aC is closed in 3D.
--- Returns positive value if splitting has been done, --- Returns positive value if splitting has been done,
--- otherwise returns zero. --- otherwise returns zero.
--- ---
RejectLines(myclass; RejectLines(myclass;
aSIn: SequenceOfCurves from IntTools; aSIn: SequenceOfCurves from IntTools;
aSOut:out SequenceOfCurves from IntTools); aSOut:out SequenceOfCurves from IntTools);
---Purpose: ---Purpose:
--- Puts curves from aSIn to aSOut except those curves that --- Puts curves from aSIn to aSOut except those curves that
--- are coincide with first curve from aSIn. --- are coincide with first curve from aSIn.
--- ---
IsDirsCoinside (myclass; IsDirsCoinside (myclass;
D1:Dir from gp; D1:Dir from gp;
D2:Dir from gp) D2:Dir from gp)
returns Boolean from Standard; returns Boolean from Standard;
---Purpose: ---Purpose:
--- Returns True if D1 and D2 coinside --- Returns True if D1 and D2 coinside
--- ---
IsDirsCoinside (myclass; IsDirsCoinside (myclass;
D1 :Dir from gp; D1 :Dir from gp;
D2 :Dir from gp; D2 :Dir from gp;
aTol:Real from Standard) aTol:Real from Standard)
returns Boolean from Standard; returns Boolean from Standard;
---Purpose: ---Purpose:
--- Returns True if D1 and D2 coinside with given tolerance --- Returns True if D1 and D2 coinside with given tolerance
--- ---
IsClosed (myclass; IsClosed (myclass;
aC : Curve from Geom) aC : Curve from Geom)
returns Boolean from Standard; returns Boolean from Standard;
---Purpose: ---Purpose:
--- Returns True if aC is BoundedCurve from Geom and --- Returns True if aC is BoundedCurve from Geom and
--- the distance between first point --- the distance between first point
--- of the curve aC and last point --- of the curve aC and last point
--- is less than 1.e-12 --- is less than 1.e-12
--- ---
CurveTolerance(myclass; CurveTolerance(myclass;
aC : Curve from Geom; aC : Curve from Geom;
aTolBase : Real from Standard) aTolBase : Real from Standard)
returns Real from Standard; returns Real from Standard;
---Purpose: ---Purpose:
--- Returns adaptive tolerance for given aTolBase --- Returns adaptive tolerance for given aTolBase
--- if aC is trimmed curve and basis curve is parabola, --- if aC is trimmed curve and basis curve is parabola,
--- otherwise returns value of aTolBase --- otherwise returns value of aTolBase
--- ---
--~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
CheckCurve(myclass;
theC:Curve from Geom;
theTol:Real from Standard;
theBox:out Box from Bnd)
returns Boolean from Standard;
IsOnPave(myclass;
theT:Real from Standard;
theRange:Range from IntTools;
theTol: Real from Standard)
returns Boolean from Standard;
VertexParameters(myclass;
theCP:CommonPrt from IntTools;
theT1:out Real from Standard;
theT2:out Real from Standard);
VertexParameter(myclass;
theCP:CommonPrt from IntTools;
theT:out Real from Standard);
IsOnPave1(myclass;
theT:Real from Standard;
theRange:Range from IntTools;
theTol: Real from Standard)
returns Boolean from Standard;
IsInRange(myclass;
theRRef : Range from IntTools;
theR : Range from IntTools;
theTol : Real from Standard)
returns Boolean from Standard;
---Purpose: Checks if the range <theR> interfere with the range <theRRef>
SegPln(myclass;
theLin : Lin from gp;
theTLin1 : Real from Standard;
theTLin2 : Real from Standard;
theTolLin: Real from Standard;
thePln : Pln from gp;
theTolPln: Real from Standard;
theP :out Pnt from gp;
theT :out Real from Standard;
theTolP :out Real from Standard;
theTmin :out Real from Standard;
theTmax :out Real from Standard)
returns Integer from Standard;
end Tools; end Tools;

270
src/IntTools/IntTools_Tools.cxx
View File

@ -61,11 +61,11 @@
static static
void ParabolaTolerance(const Handle(Geom_Curve)& , void ParabolaTolerance(const Handle(Geom_Curve)& ,
const Standard_Real , const Standard_Real ,
const Standard_Real , const Standard_Real ,
const Standard_Real , const Standard_Real ,
Standard_Real& , Standard_Real& ,
Standard_Real& ); Standard_Real& );
//======================================================================= //=======================================================================
//function : HasInternalEdge //function : HasInternalEdge
@ -110,16 +110,11 @@ static
// //
//modified by NIZNHY-PKV Mon Jul 04 11:58:23 2011f
aPC=Precision::Confusion(); aPC=Precision::Confusion();
aPC=aPC*aPC; aPC=aPC*aPC;
aDist=aP1.SquareDistance(aP2); aDist=aP1.SquareDistance(aP2);
bRet=aDist<aPC; bRet=aDist<aPC;
return bRet; return bRet;
//
//aDist=aP1.Distance(aP2);
//return (aDist < Precision::Confusion());
//modified by NIZNHY-PKV Mon Jul 04 11:59:50 2011t
} }
//======================================================================= //=======================================================================
@ -127,7 +122,7 @@ static
//purpose : //purpose :
//======================================================================= //=======================================================================
void IntTools_Tools::RejectLines(const IntTools_SequenceOfCurves& aSIn, void IntTools_Tools::RejectLines(const IntTools_SequenceOfCurves& aSIn,
IntTools_SequenceOfCurves& aSOut) IntTools_SequenceOfCurves& aSOut)
{ {
Standard_Integer i, j, aNb; Standard_Integer i, j, aNb;
Standard_Boolean bFlag; Standard_Boolean bFlag;
@ -157,7 +152,7 @@ static
if (aGLine.IsNull()) { if (aGLine.IsNull()) {
aSOut.Clear(); aSOut.Clear();
for (j=1; j<=aNb; j++) { for (j=1; j<=aNb; j++) {
aSOut.Append(aSIn(j)); aSOut.Append(aSIn(j));
} }
return; return;
} }
@ -198,8 +193,8 @@ static
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean IntTools_Tools::IsDirsCoinside (const gp_Dir& D1, Standard_Boolean IntTools_Tools::IsDirsCoinside (const gp_Dir& D1,
const gp_Dir& D2, const gp_Dir& D2,
const Standard_Real dLim) const Standard_Real dLim)
{ {
Standard_Boolean bFlag; Standard_Boolean bFlag;
Standard_Real d; Standard_Real d;
@ -215,7 +210,7 @@ static
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Integer IntTools_Tools::SplitCurve(const IntTools_Curve& IC, Standard_Integer IntTools_Tools::SplitCurve(const IntTools_Curve& IC,
IntTools_SequenceOfCurves& aCvs) IntTools_SequenceOfCurves& aCvs)
{ {
Handle (Geom_Curve) aC3D =IC.Curve(); Handle (Geom_Curve) aC3D =IC.Curve();
if(aC3D.IsNull()) if(aC3D.IsNull())
@ -277,7 +272,7 @@ static
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Real IntTools_Tools::IntermediatePoint (const Standard_Real aFirst, Standard_Real IntTools_Tools::IntermediatePoint (const Standard_Real aFirst,
const Standard_Real aLast) const Standard_Real aLast)
{ {
//define parameter division number as 10*e^(-M_PI) = 0.43213918 //define parameter division number as 10*e^(-M_PI) = 0.43213918
const Standard_Real PAR_T = 0.43213918; const Standard_Real PAR_T = 0.43213918;
@ -291,8 +286,8 @@ static
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean IntTools_Tools::IsVertex (const gp_Pnt& aP, Standard_Boolean IntTools_Tools::IsVertex (const gp_Pnt& aP,
const Standard_Real aTolPV, const Standard_Real aTolPV,
const TopoDS_Vertex& aV) const TopoDS_Vertex& aV)
{ {
Standard_Boolean bRet; Standard_Boolean bRet;
Standard_Real aTolV, aD, dTol; Standard_Real aTolV, aD, dTol;
@ -305,15 +300,10 @@ static
// //
aPv=BRep_Tool::Pnt(aV); aPv=BRep_Tool::Pnt(aV);
// //
//modified by NIZNHY-PKV Mon Jul 04 12:00:37 2011f
aD=aPv.SquareDistance(aP); aD=aPv.SquareDistance(aP);
aTolV=aTolV*aTolV; aTolV=aTolV*aTolV;
bRet=(aD<=aTolV); bRet=(aD<=aTolV);
return bRet; return bRet;
//
//aD=aPv.Distance(aP);
//return (aD<=aTolV);
//modified by NIZNHY-PKV Mon Jul 04 12:00:40 2011t
} }
@ -351,8 +341,8 @@ static
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean IntTools_Tools::IsVertex (const TopoDS_Edge& aE, Standard_Boolean IntTools_Tools::IsVertex (const TopoDS_Edge& aE,
const TopoDS_Vertex& aV, const TopoDS_Vertex& aV,
const Standard_Real t) const Standard_Real t)
{ {
Standard_Real aTolV, aTolV2, d2; Standard_Real aTolV, aTolV2, d2;
gp_Pnt aPv, aPt; gp_Pnt aPv, aPt;
@ -374,7 +364,7 @@ static
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean IntTools_Tools::IsVertex (const TopoDS_Edge& aE, Standard_Boolean IntTools_Tools::IsVertex (const TopoDS_Edge& aE,
const Standard_Real t) const Standard_Real t)
{ {
Standard_Real aTolV, aTolV2, d2; Standard_Real aTolV, aTolV2, d2;
TopoDS_Vertex aV; TopoDS_Vertex aV;
@ -404,7 +394,7 @@ static
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Integer IntTools_Tools::ComputeVV(const TopoDS_Vertex& aV1, Standard_Integer IntTools_Tools::ComputeVV(const TopoDS_Vertex& aV1,
const TopoDS_Vertex& aV2) const TopoDS_Vertex& aV2)
{ {
Standard_Real aTolV1, aTolV2, aTolSum, d; Standard_Real aTolV1, aTolV2, aTolSum, d;
gp_Pnt aP1, aP2; gp_Pnt aP1, aP2;
@ -415,11 +405,8 @@ static
aP1=BRep_Tool::Pnt(aV1); aP1=BRep_Tool::Pnt(aV1);
aP2=BRep_Tool::Pnt(aV2); aP2=BRep_Tool::Pnt(aV2);
//modified by NIZNHY-PKV Mon Jul 04 11:55:52 2011f
aTolSum=aTolSum*aTolSum; aTolSum=aTolSum*aTolSum;
d=aP1.SquareDistance(aP2); d=aP1.SquareDistance(aP2);
//d=aP1.Distance(aP2);
//modified by NIZNHY-PKV Mon Jul 04 11:55:53 2011t
if (d<aTolSum) { if (d<aTolSum) {
return 0; return 0;
} }
@ -431,8 +418,8 @@ static
//purpose : //purpose :
//======================================================================= //=======================================================================
void IntTools_Tools::MakeFaceFromWireAndFace(const TopoDS_Wire& aW, void IntTools_Tools::MakeFaceFromWireAndFace(const TopoDS_Wire& aW,
const TopoDS_Face& aF, const TopoDS_Face& aF,
TopoDS_Face& aFNew) TopoDS_Face& aFNew)
{ {
TopoDS_Face aFF; TopoDS_Face aFF;
aFF=aF; aFF=aF;
@ -447,7 +434,7 @@ static
//purpose : //purpose :
//======================================================================= //=======================================================================
TopAbs_State IntTools_Tools::ClassifyPointByFace(const TopoDS_Face& aF, TopAbs_State IntTools_Tools::ClassifyPointByFace(const TopoDS_Face& aF,
const gp_Pnt2d& aP2d) const gp_Pnt2d& aP2d)
{ {
Standard_Real aFaceTolerance; Standard_Real aFaceTolerance;
TopAbs_State aState; TopAbs_State aState;
@ -464,8 +451,8 @@ static
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean IntTools_Tools::IsMiddlePointsEqual(const TopoDS_Edge& aE1, Standard_Boolean IntTools_Tools::IsMiddlePointsEqual(const TopoDS_Edge& aE1,
const TopoDS_Edge& aE2) const TopoDS_Edge& aE2)
{ {
Standard_Boolean bRet; Standard_Boolean bRet;
Standard_Real f1, l1, m1, f2, l2, m2, aTol1, aTol2, aSumTol, aD2; Standard_Real f1, l1, m1, f2, l2, m2, aTol1, aTol2, aSumTol, aD2;
@ -482,17 +469,10 @@ static
C2->D0(m2, aP2); C2->D0(m2, aP2);
aSumTol=aTol1+aTol2; aSumTol=aTol1+aTol2;
//modified by NIZNHY-PKV Mon Jul 04 12:02:20 2011f
aSumTol=aSumTol*aSumTol; aSumTol=aSumTol*aSumTol;
aD2=aP1.SquareDistance(aP2); aD2=aP1.SquareDistance(aP2);
bRet=aD2<aSumTol; bRet=aD2<aSumTol;
return bRet; return bRet;
//
//if (aP1.Distance(aP2) < aSumTol) {
// return Standard_True;
//}
//return Standard_False;
//modified by NIZNHY-PKV Mon Jul 04 12:02:24 2011t
} }
//======================================================================= //=======================================================================
@ -500,7 +480,7 @@ static
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Real IntTools_Tools::CurveTolerance(const Handle(Geom_Curve)& aC3D, Standard_Real IntTools_Tools::CurveTolerance(const Handle(Geom_Curve)& aC3D,
const Standard_Real aTolBase) const Standard_Real aTolBase)
{ {
Standard_Real aTolReached, aTf, aTl, aTolMin, aTolMax; Standard_Real aTolReached, aTf, aTl, aTolMin, aTolMax;
@ -535,16 +515,17 @@ static
#include <Geom_Parabola.hxx> #include <Geom_Parabola.hxx>
#include <gp_Parab.hxx> #include <gp_Parab.hxx>
#include <BndLib_Add3dCurve.hxx>
//======================================================================= //=======================================================================
//function : ParabolaTolerance //function : ParabolaTolerance
//purpose : //purpose :
//======================================================================= //=======================================================================
void ParabolaTolerance(const Handle(Geom_Curve)& aC3D, void ParabolaTolerance(const Handle(Geom_Curve)& aC3D,
const Standard_Real aTf, const Standard_Real aTf,
const Standard_Real aTl, const Standard_Real aTl,
const Standard_Real aTol, const Standard_Real aTol,
Standard_Real& aTolMin, Standard_Real& aTolMin,
Standard_Real& aTolMax) Standard_Real& aTolMax)
{ {
aTolMin=aTol; aTolMin=aTol;
@ -603,4 +584,197 @@ void ParabolaTolerance(const Handle(Geom_Curve)& aC3D,
aTolMax=(aTol1>aTol2) ? aTol1 : aTol2; aTolMax=(aTol1>aTol2) ? aTol1 : aTol2;
aTolMin=(aTol1<aTol2) ? aTol1 : aTol2; aTolMin=(aTol1<aTol2) ? aTol1 : aTol2;
} }
/////////////////////////////////////////////////////////////////////////
//=======================================================================
//function : CheckCurve
//purpose :
//=======================================================================
Standard_Boolean IntTools_Tools::CheckCurve(const Handle (Geom_Curve)& aC3D,
const Standard_Real aTolR3D,
Bnd_Box& aBox)
{
Standard_Boolean bRet;
Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax, dX, dY, dZ;
Standard_Real dS, aTol;
GeomAdaptor_Curve aGAC;
//
aGAC.Load(aC3D);
BndLib_Add3dCurve::Add(aGAC, aTolR3D, aBox);
// 910/B1
aBox.Get(aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
dX=aXmax-aXmin;
dY=aYmax-aYmin;
dZ=aZmax-aZmin;
dS=1.e-12;
aTol=2.*aTolR3D+dS;
bRet=(dX>aTol || dY>aTol || dZ>aTol);
//
return bRet;
}
//=======================================================================
//function : IsOnPave
//purpose :
//=======================================================================
Standard_Boolean IntTools_Tools::IsOnPave(const Standard_Real aT1,
const IntTools_Range& aRange,
const Standard_Real aTolerance)
{
Standard_Boolean firstisonpave1, firstisonpave2, bIsOnPave;
//
firstisonpave1 = (Abs(aRange.First() - aT1) < aTolerance);
firstisonpave2 = (Abs(aRange.Last() - aT1) < aTolerance);
bIsOnPave=(firstisonpave1 || firstisonpave2);
return bIsOnPave;
}
//=======================================================================
// function: VertexParameters
// purpose:
//=======================================================================
void IntTools_Tools::VertexParameters(const IntTools_CommonPrt& aCPart,
Standard_Real& aT1,
Standard_Real& aT2)
{
const IntTools_Range& aR1=aCPart.Range1();
aT1=0.5*(aR1.First()+aR1.Last());
//
if((aCPart.VertexParameter1() >= aR1.First()) &&
(aCPart.VertexParameter1() <= aR1.Last())) {
aT1 = aCPart.VertexParameter1();
}
//
const IntTools_SequenceOfRanges& aRanges2=aCPart.Ranges2();
const IntTools_Range& aR2=aRanges2(1);
aT2=0.5*(aR2.First()+aR2.Last());
//
if((aCPart.VertexParameter2() >= aR2.First()) &&
(aCPart.VertexParameter2() <= aR2.Last())) {
aT2 = aCPart.VertexParameter2();
}
}
//=======================================================================
// function: VertexParameter
// purpose:
//=======================================================================
void IntTools_Tools::VertexParameter(const IntTools_CommonPrt& aCPart,
Standard_Real& aT)
{
const IntTools_Range& aR=aCPart.Range1();
aT=0.5*(aR.First()+aR.Last());
if((aCPart.VertexParameter1() >= aR.First()) &&
(aCPart.VertexParameter1() <= aR.Last())) {
aT = aCPart.VertexParameter1();
}
}
//=======================================================================
// function: IsOnPave1
// purpose:
//=======================================================================
Standard_Boolean IntTools_Tools::IsOnPave1(const Standard_Real aTR,
const IntTools_Range& aCPRange,
const Standard_Real aTolerance)
{
Standard_Boolean bIsOnPave;
Standard_Real aT1, aT2, dT1, dT2;
//
aT1=aCPRange.First();
aT2=aCPRange.Last();
bIsOnPave=(aTR>=aT1 && aTR<=aT1);
if (bIsOnPave) {
return bIsOnPave;
}
//
dT1=Abs(aTR-aT1);
dT2=Abs(aTR-aT2);
bIsOnPave=(dT1<=aTolerance || dT2<=aTolerance);
return bIsOnPave;
}
//=======================================================================
// function: IsInRange
// purpose:
//=======================================================================
Standard_Boolean IntTools_Tools::IsInRange(const IntTools_Range& aRRef,
const IntTools_Range& aR,
const Standard_Real aTolerance)
{
Standard_Boolean bIsIn;
Standard_Real aT1, aT2, aTRef1, aTRef2;
//
aR.Range(aT1, aT2);
aRRef.Range(aTRef1, aTRef2);
//
aTRef1-=aTolerance;
aTRef2+=aTolerance;
//
bIsIn = (aT1>=aTRef1 && aT1<=aTRef2) ||
(aT2>=aTRef1 && aT2<=aTRef2);
//
return bIsIn;
}
//=======================================================================
//function : SegPln
//purpose :
//=======================================================================
Standard_Integer IntTools_Tools::SegPln(const gp_Lin& theLin,
const Standard_Real theTLin1,
const Standard_Real theTLin2,
const Standard_Real theTolLin,
const gp_Pln& thePln,
const Standard_Real theTolPln,
gp_Pnt& theP,
Standard_Real& theTP,
Standard_Real& theTolP,
Standard_Real& theTPmin,
Standard_Real& theTPmax)
{
Standard_Integer iRet;
Standard_Real aTol, aA, aB, aC, aD, aE, aH, aTP, aDist1, aDist2;
gp_Pnt aP1, aP2;
//
iRet=0;
aTol=theTolLin+theTolPln;
//
const gp_Ax3& aPosPln=thePln.Position();
const gp_Dir& aDirPln=aPosPln.Direction();
const gp_Pnt& aLocPln=aPosPln.Location();
//
const gp_Dir& aDirLin=theLin.Direction();
const gp_Pnt& aLocLin=theLin.Location();
//
aP1.SetXYZ(aLocLin.XYZ()+theTLin1*aDirLin.XYZ());
aDist1=aDirPln.X()*(aP1.X()-aLocPln.X())+
aDirPln.Y()*(aP1.Y()-aLocPln.Y())+
aDirPln.Z()*(aP1.Z()-aLocPln.Z());
//
aP2.SetXYZ(aLocLin.XYZ()+theTLin2*aDirLin.XYZ());
aDist2=aDirPln.X()*(aP2.X()-aLocPln.X())+
aDirPln.Y()*(aP2.Y()-aLocPln.Y())+
aDirPln.Z()*(aP2.Z()-aLocPln.Z());
//
if (aDist1<aTol && aDist2<aTol){
iRet=1; // common block
return iRet;
}
//
if (aDist1*aDist2 > 0.) {
iRet=2; // segment lays on one side to the Plane
return iRet;
}
//
thePln.Coefficients(aA, aB, aC, aD);
aE=aA*aLocLin.X()+aB*aLocLin.Y()+aC*aLocLin.Z()+aD;
aH=aA*aDirLin.X()+aB*aDirLin.Y()+aC*aDirLin.Z();
aTP=-aE/aH;
if (aTP < theTLin1-aTol || aTP > theTLin2+aTol) {
iRet=3; // no intersections due to range of the Line
return iRet;
}
//
theTP=aTP;
theP.SetXYZ(aLocLin.XYZ()+aTP*aDirLin.XYZ());
theTolP=aTol;
theTPmin=theTP-theTolPln;
theTPmax=theTP+theTolPln;
iRet=0; // intersection point
return iRet;
}

2
src/QANewModTopOpe/QANewModTopOpe_Tools.cxx
View File

@ -24,7 +24,7 @@
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>
#include <BRep_Builder.hxx> #include <BRep_Builder.hxx>
#include <Geom_Surface.hxx> #include <Geom_Surface.hxx>
#include <BOPInt_Context.hxx> #include <IntTools_Context.hxx>
#include <TopExp_Explorer.hxx> #include <TopExp_Explorer.hxx>
#include <TopExp.hxx> #include <TopExp.hxx>
#include <GeomAPI_ProjectPointOnSurf.hxx> #include <GeomAPI_ProjectPointOnSurf.hxx>

1
src/TKBO/PACKAGES
View File

@ -1,7 +1,6 @@
IntTools IntTools
BRepAlgoAPI BRepAlgoAPI
BOPCol BOPCol
BOPInt
BOPDS BOPDS
BOPAlgo BOPAlgo
BOPTools BOPTools