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

0025609: Clean up the duplicate classes in TKBO project

Browse Source 
1. The package BOPCol has been fully removed:
- *BOPCol_BaseAllocator* is replaced with *Handle(NCollection_BaseAllocator)*;
- *BOPCol_BoxBndTree* is replaced with *BOPTools_BoxBndTree*;
- *BOPCol_Box2DBndTree* is removed as unused;
- *BOPCol_DataMapOfIntegerInteger* is replaced with *TColStd_DataMapOfIntegerInteger*;
- *BOPCol_DataMapOfIntegerListOfInteger* is replaced with *TColStd_DataMapOfIntegerListOfInteger*;
- *BOPCol_DataMapOfIntegerListOfShape* is replaced with *TopTools_DataMapOfIntegerListOfShape*;
- *BOPCol_DataMapOfIntegerMapOfInteger.hxx* is removed as unused;
- *BOPCol_DataMapOfIntegerReal* is replaced with *TColStd_DataMapOfIntegerReal*;
- *BOPCol_DataMapOfIntegerShape* is replaced with *TopTools_DataMapOfIntegerShape*;
- *BOPCol_DataMapOfShapeBox* is replaced with *TopTools_DataMapOfShapeBox*;
- *BOPCol_DataMapOfShapeInteger* is replaced with *TopTools_DataMapOfShapeInteger*;
- *BOPCol_DataMapOfShapeListOfShape* is replaced with *TopTools_DataMapOfShapeListOfShape*;
- *BOPCol_DataMapOfShapeReal* is replaced with *TopTools_DataMapOfShapeReal*;
- *BOPCol_DataMapOfShapeShape* is replaced with *TopTools_DataMapOfShapeShape*;
- *BOPCol_DataMapOfTransientAddress* is removed as unused;
- *BOPCol_IndexedDataMapOfIntegerListOfInteger* is removed as unused;
- *BOPCol_IndexedDataMapOfShapeBox* is removed as unused;
- *BOPCol_IndexedDataMapOfShapeInteger* is removed as unused;
- *BOPCol_IndexedDataMapOfShapeListOfShape* is replaced with *TopTools_IndexedDataMapOfShapeListOfShape*;
- *BOPCol_IndexedDataMapOfShapeReal* is removed as unused;
- *BOPCol_IndexedDataMapOfShapeShape* is replaced with *TopTools_IndexedDataMapOfShapeShape*;
- *BOPCol_IndexedMapOfInteger* is replaced with *TColStd_IndexedMapOfInteger*;
- *BOPCol_IndexedMapOfOrientedShape* is replaced with *TopTools_IndexedMapOfOrientedShape*;
- *BOPCol_IndexedMapOfShape* is replaced with *TopTools_IndexedMapOfShape*;
- *BOPCol_ListOfInteger* is replaced with *TColStd_ListOfInteger*;
- *BOPCol_ListOfListOfShape* is replaced with *TopTools_ListOfListOfShape*;
- *BOPCol_ListOfShape* is replaced with *TopTools_ListOfShape*;
- *BOPCol_MapOfInteger* is replaced with *TColStd_MapOfInteger*;
- *BOPCol_MapOfOrientedShape* is replaced with *TopTools_MapOfOrientedShape*;
- *BOPCol_MapOfShape* is replaced with *TopTools_MapOfShape*;
- *BOPCol_PListOfInteger* is removed as unused;
- *BOPCol_PInteger* is removed as unused
- *BOPCol_SequenceOfPnt2d* is replaced with *TColgp_SequenceOfPnt2d*;
- *BOPCol_SequenceOfReal* is replaced with *TColStd_SequenceOfReal*;
- *BOPCol_SequenceOfShape* is replaced with *TopTools_SequenceOfShape*;
- *BOPCol_Parallel* is replaced with *BOPTools_Parallel*;
- *BOPCol_NCVector* is replaced with *NCollection_Vector*;

2. The class *BOPDS_PassKey* and containers for it have been removed as unused;

3. The unused containers from *IntTools* package have been removed:
- *IntTools_DataMapOfShapeAddress* is removed as unused;
- *IntTools_IndexedDataMapOfTransientAddress* is removed as unused;

4. The container *BiTgte_DataMapOfShapeBox* is replaced with *TopTools_DataMapOfShapeBox*;

5. The class *BOPTools* has been removed as duplicate of the class *TopExp*;
This commit is contained in:
emv 2017-11-23 10:57:25 +03:00 committed by bugmaster
parent 2da5126371
commit 1155d05a06
210 changed files with 2355 additions and 4551 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
dox/dev_guides/upgrade/upgrade.md
View File

@ -1453,3 +1453,51 @@ The following public method has been removed:
The methods BuildPCurveForEdgeOnPlane and BuildPCurveForEdgesOnPlane have been moved from the class BOPTools_AlgoTools2D
to the more lower level class BRepLib.
@subsection upgrade_721_removed Removed features
The following obsolete features have been removed:
* The package BOPCol has been fully removed:
- *BOPCol_BaseAllocator* is replaced with *Handle(NCollection_BaseAllocator)*;
- *BOPCol_BoxBndTree* is replaced with *BOPTools_BoxBndTree*;
- *BOPCol_Box2DBndTree* is removed as unused;
- *BOPCol_DataMapOfIntegerInteger* is replaced with *TColStd_DataMapOfIntegerInteger*;
- *BOPCol_DataMapOfIntegerListOfInteger* is replaced with *TColStd_DataMapOfIntegerListOfInteger*;
- *BOPCol_DataMapOfIntegerListOfShape* is replaced with *TopTools_DataMapOfIntegerListOfShape*;
- *BOPCol_DataMapOfIntegerMapOfInteger.hxx* is removed as unused;
- *BOPCol_DataMapOfIntegerReal* is replaced with *TColStd_DataMapOfIntegerReal*;
- *BOPCol_DataMapOfIntegerShape* is replaced with *TopTools_DataMapOfIntegerShape*;
- *BOPCol_DataMapOfShapeBox* is replaced with *TopTools_DataMapOfShapeBox*;
- *BOPCol_DataMapOfShapeInteger* is replaced with *TopTools_DataMapOfShapeInteger*;
- *BOPCol_DataMapOfShapeListOfShape* is replaced with *TopTools_DataMapOfShapeListOfShape*;
- *BOPCol_DataMapOfShapeReal* is replaced with *TopTools_DataMapOfShapeReal*;
- *BOPCol_DataMapOfShapeShape* is replaced with *TopTools_DataMapOfShapeShape*;
- *BOPCol_DataMapOfTransientAddress* is removed as unused;
- *BOPCol_IndexedDataMapOfIntegerListOfInteger* is removed as unused;
- *BOPCol_IndexedDataMapOfShapeBox* is removed as unused;
- *BOPCol_IndexedDataMapOfShapeInteger* is removed as unused;
- *BOPCol_IndexedDataMapOfShapeListOfShape* is replaced with *TopTools_IndexedDataMapOfShapeListOfShape*;
- *BOPCol_IndexedDataMapOfShapeReal* is removed as unused;
- *BOPCol_IndexedDataMapOfShapeShape* is replaced with *TopTools_IndexedDataMapOfShapeShape*;
- *BOPCol_IndexedMapOfInteger* is replaced with *TColStd_IndexedMapOfInteger*;
- *BOPCol_IndexedMapOfOrientedShape* is replaced with *TopTools_IndexedMapOfOrientedShape*;
- *BOPCol_IndexedMapOfShape* is replaced with *TopTools_IndexedMapOfShape*;
- *BOPCol_ListOfInteger* is replaced with *TColStd_ListOfInteger*;
- *BOPCol_ListOfListOfShape* is replaced with *TopTools_ListOfListOfShape*;
- *BOPCol_ListOfShape* is replaced with *TopTools_ListOfShape*;
- *BOPCol_MapOfInteger* is replaced with *TColStd_MapOfInteger*;
- *BOPCol_MapOfOrientedShape* is replaced with *TopTools_MapOfOrientedShape*;
- *BOPCol_MapOfShape* is replaced with *TopTools_MapOfShape*;
- *BOPCol_PListOfInteger* is removed as unused;
- *BOPCol_PInteger* is removed as unused
- *BOPCol_SequenceOfPnt2d* is replaced with *TColgp_SequenceOfPnt2d*;
- *BOPCol_SequenceOfReal* is replaced with *TColStd_SequenceOfReal*;
- *BOPCol_SequenceOfShape* is replaced with *TopTools_SequenceOfShape*;
- *BOPCol_Parallel* is replaced with *BOPTools_Parallel*;
- *BOPCol_NCVector* is replaced with *NCollection_Vector*;
* The class *BOPDS_PassKey* and containers for it have been removed as unused.
* The unused containers from *IntTools* package have been removed:
- *IntTools_DataMapOfShapeAddress* is removed as unused;
- *IntTools_IndexedDataMapOfTransientAddress* is removed as unused;
* The container *BiTgte_DataMapOfShapeBox* is replaced with *TopTools_DataMapOfShapeBox*;
* The class *BOPTools* has been removed as duplicate of the class *TopExp*;

12
dox/user_guides/boolean_operations/boolean_operations.md
View File

@ -1082,8 +1082,8 @@ It is based on the General Fuse algorithm, thus all options of the General Fuse
On the low level the Splitter algorithm is implemented in class *BOPAlgo_Splitter*. The usage of this algorithm looks as follows:
~~~~~
BOPAlgo_Splitter aSplitter;
BOPCol_ListOfShape aLSObjects = …; // Objects
BOPCol_ListOfShape aLSTools = …; // Tools
TopTools_ListOfShape aLSObjects = …; // Objects
TopTools_ListOfShape aLSTools = …; // Tools
Standard_Boolean bRunParallel = Standard_False; /* parallel or single mode (the default value is FALSE)*/
Standard_Real aTol = 0.0; /* fuzzy option (default value is 0)*/
Standard_Boolean bSafeMode = Standard_False; /* protect or not the arguments from modification*/
@ -2054,7 +2054,7 @@ This option is useful e.g. for building a solid from the faces of one shell or f
The usage of the algorithm on the API level:
~~~~
BOPAlgo_MakerVolume aMV;
BOPCol_ListOfShape aLS = …; // arguments
TopTools_ListOfShape aLS = …; // arguments
Standard_Boolean bRunParallel = Standard_False; /* parallel or single mode (the default value is FALSE)*/
Standard_Boolean bIntersect = Standard_True; /* intersect or not the arguments (the default value is TRUE)*/
Standard_Real aTol = 0.0; /* fuzzy option (default value is 0)*/
@ -2148,7 +2148,7 @@ It is possible to create typed Containers from the parts added into result by us
Here is the example of the algorithm use on the API level:
~~~~
BOPAlgo_CellsBuilder aCBuilder;
BOPCol_ListOfShape aLS = …; // arguments
TopTools_ListOfShape aLS = …; // arguments
Standard_Boolean bRunParallel = Standard_False; /* parallel or single mode (the default value is FALSE)*/
Standard_Real aTol = 0.0; /* fuzzy option (the default value is 0)*/
Standard_Boolean bSafeMode = Standard_False; /* protect or not the arguments from modification*/
@ -2169,8 +2169,8 @@ if (aCBuilder.HasErrors()) { // check error status
const TopoDS_Shape& anEmptyRes = aCBuilder.Shape(); // empty result, as nothing has been added yet
const TopoDS_Shape& anAllCells = aCBuilder.GetAllParts(); //all split parts
//
BOPCol_ListOfShape aLSToTake = ...; // parts of these arguments will be taken into result
BOPCol_ListOfShape aLSToAvoid = ...; // parts of these arguments will not be taken into result
TopTools_ListOfShape aLSToTake = ...; // parts of these arguments will be taken into result
TopTools_ListOfShape aLSToAvoid = ...; // parts of these arguments will not be taken into result
//
Standard_Integer iMaterial = 1; // defines the material for the cells
Standard_Boolean bUpdate = Standard_False; // defines whether to update the result right now or not

4
src/BOPAlgo/BOPAlgo_Algo.hxx
View File

@ -24,8 +24,6 @@
#include <BOPAlgo_Options.hxx>
#include <BOPCol_DataMapOfIntegerListOfShape.hxx>
//! The class provides the root interface for the algorithms in Boolean Component.<br>
class BOPAlgo_Algo : public BOPAlgo_Options
{
@ -41,7 +39,7 @@ protected:
Standard_EXPORT BOPAlgo_Algo();
Standard_EXPORT virtual ~BOPAlgo_Algo();
Standard_EXPORT BOPAlgo_Algo(const BOPCol_BaseAllocator& theAllocator);
Standard_EXPORT BOPAlgo_Algo(const Handle(NCollection_BaseAllocator)& theAllocator);
//! Checks input data
Standard_EXPORT virtual void CheckData();

30
src/BOPAlgo/BOPAlgo_ArgumentAnalyzer.cxx
View File

@ -16,13 +16,8 @@
#include <BOPAlgo_BuilderFace.hxx>
#include <BOPAlgo_CheckerSI.hxx>
#include <BOPAlgo_Operation.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <BOPCol_IndexedMapOfShape.hxx>
#include <BOPCol_SequenceOfShape.hxx>
#include <BOPDS_DS.hxx>
#include <BOPDS_MapOfPair.hxx>
#include <BOPTools.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_AlgoTools3D.hxx>
#include <BRep_Builder.hxx>
@ -50,6 +45,11 @@
#include <TopoDS_Solid.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Wire.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopTools_SequenceOfShape.hxx>
// ================================================================================
// function: Constructor
// purpose:
@ -353,7 +353,7 @@ void BOPAlgo_ArgumentAnalyzer::TestSelfInterferences()
//
Standard_Integer n1, n2;
BOPDS_MapIteratorOfMapOfPair aItMPK;
BOPCol_ListOfShape anArgs;
TopTools_ListOfShape anArgs;
BOPAlgo_CheckerSI aChecker;
//
anArgs.Append(aS);
@ -535,7 +535,7 @@ void BOPAlgo_ArgumentAnalyzer::TestRebuildFace()
continue;
TopExp_Explorer anExp(aS, TopAbs_FACE);
BOPCol_ListOfShape aLS;
TopTools_ListOfShape aLS;
for(; anExp.More(); anExp.Next()) {
const TopoDS_Face& aFace = *(TopoDS_Face*)&(anExp.Current());
@ -566,7 +566,7 @@ void BOPAlgo_ArgumentAnalyzer::TestRebuildFace()
aBF.SetFace(aFace);
aBF.SetShapes(aLS);
aBF.Perform();
const BOPCol_ListOfShape& aLF = aBF.Areas();
const TopTools_ListOfShape& aLF = aBF.Areas();
Standard_Boolean bBadFace = Standard_False;
if(aLF.Extent() != 1) {
@ -647,8 +647,8 @@ void BOPAlgo_ArgumentAnalyzer::TestTangent()
}
TopExp_Explorer anExp1(myShape1, theType);
TopExp_Explorer anExp2(myShape2, theType);
BOPCol_SequenceOfShape aSeq1, aSeq2;
BOPCol_MapOfShape aMap1, aMap2;
TopTools_SequenceOfShape aSeq1, aSeq2;
TopTools_MapOfShape aMap1, aMap2;
for(; anExp1.More(); anExp1.Next()) {
const TopoDS_Shape& aS1 = anExp1.Current();
@ -675,7 +675,7 @@ void BOPAlgo_ArgumentAnalyzer::TestTangent()
for(i = 1; i <= aSeq1.Length(); i++) {
const TopoDS_Shape& aS1 = aSeq1.Value(i);
BOPCol_ListOfShape aListOfS2;
TopTools_ListOfShape aListOfS2;
Standard_Integer nbs = 0;
for(j = 1; j <= aSeq2.Length(); j++) {
@ -731,7 +731,7 @@ void BOPAlgo_ArgumentAnalyzer::TestTangent()
aResult.SetShape1(myShape1);
aResult.SetShape2(myShape2);
aResult.AddFaultyShape1(aS1);
BOPCol_ListIteratorOfListOfShape anIt(aListOfS2);
TopTools_ListIteratorOfListOfShape anIt(aListOfS2);
for(; anIt.More(); anIt.Next()) {
aResult.AddFaultyShape2(anIt.Value());
@ -748,7 +748,7 @@ void BOPAlgo_ArgumentAnalyzer::TestTangent()
for(i = 1; i <= aSeq2.Length(); i++) {
const TopoDS_Shape& aS2 = aSeq2.Value(i);
BOPCol_ListOfShape aListOfS1;
TopTools_ListOfShape aListOfS1;
Standard_Integer nbs = 0;
for(j = 1; j <= aSeq1.Length(); j++) {
@ -765,7 +765,7 @@ void BOPAlgo_ArgumentAnalyzer::TestTangent()
aResult.SetShape1(myShape1);
aResult.SetShape2(myShape2);
BOPCol_ListIteratorOfListOfShape anIt(aListOfS1);
TopTools_ListIteratorOfListOfShape anIt(aListOfS1);
for(; anIt.More(); anIt.Next()) {
aResult.AddFaultyShape1(anIt.Value());
@ -816,7 +816,7 @@ void BOPAlgo_ArgumentAnalyzer::TestContinuity()
continue;
}
//
BOPCol_IndexedMapOfShape aMS;
TopTools_IndexedMapOfShape aMS;
//Edges
aExp.Init(aS, TopAbs_EDGE);
for (; aExp.More(); aExp.Next()) {

3
src/BOPAlgo/BOPAlgo_ArgumentAnalyzer.hxx
View File

@ -22,11 +22,10 @@
#include <TopoDS_Shape.hxx>
#include <Standard_Boolean.hxx>
#include <BOPAlgo_Algo.hxx>
#include <BOPAlgo_Operation.hxx>
#include <BOPAlgo_ListOfCheckResult.hxx>
#include <Standard_Real.hxx>
#include <BOPCol_DataMapOfShapeReal.hxx>
#include <BOPAlgo_Algo.hxx>
#include <TopAbs_ShapeEnum.hxx>
class TopoDS_Shape;

203
src/BOPAlgo/BOPAlgo_BOP.cxx
View File

@ -18,54 +18,49 @@
#include <BOPAlgo_PaveFiller.hxx>
#include <BOPAlgo_Tools.hxx>
#include <BOPAlgo_Alerts.hxx>
#include <BOPCol_DataMapOfShapeShape.hxx>
#include <BOPCol_IndexedDataMapOfShapeListOfShape.hxx>
#include <BOPCol_IndexedMapOfShape.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <BOPDS_DS.hxx>
#include <BOPTools.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_AlgoTools3D.hxx>
#include <BOPTools_IndexedDataMapOfSetShape.hxx>
#include <BOPTools_Set.hxx>
#include <BOPTools_SetMapHasher.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <NCollection_DataMap.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS_Compound.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Iterator.hxx>
#include <TopoDS_Shape.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
typedef NCollection_IndexedDataMap
<BOPTools_Set,
TopoDS_Shape,
BOPTools_SetMapHasher> BOPTools_IndexedDataMapOfSetShape;
//
static
TopAbs_ShapeEnum TypeToExplore(const Standard_Integer theDim);
//
static
void CollectContainers(const TopoDS_Shape& theS,
BOPCol_ListOfShape& theLSC);
TopTools_ListOfShape& theLSC);
//
static
void RemoveDuplicates(BOPCol_ListOfShape& theContainers);
void RemoveDuplicates(TopTools_ListOfShape& theContainers);
//
static
void RemoveDuplicates(BOPCol_ListOfShape& theContainers,
void RemoveDuplicates(TopTools_ListOfShape& theContainers,
const TopAbs_ShapeEnum theType);
//
static
Standard_Integer NbCommonItemsInMap(const BOPCol_MapOfShape& theM1,
const BOPCol_MapOfShape& theM2);
Standard_Integer NbCommonItemsInMap(const TopTools_MapOfShape& theM1,
const TopTools_MapOfShape& theM2);
//
static
void MapFacesToBuildSolids(const TopoDS_Shape& theSol,
BOPCol_IndexedDataMapOfShapeListOfShape& theMFS,
BOPCol_IndexedMapOfShape& theMFI);
TopTools_IndexedDataMapOfShapeListOfShape& theMFS,
TopTools_IndexedMapOfShape& theMFI);
//=======================================================================
//function :
@ -128,7 +123,7 @@ void BOPAlgo_BOP::CheckData()
{
Standard_Integer i, j, iDim, aNbArgs, aNbTools;
Standard_Boolean bFuse;
BOPCol_ListIteratorOfListOfShape aItLS;
TopTools_ListIteratorOfListOfShape aItLS;
//
if (!(myOperation==BOPAlgo_COMMON ||
myOperation==BOPAlgo_FUSE ||
@ -172,7 +167,7 @@ void BOPAlgo_BOP::CheckData()
Standard_Boolean bHasValid[2] = {Standard_False, Standard_False};
//
for (i=0; i<2; ++i) {
const BOPCol_ListOfShape& aLS=(!i)? myArguments : myTools;
const TopTools_ListOfShape& aLS=(!i)? myArguments : myTools;
aItLS.Initialize(aLS);
for (j=0; aItLS.More(); aItLS.Next(), ++j) {
const TopoDS_Shape& aS=aItLS.Value();
@ -237,8 +232,8 @@ Standard_Boolean BOPAlgo_BOP::TreatEmptyShape()
}
//
// Find non-empty objects
BOPCol_ListOfShape aLValidObjs;
BOPCol_ListIteratorOfListOfShape aItLS(myArguments);
TopTools_ListOfShape aLValidObjs;
TopTools_ListIteratorOfListOfShape aItLS(myArguments);
for (; aItLS.More(); aItLS.Next()) {
if (!BOPTools_AlgoTools3D::IsEmptyShape(aItLS.Value())) {
aLValidObjs.Append(aItLS.Value());
@ -246,7 +241,7 @@ Standard_Boolean BOPAlgo_BOP::TreatEmptyShape()
}
//
// Find non-empty tools
BOPCol_ListOfShape aLValidTools;
TopTools_ListOfShape aLValidTools;
aItLS.Initialize(myTools);
for (; aItLS.More() ; aItLS.Next()) {
if (!BOPTools_AlgoTools3D::IsEmptyShape(aItLS.Value())) {
@ -271,7 +266,7 @@ Standard_Boolean BOPAlgo_BOP::TreatEmptyShape()
// so we can build the result of operation right away just by
// choosing the list of shapes to add to result, depending on
// the type of the operation
BOPCol_ListOfShape *pLResult = NULL;
TopTools_ListOfShape *pLResult = NULL;
//
switch (myOperation) {
case BOPAlgo_FUSE:
@ -309,17 +304,17 @@ void BOPAlgo_BOP::BuildResult(const TopAbs_ShapeEnum theType)
{
TopAbs_ShapeEnum aType;
BRep_Builder aBB;
BOPCol_MapOfShape aM;
BOPCol_ListIteratorOfListOfShape aIt, aItIm;
TopTools_MapOfShape aM;
TopTools_ListIteratorOfListOfShape aIt, aItIm;
//
const BOPCol_ListOfShape& aLA=myDS->Arguments();
const TopTools_ListOfShape& aLA=myDS->Arguments();
aIt.Initialize(aLA);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS=aIt.Value();
aType=aS.ShapeType();
if (aType==theType) {
if (myImages.IsBound(aS)){
const BOPCol_ListOfShape& aLSIm=myImages.Find(aS);
const TopTools_ListOfShape& aLSIm=myImages.Find(aS);
aItIm.Initialize(aLSIm);
for (; aItIm.More(); aItIm.Next()) {
const TopoDS_Shape& aSIm=aItIm.Value();
@ -344,7 +339,7 @@ void BOPAlgo_BOP::Perform()
{
Handle(NCollection_BaseAllocator) aAllocator;
BOPAlgo_PaveFiller* pPF;
BOPCol_ListIteratorOfListOfShape aItLS;
TopTools_ListIteratorOfListOfShape aItLS;
//
GetReport()->Clear();
//
@ -357,7 +352,7 @@ void BOPAlgo_BOP::Perform()
//
aAllocator=
NCollection_BaseAllocator::CommonBaseAllocator();
BOPCol_ListOfShape aLS(aAllocator);
TopTools_ListOfShape aLS(aAllocator);
//
aItLS.Initialize(myArguments);
for (; aItLS.More(); aItLS.Next()) {
@ -530,7 +525,7 @@ void BOPAlgo_BOP::BuildRC()
//
// A. Fuse
if (myOperation == BOPAlgo_FUSE) {
BOPCol_MapOfShape aMFence;
TopTools_MapOfShape aMFence;
aType = TypeToExplore(myDims[0]);
TopExp_Explorer aExp(myShape, aType);
for (; aExp.More(); aExp.Next()) {
@ -547,13 +542,13 @@ void BOPAlgo_BOP::BuildRC()
//
Standard_Integer i, j, aNb, iDim;
Standard_Boolean bCheckEdges, bContains, bCut21, bCommon;
BOPCol_ListIteratorOfListOfShape aItLS;
TopTools_ListIteratorOfListOfShape aItLS;
//
// prepare the building elements of arguments to get its splits
BOPCol_IndexedMapOfShape aMArgs, aMTools;
TopTools_IndexedMapOfShape aMArgs, aMTools;
for (i = 0; i < 2; ++i) {
const BOPCol_ListOfShape& aLS = !i ? myArguments : myTools;
BOPCol_IndexedMapOfShape& aMS = !i ? aMArgs : aMTools;
const TopTools_ListOfShape& aLS = !i ? myArguments : myTools;
TopTools_IndexedMapOfShape& aMS = !i ? aMArgs : aMTools;
aItLS.Initialize(aLS);
for (; aItLS.More(); aItLS.Next()) {
const TopoDS_Shape& aS = aItLS.Value();
@ -562,19 +557,19 @@ void BOPAlgo_BOP::BuildRC()
continue;
}
aType = TypeToExplore(iDim);
BOPTools::MapShapes(aS, aType, aMS);
TopExp::MapShapes(aS, aType, aMS);
}
}
//
bCheckEdges = Standard_False;
//
// get splits of building elements
BOPCol_IndexedMapOfShape aMArgsIm, aMToolsIm;
TopTools_IndexedMapOfShape aMArgsIm, aMToolsIm;
BOPTools_IndexedDataMapOfSetShape aMSetArgs, aMSetTools;
for (i = 0; i < 2; ++i) {
const BOPCol_IndexedMapOfShape& aMS = !i ? aMArgs : aMTools;
BOPCol_IndexedMapOfShape& aMSIm = !i ? aMArgsIm : aMToolsIm;
const TopTools_IndexedMapOfShape& aMS = !i ? aMArgs : aMTools;
TopTools_IndexedMapOfShape& aMSIm = !i ? aMArgsIm : aMToolsIm;
BOPTools_IndexedDataMapOfSetShape& aMSet = !i ? aMSetArgs : aMSetTools;
//
aNb = aMS.Extent();
@ -590,7 +585,7 @@ void BOPAlgo_BOP::BuildRC()
}
//
if (myImages.IsBound(aS)) {
const BOPCol_ListOfShape& aLSIm = myImages.Find(aS);
const TopTools_ListOfShape& aLSIm = myImages.Find(aS);
aItLS.Initialize(aLSIm);
for (; aItLS.More(); aItLS.Next()) {
const TopoDS_Shape& aSIm = aItLS.Value();
@ -618,11 +613,11 @@ void BOPAlgo_BOP::BuildRC()
bCommon = (myOperation == BOPAlgo_COMMON);
bCut21 = (myOperation == BOPAlgo_CUT21);
//
const BOPCol_IndexedMapOfShape& aMIt = bCut21 ? aMToolsIm : aMArgsIm;
const BOPCol_IndexedMapOfShape& aMCheck = bCut21 ? aMArgsIm : aMToolsIm;
const TopTools_IndexedMapOfShape& aMIt = bCut21 ? aMToolsIm : aMArgsIm;
const TopTools_IndexedMapOfShape& aMCheck = bCut21 ? aMArgsIm : aMToolsIm;
const BOPTools_IndexedDataMapOfSetShape& aMSetCheck = bCut21 ? aMSetArgs : aMSetTools;
//
BOPCol_IndexedMapOfShape aMCheckExp, aMItExp;
TopTools_IndexedMapOfShape aMCheckExp, aMItExp;
//
if (bCommon) {
aNb = aMIt.Extent();
@ -631,7 +626,7 @@ void BOPAlgo_BOP::BuildRC()
iDimMax = BOPTools_AlgoTools::Dimension(aS);
for (iDim = iDimMin; iDim < iDimMax; ++iDim) {
aType = TypeToExplore(iDim);
BOPTools::MapShapes(aS, aType, aMItExp);
TopExp::MapShapes(aS, aType, aMItExp);
}
aMItExp.Add(aS);
}
@ -646,7 +641,7 @@ void BOPAlgo_BOP::BuildRC()
iDimMax = BOPTools_AlgoTools::Dimension(aS);
for (iDim = iDimMin; iDim < iDimMax; ++iDim) {
aType = TypeToExplore(iDim);
BOPTools::MapShapes(aS, aType, aMCheckExp);
TopExp::MapShapes(aS, aType, aMCheckExp);
}
aMCheckExp.Add(aS);
}
@ -676,7 +671,7 @@ void BOPAlgo_BOP::BuildRC()
//
// filter result for COMMON operation
if (bCommon) {
BOPCol_MapOfShape aMFence;
TopTools_MapOfShape aMFence;
TopExp_Explorer aExp;
TopoDS_Compound aCx;
aBB.MakeCompound(aCx);
@ -688,7 +683,7 @@ void BOPAlgo_BOP::BuildRC()
const TopoDS_Shape& aS = aExp.Current();
if (aMFence.Add(aS)) {
aBB.Add(aCx, aS);
BOPTools::MapShapes(aS, aMFence);
TopExp::MapShapes(aS, aMFence);
}
}
}
@ -702,10 +697,10 @@ void BOPAlgo_BOP::BuildRC()
//
// The squats around degenerated edges
Standard_Integer nVD;
BOPCol_IndexedMapOfShape aMVC;
TopTools_IndexedMapOfShape aMVC;
//
// 1. Vertices of aC
BOPTools::MapShapes(aC, TopAbs_VERTEX, aMVC);
TopExp::MapShapes(aC, TopAbs_VERTEX, aMVC);
//
// 2. DE candidates
aNb = myDS->NbSourceShapes();
@ -756,18 +751,18 @@ void BOPAlgo_BOP::BuildShape()
//
Standard_Integer i;
TopAbs_ShapeEnum aType, aT1, aT2;
BOPCol_ListOfShape aLSC, aLCB;
BOPCol_ListIteratorOfListOfShape aItLS, aItLSIm, aItLCB;
TopTools_ListOfShape aLSC, aLCB;
TopTools_ListIteratorOfListOfShape aItLS, aItLSIm, aItLCB;
TopoDS_Iterator aIt;
BRep_Builder aBB;
TopoDS_Shape aRC, aRCB;
//
BOPCol_MapOfShape aMSRC;
BOPTools::MapShapes(myRC, aMSRC);
TopTools_MapOfShape aMSRC;
TopExp::MapShapes(myRC, aMSRC);
//
// collect images of containers
for (i = 0; i < 2; ++i) {
const BOPCol_ListOfShape& aLS = !i ? myArguments : myTools;
const TopTools_ListOfShape& aLS = !i ? myArguments : myTools;
//
aItLS.Initialize(aLS);
for (; aItLS.More(); aItLS.Next()) {
@ -777,8 +772,8 @@ void BOPAlgo_BOP::BuildShape()
}
}
// make containers
BOPCol_ListOfShape aLCRes;
BOPCol_MapOfShape aMInpFence;
TopTools_ListOfShape aLCRes;
TopTools_MapOfShape aMInpFence;
aItLS.Initialize(aLSC);
for (; aItLS.More(); aItLS.Next()) {
const TopoDS_Shape& aSC = aItLS.Value();
@ -790,7 +785,7 @@ void BOPAlgo_BOP::BuildShape()
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS = aIt.Value();
if (myImages.IsBound(aS)) {
const BOPCol_ListOfShape& aLSIm = myImages.Find(aS);
const TopTools_ListOfShape& aLSIm = myImages.Find(aS);
//
aItLSIm.Initialize(aLSIm);
for (; aItLSIm.More(); aItLSIm.Next()) {
@ -866,14 +861,14 @@ void BOPAlgo_BOP::BuildShape()
}
// create map of containers
BOPCol_MapOfShape aMSResult;
BOPTools::MapShapes(aResult, aMSResult);
TopTools_MapOfShape aMSResult;
TopExp::MapShapes(aResult, aMSResult);
// get input non-container shapes
BOPCol_ListOfShape aLSNonCont;
TopTools_ListOfShape aLSNonCont;
for (i = 0; i < 2; ++i)
{
const BOPCol_ListOfShape& aLS = !i ? myArguments : myTools;
const TopTools_ListOfShape& aLS = !i ? myArguments : myTools;
aItLS.Initialize(aLS);
for (; aItLS.More(); aItLS.Next())
{
@ -889,7 +884,7 @@ void BOPAlgo_BOP::BuildShape()
const TopoDS_Shape& aS = aItLS.Value();
if (myImages.IsBound(aS))
{
const BOPCol_ListOfShape& aLSIm = myImages.Find(aS);
const TopTools_ListOfShape& aLSIm = myImages.Find(aS);
aItLSIm.Initialize(aLSIm);
for (; aItLSIm.More(); aItLSIm.Next())
{
@ -911,18 +906,18 @@ void BOPAlgo_BOP::BuildShape()
void BOPAlgo_BOP::BuildSolid()
{
// Containers
BOPCol_ListOfShape aLSC;
TopTools_ListOfShape aLSC;
//
BOPCol_ListIteratorOfListOfShape aItLS;
TopTools_ListIteratorOfListOfShape aItLS;
TopExp_Explorer aExp;
BRep_Builder aBB;
//
// Get solids from input arguments
BOPCol_MapOfShape aMSA;
TopTools_MapOfShape aMSA;
// Map the arguments to find shared faces
BOPCol_IndexedDataMapOfShapeListOfShape aMFS;
TopTools_IndexedDataMapOfShapeListOfShape aMFS;
for (Standard_Integer i = 0; i < 2; ++i) {
const BOPCol_ListOfShape& aLSA = (i) ? myArguments : myTools;
const TopTools_ListOfShape& aLSA = (i) ? myArguments : myTools;
aItLS.Initialize(aLSA);
for (; aItLS.More(); aItLS.Next()) {
const TopoDS_Shape& aSA = aItLS.Value();
@ -930,7 +925,7 @@ void BOPAlgo_BOP::BuildSolid()
for (; aExp.More(); aExp.Next()) {
const TopoDS_Shape& aSol = aExp.Current();
aMSA.Add(aSol);
BOPTools::MapShapesAndAncestors(aSol, TopAbs_FACE, TopAbs_SOLID, aMFS);
TopExp::MapShapesAndAncestors(aSol, TopAbs_FACE, TopAbs_SOLID, aMFS);
}
//
// get Compsolids from input arguments
@ -939,10 +934,10 @@ void BOPAlgo_BOP::BuildSolid()
}
//
// Find solids in input arguments sharing faces with other solids
BOPCol_MapOfShape aMTSols;
TopTools_MapOfShape aMTSols;
Standard_Integer i, aNb = aMFS.Extent();
for (i = 1; i < aNb; ++i) {
const BOPCol_ListOfShape& aLSols = aMFS(i);
const TopTools_ListOfShape& aLSols = aMFS(i);
if (aLSols.Extent() > 1) {
aItLS.Initialize(aLSols);
for(; aItLS.More(); aItLS.Next()) {
@ -952,11 +947,11 @@ void BOPAlgo_BOP::BuildSolid()
}
//
// Possibly untouched solids - to be added to results as is
BOPCol_IndexedMapOfShape aMUSols;
TopTools_IndexedMapOfShape aMUSols;
// Use map to chose the most outer faces to build result solids
aMFS.Clear();
// Internal faces
BOPCol_IndexedMapOfShape aMFI;
TopTools_IndexedMapOfShape aMFI;
//
TopoDS_Iterator aIt(myRC);
for (; aIt.More(); aIt.Next()) {
@ -999,16 +994,16 @@ void BOPAlgo_BOP::BuildSolid()
}
}
//
BOPCol_IndexedDataMapOfShapeListOfShape aMEF;
TopTools_IndexedDataMapOfShapeListOfShape aMEF;
// Split faces will be added in the end
// to avoid errors in BuilderSolid algorithm
BOPCol_ListOfShape aLF, aLFx;
TopTools_ListOfShape aLF, aLFx;
aNb = aMFS.Extent();
for (i = 1; i <= aNb; ++i) {
const BOPCol_ListOfShape& aLSx = aMFS(i);
const TopTools_ListOfShape& aLSx = aMFS(i);
if (aLSx.Extent() == 1) {
const TopoDS_Shape& aFx = aMFS.FindKey(i);
BOPTools::MapShapesAndAncestors(aFx, TopAbs_EDGE, TopAbs_FACE, aMEF);
TopExp::MapShapesAndAncestors(aFx, TopAbs_EDGE, TopAbs_FACE, aMEF);
if (IsBoundSplits(aFx, aMEF)){
aLFx.Append(aFx);
continue;
@ -1018,7 +1013,7 @@ void BOPAlgo_BOP::BuildSolid()
}
//
// Faces to build result solids
BOPCol_ListOfShape aSFS;
TopTools_ListOfShape aSFS;
aItLS.Initialize(aLF);
for(; aItLS.More(); aItLS.Next()) {
const TopoDS_Shape& aFx = aItLS.Value();
@ -1053,7 +1048,7 @@ void BOPAlgo_BOP::BuildSolid()
return;
}
// new solids
const BOPCol_ListOfShape& aLSR = aSB.Areas();
const TopTools_ListOfShape& aLSR = aSB.Areas();
//
// add new solids to result
aItLS.Initialize(aLSR);
@ -1104,19 +1099,19 @@ void BOPAlgo_BOP::BuildSolid()
}
//
// get splits of faces of the Compsolid arguments
BOPCol_MapOfShape aMFCs;
TopTools_MapOfShape aMFCs;
aItLS.Initialize(aLSC);
for (; aItLS.More(); aItLS.Next()) {
const TopoDS_Shape& aCs = aItLS.Value();
aExp.Init(aCs, TopAbs_FACE);
for (; aExp.More(); aExp.Next()) {
const TopoDS_Shape& aF = aExp.Current();
const BOPCol_ListOfShape* pLFIm = myImages.Seek(aF);
const TopTools_ListOfShape* pLFIm = myImages.Seek(aF);
if (!pLFIm) {
aMFCs.Add(aF);
}
else {
BOPCol_ListIteratorOfListOfShape aItLFIm(*pLFIm);
TopTools_ListIteratorOfListOfShape aItLFIm(*pLFIm);
for (; aItLFIm.More(); aItLFIm.Next()) {
aMFCs.Add(aItLFIm.Value());
}
@ -1125,7 +1120,7 @@ void BOPAlgo_BOP::BuildSolid()
}
//
// build connexity blocks from new solids
BOPCol_ListOfShape aLCBS;
TopTools_ListOfShape aLCBS;
BOPTools_AlgoTools::MakeConnexityBlocks(aRC, TopAbs_FACE, TopAbs_SOLID, aLCBS);
//
aItLS.Initialize(aLCBS);
@ -1168,14 +1163,14 @@ void BOPAlgo_BOP::BuildSolid()
//=======================================================================
Standard_Boolean BOPAlgo_BOP::IsBoundSplits
(const TopoDS_Shape& aS,
BOPCol_IndexedDataMapOfShapeListOfShape& aMEF)
TopTools_IndexedDataMapOfShapeListOfShape& aMEF)
{
Standard_Boolean bRet = Standard_False;
if (mySplits.IsBound(aS) || myOrigins.IsBound(aS)) {
return !bRet;
}
BOPCol_ListIteratorOfListOfShape aIt;
TopTools_ListIteratorOfListOfShape aIt;
Standard_Integer aNbLS;
TopAbs_Orientation anOr;
//
@ -1193,7 +1188,7 @@ Standard_Boolean BOPAlgo_BOP::IsBoundSplits
continue;
}
//
const BOPCol_ListOfShape& aLS=aMEF.FindFromKey(aE);
const TopTools_ListOfShape& aLS=aMEF.FindFromKey(aE);
aNbLS = aLS.Extent();
if (!aNbLS) {
continue;
@ -1242,7 +1237,7 @@ TopAbs_ShapeEnum TypeToExplore(const Standard_Integer theDim)
//purpose :
//=======================================================================
void CollectContainers(const TopoDS_Shape& theS,
BOPCol_ListOfShape& theLSC)
TopTools_ListOfShape& theLSC)
{
TopAbs_ShapeEnum aType = theS.ShapeType();
if (aType == TopAbs_WIRE ||
@ -1267,7 +1262,7 @@ void CollectContainers(const TopoDS_Shape& theS,
//function : RemoveDuplicates
//purpose : Filters the containers with identical contents
//=======================================================================
void RemoveDuplicates(BOPCol_ListOfShape& theContainers)
void RemoveDuplicates(TopTools_ListOfShape& theContainers)
{
RemoveDuplicates(theContainers, TopAbs_WIRE);
RemoveDuplicates(theContainers, TopAbs_SHELL);
@ -1278,12 +1273,12 @@ void RemoveDuplicates(BOPCol_ListOfShape& theContainers)
//function : RemoveDuplicates
//purpose : Filters the containers of given type with identical contents
//=======================================================================
void RemoveDuplicates(BOPCol_ListOfShape& theContainers,
void RemoveDuplicates(TopTools_ListOfShape& theContainers,
const TopAbs_ShapeEnum theType)
{
// get containers of given type
BOPCol_ListOfShape aLC;
BOPCol_ListIteratorOfListOfShape aItLC(theContainers);
TopTools_ListOfShape aLC;
TopTools_ListIteratorOfListOfShape aItLC(theContainers);
for (; aItLC.More(); aItLC.Next()) {
const TopoDS_Shape& aC = aItLC.Value();
if (aC.ShapeType() == theType) {
@ -1296,13 +1291,13 @@ void RemoveDuplicates(BOPCol_ListOfShape& theContainers,
}
//
// map containers to compare its contents
NCollection_IndexedDataMap<TopoDS_Shape, BOPCol_MapOfShape> aContents;
NCollection_IndexedDataMap<TopoDS_Shape, TopTools_MapOfShape> aContents;
//
aItLC.Initialize(aLC);
for (; aItLC.More(); aItLC.Next()) {
const TopoDS_Shape& aC = aItLC.Value();
//
BOPCol_MapOfShape& aMC = aContents(aContents.Add(aC, BOPCol_MapOfShape()));
TopTools_MapOfShape& aMC = aContents(aContents.Add(aC, TopTools_MapOfShape()));
//
TopoDS_Iterator aIt(aC);
for (; aIt.More(); aIt.Next()) {
@ -1311,7 +1306,7 @@ void RemoveDuplicates(BOPCol_ListOfShape& theContainers,
}
//
// compare the contents of the containers and find duplicates
BOPCol_MapOfShape aDuplicates;
TopTools_MapOfShape aDuplicates;
//
Standard_Integer i, j, aNb = aContents.Extent();
for (i = 1; i <= aNb; ++i) {
@ -1319,7 +1314,7 @@ void RemoveDuplicates(BOPCol_ListOfShape& theContainers,
if (aDuplicates.Contains(aCi)) {
continue;
}
const BOPCol_MapOfShape& aMi = aContents(i);
const TopTools_MapOfShape& aMi = aContents(i);
Standard_Integer aNbi = aMi.Extent();
//
for (j = i + 1; j <= aNb; ++j) {
@ -1327,7 +1322,7 @@ void RemoveDuplicates(BOPCol_ListOfShape& theContainers,
if (aDuplicates.Contains(aCj)) {
continue;
}
const BOPCol_MapOfShape& aMj = aContents(j);
const TopTools_MapOfShape& aMj = aContents(j);
Standard_Integer aNbj = aMj.Extent();
//
Standard_Integer aNbCommon = NbCommonItemsInMap(aMi, aMj);
@ -1364,11 +1359,11 @@ void RemoveDuplicates(BOPCol_ListOfShape& theContainers,
//function : NbCommonItemsInMap
//purpose : Counts the items contained in both maps
//=======================================================================
Standard_Integer NbCommonItemsInMap(const BOPCol_MapOfShape& theM1,
const BOPCol_MapOfShape& theM2)
Standard_Integer NbCommonItemsInMap(const TopTools_MapOfShape& theM1,
const TopTools_MapOfShape& theM2)
{
const BOPCol_MapOfShape* aMap1 = &theM1;
const BOPCol_MapOfShape* aMap2 = &theM2;
const TopTools_MapOfShape* aMap1 = &theM1;
const TopTools_MapOfShape* aMap2 = &theM2;
//
if (theM2.Extent() < theM1.Extent()) {
aMap1 = &theM2;
@ -1376,7 +1371,7 @@ Standard_Integer NbCommonItemsInMap(const BOPCol_MapOfShape& theM1,
}
//
Standard_Integer iCommon = 0;
for (BOPCol_MapIteratorOfMapOfShape aIt(*aMap1); aIt.More(); aIt.Next()) {
for (TopTools_MapIteratorOfMapOfShape aIt(*aMap1); aIt.More(); aIt.Next()) {
if (aMap2->Contains(aIt.Value())) {
++iCommon;
}
@ -1390,8 +1385,8 @@ Standard_Integer NbCommonItemsInMap(const BOPCol_MapOfShape& theM1,
// <theMFI> - internal faces.
//=======================================================================
void MapFacesToBuildSolids(const TopoDS_Shape& theSol,
BOPCol_IndexedDataMapOfShapeListOfShape& theMFS,
BOPCol_IndexedMapOfShape& theMFI)
TopTools_IndexedDataMapOfShapeListOfShape& theMFS,
TopTools_IndexedMapOfShape& theMFI)
{
TopExp_Explorer aExp(theSol, TopAbs_FACE);
for (; aExp.More(); aExp.Next()) {
@ -1402,9 +1397,9 @@ void MapFacesToBuildSolids(const TopoDS_Shape& theSol,
continue;
}
//
BOPCol_ListOfShape* pLSol = theMFS.ChangeSeek(aF);
TopTools_ListOfShape* pLSol = theMFS.ChangeSeek(aF);
if (!pLSol) {
pLSol = &theMFS(theMFS.Add(aF, BOPCol_ListOfShape()));
pLSol = &theMFS(theMFS.Add(aF, TopTools_ListOfShape()));
pLSol->Append(theSol);
}
else {

10
src/BOPAlgo/BOPAlgo_BOP.hxx
View File

@ -22,13 +22,11 @@
#include <BOPAlgo_Operation.hxx>
#include <Standard_Integer.hxx>
#include <TopoDS_Shape.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <BOPAlgo_ToolsProvider.hxx>
#include <BOPCol_BaseAllocator.hxx>
#include <NCollection_BaseAllocator.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <Standard_Boolean.hxx>
#include <BOPCol_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
class TopoDS_Shape;
class BOPAlgo_PaveFiller;
@ -77,7 +75,7 @@ public:
Standard_EXPORT BOPAlgo_BOP();
Standard_EXPORT virtual ~BOPAlgo_BOP();
Standard_EXPORT BOPAlgo_BOP(const BOPCol_BaseAllocator& theAllocator);
Standard_EXPORT BOPAlgo_BOP(const Handle(NCollection_BaseAllocator)& theAllocator);
//! Clears internal fields and arguments
Standard_EXPORT virtual void Clear() Standard_OVERRIDE;
@ -104,7 +102,7 @@ protected:
Standard_EXPORT void BuildSolid();
Standard_EXPORT Standard_Boolean IsBoundSplits (const TopoDS_Shape& theS, BOPCol_IndexedDataMapOfShapeListOfShape& theMEF);
Standard_EXPORT Standard_Boolean IsBoundSplits (const TopoDS_Shape& theS, TopTools_IndexedDataMapOfShapeListOfShape& theMEF);
//! Treatment of the cases with empty shapes.<br>
//! It returns TRUE if there is nothing to do, i.e.

19
src/BOPAlgo/BOPAlgo_Builder.cxx
View File

@ -27,12 +27,11 @@
#include <TopoDS_Compound.hxx>
#include <BRep_Builder.hxx>
#include <BOPCol_IndexedMapOfShape.hxx>
#include <BOPDS_ShapeInfo.hxx>
#include <BOPDS_DS.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
@ -118,9 +117,9 @@ void BOPAlgo_Builder::AddArgument(const TopoDS_Shape& theShape)
//function : SetArguments
//purpose :
//=======================================================================
void BOPAlgo_Builder::SetArguments(const BOPCol_ListOfShape& theShapes)
void BOPAlgo_Builder::SetArguments(const TopTools_ListOfShape& theShapes)
{
BOPCol_ListIteratorOfListOfShape aIt;
TopTools_ListIteratorOfListOfShape aIt;
//
myArguments.Clear();
//
@ -134,7 +133,7 @@ void BOPAlgo_Builder::SetArguments(const BOPCol_ListOfShape& theShapes)
//function : Arguments
//purpose :
//=======================================================================
const BOPCol_ListOfShape& BOPAlgo_Builder::Arguments()const
const TopTools_ListOfShape& BOPAlgo_Builder::Arguments()const
{
return myArguments;
}
@ -142,7 +141,7 @@ const BOPCol_ListOfShape& BOPAlgo_Builder::Arguments()const
//function : Images
//purpose :
//=======================================================================
const BOPCol_DataMapOfShapeListOfShape& BOPAlgo_Builder::Images()const
const TopTools_DataMapOfShapeListOfShape& BOPAlgo_Builder::Images()const
{
return myImages;
}
@ -150,7 +149,7 @@ const BOPCol_DataMapOfShapeListOfShape& BOPAlgo_Builder::Images()const
//function : Origins
//purpose :
//=======================================================================
const BOPCol_DataMapOfShapeListOfShape& BOPAlgo_Builder::Origins()const
const TopTools_DataMapOfShapeListOfShape& BOPAlgo_Builder::Origins()const
{
return myOrigins;
}
@ -159,7 +158,7 @@ const BOPCol_DataMapOfShapeListOfShape& BOPAlgo_Builder::Origins()const
//function : ShapesSd
//purpose :
//=======================================================================
const BOPCol_DataMapOfShapeShape& BOPAlgo_Builder::ShapesSD()const
const TopTools_DataMapOfShapeShape& BOPAlgo_Builder::ShapesSD()const
{
return myShapesSD;
}
@ -167,7 +166,7 @@ const BOPCol_DataMapOfShapeShape& BOPAlgo_Builder::ShapesSD()const
//function : Splits
//purpose :
//=======================================================================
const BOPCol_DataMapOfShapeListOfShape& BOPAlgo_Builder::Splits()const
const TopTools_DataMapOfShapeListOfShape& BOPAlgo_Builder::Splits()const
{
return mySplits;
}
@ -447,7 +446,7 @@ void BOPAlgo_Builder::PostTreat()
{
Standard_Integer i, aNbS;
TopAbs_ShapeEnum aType;
BOPCol_IndexedMapOfShape aMA;
TopTools_IndexedMapOfShape aMA;
if (myPaveFiller->NonDestructive()) {
// MapToAvoid
aNbS=myDS->NbSourceShapes();

45
src/BOPAlgo/BOPAlgo_Builder.hxx
View File

@ -22,18 +22,17 @@
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <BOPAlgo_PPaveFiller.hxx>
#include <BOPAlgo_BuilderShape.hxx>
#include <BOPAlgo_GlueEnum.hxx>
#include <BOPDS_PDS.hxx>
#include <NCollection_BaseAllocator.hxx>
#include <Standard_Integer.hxx>
#include <BOPCol_DataMapOfShapeListOfShape.hxx>
#include <BOPCol_DataMapOfShapeShape.hxx>
#include <Standard_Real.hxx>
#include <BOPAlgo_BuilderShape.hxx>
#include <BOPCol_BaseAllocator.hxx>
#include <TopTools_DataMapOfShapeListOfShape.hxx>
#include <TopTools_DataMapOfShapeShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
#include <Standard_Boolean.hxx>
#include <TopAbs_ShapeEnum.hxx>
class IntTools_Context;
@ -71,7 +70,7 @@ public:
Standard_EXPORT BOPAlgo_Builder();
Standard_EXPORT virtual ~BOPAlgo_Builder();
Standard_EXPORT BOPAlgo_Builder(const BOPCol_BaseAllocator& theAllocator);
Standard_EXPORT BOPAlgo_Builder(const Handle(NCollection_BaseAllocator)& theAllocator);
Standard_EXPORT virtual void Clear() Standard_OVERRIDE;
@ -81,9 +80,9 @@ Standard_EXPORT virtual ~BOPAlgo_Builder();
Standard_EXPORT virtual void AddArgument (const TopoDS_Shape& theShape);
Standard_EXPORT virtual void SetArguments (const BOPCol_ListOfShape& theLS);
Standard_EXPORT virtual void SetArguments (const TopTools_ListOfShape& theLS);
Standard_EXPORT const BOPCol_ListOfShape& Arguments() const;
Standard_EXPORT const TopTools_ListOfShape& Arguments() const;
Standard_EXPORT virtual void Perform() Standard_OVERRIDE;
@ -100,18 +99,18 @@ Standard_EXPORT virtual ~BOPAlgo_Builder();
//! Returns true if the shape theS has been deleted.
Standard_EXPORT virtual Standard_Boolean IsDeleted (const TopoDS_Shape& theS) Standard_OVERRIDE;
Standard_EXPORT const BOPCol_DataMapOfShapeListOfShape& Images() const;
Standard_EXPORT const TopTools_DataMapOfShapeListOfShape& Images() const;
Standard_EXPORT Standard_Boolean IsInterferred (const TopoDS_Shape& theS) const;
//! Returns myOrigins.
Standard_EXPORT const BOPCol_DataMapOfShapeListOfShape& Origins() const;
Standard_EXPORT const TopTools_DataMapOfShapeListOfShape& Origins() const;
//! Returns myShapesSD.
Standard_EXPORT const BOPCol_DataMapOfShapeShape& ShapesSD() const;
Standard_EXPORT const TopTools_DataMapOfShapeShape& ShapesSD() const;
//! Returns mySplits.
Standard_EXPORT const BOPCol_DataMapOfShapeListOfShape& Splits() const;
Standard_EXPORT const TopTools_DataMapOfShapeListOfShape& Splits() const;
//! Sets the flag that defines the mode of treatment.
@ -161,7 +160,7 @@ protected:
Standard_EXPORT void FillImagesContainer (const TopoDS_Shape& theS, const TopAbs_ShapeEnum theType);
Standard_EXPORT void FillImagesCompound (const TopoDS_Shape& theS, BOPCol_MapOfShape& theMF);
Standard_EXPORT void FillImagesCompound (const TopoDS_Shape& theS, TopTools_MapOfShape& theMF);
Standard_EXPORT void FillImagesFaces();
@ -173,27 +172,27 @@ protected:
Standard_EXPORT void FillImagesSolids();
Standard_EXPORT void BuildDraftSolid (const TopoDS_Shape& theSolid, TopoDS_Shape& theDraftSolid, BOPCol_ListOfShape& theLIF);
Standard_EXPORT void BuildDraftSolid (const TopoDS_Shape& theSolid, TopoDS_Shape& theDraftSolid, TopTools_ListOfShape& theLIF);
Standard_EXPORT virtual void FillIn3DParts (BOPCol_DataMapOfShapeListOfShape& theInParts, BOPCol_DataMapOfShapeShape& theDraftSolids, const BOPCol_BaseAllocator& theAllocator);
Standard_EXPORT virtual void FillIn3DParts (TopTools_DataMapOfShapeListOfShape& theInParts, TopTools_DataMapOfShapeShape& theDraftSolids, const Handle(NCollection_BaseAllocator)& theAllocator);
Standard_EXPORT void BuildSplitSolids (BOPCol_DataMapOfShapeListOfShape& theInParts, BOPCol_DataMapOfShapeShape& theDraftSolids, const BOPCol_BaseAllocator& theAllocator);
Standard_EXPORT void BuildSplitSolids (TopTools_DataMapOfShapeListOfShape& theInParts, TopTools_DataMapOfShapeShape& theDraftSolids, const Handle(NCollection_BaseAllocator)& theAllocator);
Standard_EXPORT void FillInternalShapes();
Standard_EXPORT virtual void PostTreat();
BOPCol_ListOfShape myArguments;
BOPCol_MapOfShape myMapFence;
TopTools_ListOfShape myArguments;
TopTools_MapOfShape myMapFence;
BOPAlgo_PPaveFiller myPaveFiller;
BOPDS_PDS myDS;
Handle(IntTools_Context) myContext;
Standard_Integer myEntryPoint;
BOPCol_DataMapOfShapeListOfShape myImages;
BOPCol_DataMapOfShapeShape myShapesSD;
BOPCol_DataMapOfShapeListOfShape mySplits;
BOPCol_DataMapOfShapeListOfShape myOrigins;
TopTools_DataMapOfShapeListOfShape myImages;
TopTools_DataMapOfShapeShape myShapesSD;
TopTools_DataMapOfShapeListOfShape mySplits;
TopTools_DataMapOfShapeListOfShape myOrigins;
Standard_Boolean myNonDestructive;
BOPAlgo_GlueEnum myGlue;

26
src/BOPAlgo/BOPAlgo_BuilderArea.hxx
View File

@ -22,10 +22,10 @@
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_IndexedMapOfOrientedShape.hxx>
#include <BOPAlgo_Algo.hxx>
#include <BOPCol_BaseAllocator.hxx>
#include <NCollection_BaseAllocator.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_IndexedMapOfOrientedShape.hxx>
class IntTools_Context;
@ -43,22 +43,22 @@ public:
}
//! Returns the input shapes
Standard_EXPORT const BOPCol_ListOfShape& Shapes() const {
Standard_EXPORT const TopTools_ListOfShape& Shapes() const {
return myShapes;
}
//! Sets the shapes for building areas
Standard_EXPORT void SetShapes(const BOPCol_ListOfShape& theLS) {
Standard_EXPORT void SetShapes(const TopTools_ListOfShape& theLS) {
myShapes = theLS;
}
//! Returns the found loops
Standard_EXPORT const BOPCol_ListOfShape& Loops() const {
Standard_EXPORT const TopTools_ListOfShape& Loops() const {
return myLoops;
}
//! Returns the found areas
Standard_EXPORT const BOPCol_ListOfShape& Areas() const {
Standard_EXPORT const TopTools_ListOfShape& Areas() const {
return myAreas;
}
@ -78,7 +78,7 @@ protected:
Standard_EXPORT BOPAlgo_BuilderArea();
Standard_EXPORT virtual ~BOPAlgo_BuilderArea();
Standard_EXPORT BOPAlgo_BuilderArea(const BOPCol_BaseAllocator& theAllocator);
Standard_EXPORT BOPAlgo_BuilderArea(const Handle(NCollection_BaseAllocator)& theAllocator);
Standard_EXPORT virtual void PerformShapesToAvoid() = 0;
@ -90,11 +90,11 @@ protected:
Handle(IntTools_Context) myContext;
BOPCol_ListOfShape myShapes;
BOPCol_ListOfShape myLoops;
BOPCol_ListOfShape myLoopsInternal;
BOPCol_ListOfShape myAreas;
BOPCol_IndexedMapOfOrientedShape myShapesToAvoid;
TopTools_ListOfShape myShapes;
TopTools_ListOfShape myLoops;
TopTools_ListOfShape myLoopsInternal;
TopTools_ListOfShape myAreas;
TopTools_IndexedMapOfOrientedShape myShapesToAvoid;
Standard_Boolean myAvoidInternalShapes;
private:

112
src/BOPAlgo/BOPAlgo_BuilderFace.cxx
View File

@ -17,21 +17,14 @@
// commercial license or contractual agreement.
#include <Bnd_Box.hxx>
#include <Bnd_Box2d.hxx>
#include <BOPAlgo_BuilderFace.hxx>
#include <BOPAlgo_WireEdgeSet.hxx>
#include <BOPAlgo_WireSplitter.hxx>
#include <BOPAlgo_Alerts.hxx>
#include <BOPCol_Box2DBndTree.hxx>
#include <BOPCol_DataMapOfShapeListOfShape.hxx>
#include <BOPCol_DataMapOfShapeShape.hxx>
#include <BOPCol_IndexedDataMapOfShapeListOfShape.hxx>
#include <BOPCol_IndexedDataMapOfShapeShape.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <BOPCol_MapOfOrientedShape.hxx>
#include <BOPTools.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_AlgoTools2D.hxx>
#include <BOPTools_BoxSelector.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <BRepBndLib.hxx>
@ -58,19 +51,23 @@
#include <TopoDS_Shape.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Wire.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_IndexedDataMapOfShapeShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopTools_MapOfOrientedShape.hxx>
//
static
Standard_Boolean IsGrowthWire(const TopoDS_Shape& ,
const BOPCol_IndexedMapOfShape& );
const TopTools_IndexedMapOfShape& );
static
Standard_Boolean IsInside(const TopoDS_Shape& ,
const TopoDS_Shape& ,
Handle(IntTools_Context)& );
static
void MakeInternalWires(const BOPCol_IndexedMapOfShape& ,
BOPCol_ListOfShape& );
void MakeInternalWires(const TopTools_IndexedMapOfShape& ,
TopTools_ListOfShape& );
//=======================================================================
//function :
@ -189,8 +186,8 @@ void BOPAlgo_BuilderFace::PerformShapesToAvoid()
{
Standard_Boolean bFound;
Standard_Integer i, iCnt, aNbV, aNbE;
BOPCol_IndexedDataMapOfShapeListOfShape aMVE;
BOPCol_ListIteratorOfListOfShape aIt;
TopTools_IndexedDataMapOfShapeListOfShape aMVE;
TopTools_ListIteratorOfListOfShape aIt;
//
myShapesToAvoid.Clear();
//
@ -205,7 +202,7 @@ void BOPAlgo_BuilderFace::PerformShapesToAvoid()
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aE=aIt.Value();
if (!myShapesToAvoid.Contains(aE)) {
BOPTools::MapShapesAndAncestors(aE, TopAbs_VERTEX, TopAbs_EDGE, aMVE);
TopExp::MapShapesAndAncestors(aE, TopAbs_VERTEX, TopAbs_EDGE, aMVE);
}
}
aNbV=aMVE.Extent();
@ -214,7 +211,7 @@ void BOPAlgo_BuilderFace::PerformShapesToAvoid()
for (i=1; i<=aNbV; ++i) {
const TopoDS_Vertex& aV=(*(TopoDS_Vertex *)(&aMVE.FindKey(i)));
//
BOPCol_ListOfShape& aLE=aMVE.ChangeFromKey(aV);
TopTools_ListOfShape& aLE=aMVE.ChangeFromKey(aV);
aNbE=aLE.Extent();
if (!aNbE) {
continue;
@ -262,9 +259,9 @@ void BOPAlgo_BuilderFace::PerformLoops()
{
Standard_Boolean bFlag;
Standard_Integer i, aNbEA;
BOPCol_ListIteratorOfListOfShape aIt;
BOPCol_IndexedDataMapOfShapeListOfShape aVEMap;
BOPCol_MapOfOrientedShape aMAdded;
TopTools_ListIteratorOfListOfShape aIt;
TopTools_IndexedDataMapOfShapeListOfShape aVEMap;
TopTools_MapOfOrientedShape aMAdded;
TopoDS_Iterator aItW;
BRep_Builder aBB;
BOPAlgo_WireEdgeSet aWES(myAllocator);
@ -290,14 +287,14 @@ void BOPAlgo_BuilderFace::PerformLoops()
return;
}
//
const BOPCol_ListOfShape& aLW=aWES.Shapes();
const TopTools_ListOfShape& aLW=aWES.Shapes();
aIt.Initialize (aLW);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aW=aIt.Value();
myLoops.Append(aW);
}
// Post Treatment
BOPCol_MapOfOrientedShape aMEP;
TopTools_MapOfOrientedShape aMEP;
//
// a. collect all edges that are in loops
aIt.Initialize (myLoops);
@ -332,7 +329,7 @@ void BOPAlgo_BuilderFace::PerformLoops()
aNbEA = myShapesToAvoid.Extent();
for (i = 1; i <= aNbEA; ++i) {
const TopoDS_Shape& aEE = myShapesToAvoid(i);
BOPTools::MapShapesAndAncestors(aEE,
TopExp::MapShapesAndAncestors(aEE,
TopAbs_VERTEX,
TopAbs_EDGE,
aVEMap);
@ -357,7 +354,7 @@ void BOPAlgo_BuilderFace::PerformLoops()
TopoDS_Iterator aItE(aE);
for (; aItE.More()&&bFlag; aItE.Next()) {
const TopoDS_Vertex& aV = (*(TopoDS_Vertex *)(&aItE.Value()));
const BOPCol_ListOfShape& aLE=aVEMap.FindFromKey(aV);
const TopTools_ListOfShape& aLE=aVEMap.FindFromKey(aV);
aIt.Initialize(aLE);
for (; aIt.More()&&bFlag; aIt.Next()) {
const TopoDS_Shape& aEx=aIt.Value();
@ -404,16 +401,16 @@ void BOPAlgo_BuilderFace::PerformAreas()
}
// The new faces
BOPCol_ListOfShape aNewFaces;
TopTools_ListOfShape aNewFaces;
// The hole faces which has to be classified relatively new faces
BOPCol_IndexedMapOfShape aHoleFaces;
TopTools_IndexedMapOfShape aHoleFaces;
// Map of the edges of the hole faces for quick check of the growths.
// If the analyzed wire contains any of the edges from the hole faces
// it is considered as growth.
BOPCol_IndexedMapOfShape aMHE;
TopTools_IndexedMapOfShape aMHE;
// Analyze the new wires - classify them to be the holes and growths
BOPCol_ListIteratorOfListOfShape aItLL(myLoops);
TopTools_ListIteratorOfListOfShape aItLL(myLoops);
for (; aItLL.More(); aItLL.Next())
{
const TopoDS_Shape& aWire = aItLL.Value();
@ -438,7 +435,7 @@ void BOPAlgo_BuilderFace::PerformAreas()
else
{
aHoleFaces.Add(aFace);
BOPTools::MapShapes(aWire, TopAbs_EDGE, aMHE);
TopExp::MapShapes(aWire, TopAbs_EDGE, aMHE);
}
}
@ -451,7 +448,7 @@ void BOPAlgo_BuilderFace::PerformAreas()
// Classify holes relatively faces
// Prepare tree filler with the boxes of the hole faces
BOPCol_Box2DBndTree aBBTree;
NCollection_UBTree<Standard_Integer, Bnd_Box2d> aBBTree;
NCollection_UBTreeFiller <Standard_Integer, Bnd_Box2d> aTreeFiller(aBBTree);
Standard_Integer i, aNbH = aHoleFaces.Extent();
@ -468,9 +465,12 @@ void BOPAlgo_BuilderFace::PerformAreas()
aTreeFiller.Fill();
// Find outer growth face that is most close to each hole face
BOPCol_IndexedDataMapOfShapeShape aHoleFaceMap;
TopTools_IndexedDataMapOfShapeShape aHoleFaceMap;
BOPCol_ListIteratorOfListOfShape aItLS(aNewFaces);
// Selector
BOPTools_BoxSelector<Bnd_Box2d> aSelector;
TopTools_ListIteratorOfListOfShape aItLS(aNewFaces);
for (; aItLS.More(); aItLS.Next())
{
const TopoDS_Face& aFace = TopoDS::Face(aItLS.Value());
@ -479,12 +479,12 @@ void BOPAlgo_BuilderFace::PerformAreas()
Bnd_Box2d aBox;
BRepTools::AddUVBounds(aFace, aBox);
BOPCol_Box2DBndTreeSelector aSelector;
aSelector.Clear();
aSelector.SetBox(aBox);
aBBTree.Select(aSelector);
const BOPCol_ListOfInteger& aLI = aSelector.Indices();
BOPCol_ListIteratorOfListOfInteger aItLI(aLI);
const TColStd_ListOfInteger& aLI = aSelector.Indices();
TColStd_ListIteratorOfListOfInteger aItLI(aLI);
for (; aItLI.More(); aItLI.Next())
{
Standard_Integer k = aItLI.Value();
@ -510,7 +510,7 @@ void BOPAlgo_BuilderFace::PerformAreas()
}
// Make the back map from faces to holes
BOPCol_IndexedDataMapOfShapeListOfShape aFaceHolesMap;
TopTools_IndexedDataMapOfShapeListOfShape aFaceHolesMap;
aNbH = aHoleFaceMap.Extent();
for (i = 1; i <= aNbH; ++i)
@ -518,9 +518,9 @@ void BOPAlgo_BuilderFace::PerformAreas()
const TopoDS_Shape& aHole = aHoleFaceMap.FindKey(i);
const TopoDS_Shape& aFace = aHoleFaceMap(i);
//
BOPCol_ListOfShape* pLHoles = aFaceHolesMap.ChangeSeek(aFace);
TopTools_ListOfShape* pLHoles = aFaceHolesMap.ChangeSeek(aFace);
if (!pLHoles)
pLHoles = &aFaceHolesMap(aFaceHolesMap.Add(aFace, BOPCol_ListOfShape()));
pLHoles = &aFaceHolesMap(aFaceHolesMap.Add(aFace, TopTools_ListOfShape()));
pLHoles->Append(aHole);
}
@ -535,7 +535,7 @@ void BOPAlgo_BuilderFace::PerformAreas()
{
TopoDS_Face aFace;
aBB.MakeFace(aFace, aS, aLoc, aTol);
BOPCol_ListOfShape& anUnUsedHoles = aFaceHolesMap(aFaceHolesMap.Add(aFace, BOPCol_ListOfShape()));
TopTools_ListOfShape& anUnUsedHoles = aFaceHolesMap(aFaceHolesMap.Add(aFace, TopTools_ListOfShape()));
aNbH = aHoleFaces.Extent();
for (i = 1; i <= aNbH; ++i)
{
@ -553,11 +553,11 @@ void BOPAlgo_BuilderFace::PerformAreas()
for ( ; aItLS.More(); aItLS.Next())
{
TopoDS_Face& aFace = *(TopoDS_Face*)&aItLS.Value();
const BOPCol_ListOfShape* pLHoles = aFaceHolesMap.Seek(aFace);
const TopTools_ListOfShape* pLHoles = aFaceHolesMap.Seek(aFace);
if (pLHoles)
{
// update faces with the holes
BOPCol_ListIteratorOfListOfShape aItLH(*pLHoles);
TopTools_ListIteratorOfListOfShape aItLH(*pLHoles);
for (; aItLH.More(); aItLH.Next())
{
const TopoDS_Shape& aFHole = aItLH.Value();
@ -592,11 +592,11 @@ void BOPAlgo_BuilderFace::PerformInternalShapes()
//Standard_Real aTol;
Standard_Integer i;
BRep_Builder aBB;
BOPCol_ListIteratorOfListOfShape aIt1, aIt2;
TopTools_ListIteratorOfListOfShape aIt1, aIt2;
TopoDS_Iterator aIt;
BOPCol_IndexedMapOfShape aME1, aME2, aMEP;
BOPCol_IndexedDataMapOfShapeListOfShape aMVE;
BOPCol_ListOfShape aLSI;
TopTools_IndexedMapOfShape aME1, aME2, aMEP;
TopTools_IndexedDataMapOfShapeListOfShape aMVE;
TopTools_ListOfShape aLSI;
//
// 1. All internal edges
aIt1.Initialize(myLoopsInternal);
@ -615,7 +615,7 @@ void BOPAlgo_BuilderFace::PerformInternalShapes()
TopoDS_Face& aF=(*(TopoDS_Face *)(&aIt2.Value()));
//
aMVE.Clear();
BOPTools::MapShapesAndAncestors(aF, TopAbs_VERTEX, TopAbs_EDGE, aMVE);
TopExp::MapShapesAndAncestors(aF, TopAbs_VERTEX, TopAbs_EDGE, aMVE);
//
// 2.1 Separate faces to process aMEP
aME2.Clear();
@ -655,19 +655,19 @@ void BOPAlgo_BuilderFace::PerformInternalShapes()
//function : MakeInternalWires
//purpose :
//=======================================================================
void MakeInternalWires(const BOPCol_IndexedMapOfShape& theME,
BOPCol_ListOfShape& theWires)
void MakeInternalWires(const TopTools_IndexedMapOfShape& theME,
TopTools_ListOfShape& theWires)
{
Standard_Integer i, aNbE;
BOPCol_MapOfShape aAddedMap;
BOPCol_ListIteratorOfListOfShape aItE;
BOPCol_IndexedDataMapOfShapeListOfShape aMVE;
TopTools_MapOfShape aAddedMap;
TopTools_ListIteratorOfListOfShape aItE;
TopTools_IndexedDataMapOfShapeListOfShape aMVE;
BRep_Builder aBB;
//
aNbE = theME.Extent();
for (i = 1; i <= aNbE; ++i) {
const TopoDS_Shape& aE = theME(i);
BOPTools::MapShapesAndAncestors(aE, TopAbs_VERTEX, TopAbs_EDGE, aMVE);
TopExp::MapShapesAndAncestors(aE, TopAbs_VERTEX, TopAbs_EDGE, aMVE);
}
//
for (i = 1; i <= aNbE; ++i) {
@ -689,7 +689,7 @@ void MakeInternalWires(const BOPCol_IndexedMapOfShape& theME,
TopExp_Explorer aExp(aE, TopAbs_VERTEX);
for (; aExp.More(); aExp.Next()) {
const TopoDS_Shape& aV =aExp.Current();
const BOPCol_ListOfShape& aLE=aMVE.FindFromKey(aV);
const TopTools_ListOfShape& aLE=aMVE.FindFromKey(aV);
aItE.Initialize(aLE);
for (; aItE.More(); aItE.Next()) {
TopoDS_Shape aEL=aItE.Value();
@ -717,14 +717,14 @@ Standard_Boolean IsInside(const TopoDS_Shape& theHole,
TopAbs_State aState;
TopExp_Explorer aExp;
BOPCol_IndexedMapOfShape aME2;
TopTools_IndexedMapOfShape aME2;
gp_Pnt2d aP2D;
//
bRet=Standard_False;
aState=TopAbs_UNKNOWN;
const TopoDS_Face& aF2=(*(TopoDS_Face *)(&theF2));
//
BOPTools::MapShapes(aF2, TopAbs_EDGE, aME2);//AA
TopExp::MapShapes(aF2, TopAbs_EDGE, aME2);//AA
//
aExp.Init(theHole, TopAbs_EDGE);
if (aExp.More()) {
@ -752,7 +752,7 @@ Standard_Boolean IsInside(const TopoDS_Shape& theHole,
//purpose :
//=======================================================================
Standard_Boolean IsGrowthWire(const TopoDS_Shape& theWire,
const BOPCol_IndexedMapOfShape& theMHE)
const TopTools_IndexedMapOfShape& theMHE)
{
if (theMHE.Extent())
{

4
src/BOPAlgo/BOPAlgo_BuilderFace.hxx
View File

@ -25,7 +25,7 @@
#include <TopoDS_Face.hxx>
#include <TopAbs_Orientation.hxx>
#include <BOPAlgo_BuilderArea.hxx>
#include <BOPCol_BaseAllocator.hxx>
#include <NCollection_BaseAllocator.hxx>
class TopoDS_Face;
@ -45,7 +45,7 @@ public:
Standard_EXPORT BOPAlgo_BuilderFace();
Standard_EXPORT virtual ~BOPAlgo_BuilderFace();
Standard_EXPORT BOPAlgo_BuilderFace(const BOPCol_BaseAllocator& theAllocator);
Standard_EXPORT BOPAlgo_BuilderFace(const Handle(NCollection_BaseAllocator)& theAllocator);
//! Sets the face generatix
Standard_EXPORT void SetFace (const TopoDS_Face& theFace);

2
src/BOPAlgo/BOPAlgo_BuilderShape.cxx
View File

@ -132,7 +132,7 @@
//function : ImagesResult
//purpose :
//=======================================================================
const BOPCol_IndexedDataMapOfShapeListOfShape&
const TopTools_IndexedDataMapOfShapeListOfShape&
BOPAlgo_BuilderShape::ImagesResult()const
{
return myImagesResult;

29
src/BOPAlgo/BOPAlgo_BuilderShape.hxx
View File

@ -21,14 +21,14 @@
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Boolean.hxx>
#include <BOPAlgo_Algo.hxx>
#include <NCollection_BaseAllocator.hxx>
#include <TopoDS_Shape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <Standard_Boolean.hxx>
#include <BOPCol_IndexedDataMapOfShapeListOfShape.hxx>
#include <BOPAlgo_Algo.hxx>
#include <BOPCol_BaseAllocator.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
class TopoDS_Shape;
@ -69,7 +69,7 @@ public:
//! of arguments has modified shapes.
Standard_EXPORT Standard_Boolean HasModified() const;
Standard_EXPORT const BOPCol_IndexedDataMapOfShapeListOfShape& ImagesResult() const;
Standard_EXPORT const TopTools_IndexedDataMapOfShapeListOfShape& ImagesResult() const;
@ -80,7 +80,7 @@ protected:
Standard_EXPORT BOPAlgo_BuilderShape();
Standard_EXPORT virtual ~BOPAlgo_BuilderShape();
Standard_EXPORT BOPAlgo_BuilderShape(const BOPCol_BaseAllocator& theAllocator);
Standard_EXPORT BOPAlgo_BuilderShape(const Handle(NCollection_BaseAllocator)& theAllocator);
//! Prepare information for history support
Standard_EXPORT virtual void PrepareHistory();
@ -88,26 +88,15 @@ Standard_EXPORT virtual ~BOPAlgo_BuilderShape();
TopoDS_Shape myShape;
TopTools_ListOfShape myHistShapes;
BOPCol_MapOfShape myMapShape;
TopTools_MapOfShape myMapShape;
Standard_Boolean myHasDeleted;
Standard_Boolean myHasGenerated;
Standard_Boolean myHasModified;
BOPCol_IndexedDataMapOfShapeListOfShape myImagesResult;
TopTools_IndexedDataMapOfShapeListOfShape myImagesResult;
Standard_Boolean myFlagHistory;
private:
};
#endif // _BOPAlgo_BuilderShape_HeaderFile

129
src/BOPAlgo/BOPAlgo_BuilderSolid.cxx
View File

@ -19,21 +19,11 @@
#include <BOPAlgo_ShellSplitter.hxx>
#include <BOPAlgo_Alerts.hxx>
#include <BOPAlgo_Tools.hxx>
#include <BOPCol_BoxBndTree.hxx>
#include <BOPCol_DataMapOfShapeListOfShape.hxx>
#include <BOPCol_DataMapOfShapeShape.hxx>
#include <BOPCol_IndexedDataMapOfShapeListOfShape.hxx>
#include <BOPCol_IndexedDataMapOfShapeShape.hxx>
#include <BOPCol_ListOfInteger.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_MapOfOrientedShape.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <BOPCol_NCVector.hxx>
#include <BOPCol_Parallel.hxx>
#include <BOPTools.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_AlgoTools3D.hxx>
#include <BOPTools_BoxBndTree.hxx>
#include <BOPTools_CoupleOfShape.hxx>
#include <BOPTools_Parallel.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <BRepBndLib.hxx>
@ -50,6 +40,7 @@
#include <NCollection_DataMap.hxx>
#include <NCollection_List.hxx>
#include <NCollection_UBTreeFiller.hxx>
#include <NCollection_Vector.hxx>
#include <TColStd_MapIntegerHasher.hxx>
#include <TopAbs.hxx>
#include <TopExp.hxx>
@ -63,11 +54,17 @@
#include <TopoDS_Shell.hxx>
#include <TopoDS_Solid.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_IndexedDataMapOfShapeShape.hxx>
#include <TColStd_ListOfInteger.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_MapOfOrientedShape.hxx>
#include <TopTools_MapOfShape.hxx>
//
static
Standard_Boolean IsGrowthShell(const TopoDS_Shape& ,
const BOPCol_IndexedMapOfShape& );
const TopTools_IndexedMapOfShape& );
static
Standard_Boolean IsHole(const TopoDS_Shape& ,
Handle(IntTools_Context)& );
@ -76,8 +73,8 @@ static
const TopoDS_Shape& ,
Handle(IntTools_Context)& );
static
void MakeInternalShells(const BOPCol_IndexedMapOfShape& ,
BOPCol_ListOfShape& );
void MakeInternalShells(const TopTools_IndexedMapOfShape& ,
TopTools_ListOfShape& );
//=======================================================================
//function :
@ -140,7 +137,7 @@ void BOPAlgo_BuilderSolid::Perform()
TopoDS_Compound aC;
BRep_Builder aBB;
BOPCol_ListIteratorOfListOfShape aIt;
TopTools_ListIteratorOfListOfShape aIt;
//
aBB.MakeCompound(aC);
aIt.Initialize(myShapes);
@ -186,8 +183,8 @@ void BOPAlgo_BuilderSolid::PerformShapesToAvoid()
Standard_Boolean bFound;
Standard_Integer i, iCnt, aNbE, aNbF;
TopAbs_Orientation aOrE;
BOPCol_IndexedDataMapOfShapeListOfShape aMEF;
BOPCol_ListIteratorOfListOfShape aIt;
TopTools_IndexedDataMapOfShapeListOfShape aMEF;
TopTools_ListIteratorOfListOfShape aIt;
//
myShapesToAvoid.Clear();
//
@ -202,7 +199,7 @@ void BOPAlgo_BuilderSolid::PerformShapesToAvoid()
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aF=aIt.Value();
if (!myShapesToAvoid.Contains(aF)) {
BOPTools::MapShapesAndAncestors(aF,
TopExp::MapShapesAndAncestors(aF,
TopAbs_EDGE,
TopAbs_FACE,
aMEF);
@ -217,7 +214,7 @@ void BOPAlgo_BuilderSolid::PerformShapesToAvoid()
continue;
}
//
BOPCol_ListOfShape& aLF=aMEF.ChangeFromKey(aE);
TopTools_ListOfShape& aLF=aMEF.ChangeFromKey(aE);
aNbF=aLF.Extent();
if (!aNbF) {
continue;
@ -264,7 +261,7 @@ void BOPAlgo_BuilderSolid::PerformShapesToAvoid()
void BOPAlgo_BuilderSolid::PerformLoops()
{
Standard_Integer i, aNbSh;
BOPCol_ListIteratorOfListOfShape aIt;
TopTools_ListIteratorOfListOfShape aIt;
TopoDS_Iterator aItS;
Handle(NCollection_BaseAllocator) aAlr;
//
@ -300,7 +297,7 @@ void BOPAlgo_BuilderSolid::PerformLoops()
{
TopoDS_Compound aFacesSp;
BRep_Builder().MakeCompound(aFacesSp);
BOPCol_ListIteratorOfListOfShape aItLF(aSSp.StartElements());
TopTools_ListIteratorOfListOfShape aItLF(aSSp.StartElements());
for (; aItLF.More(); aItLF.Next()) {
BRep_Builder().Add(aFacesSp, aItLF.Value());
}
@ -309,7 +306,7 @@ void BOPAlgo_BuilderSolid::PerformLoops()
return;
}
//
const BOPCol_ListOfShape& aLSh=aSSp.Shells();
const TopTools_ListOfShape& aLSh=aSSp.Shells();
aIt.Initialize (aLSh);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aSh=aIt.Value();
@ -319,9 +316,9 @@ void BOPAlgo_BuilderSolid::PerformLoops()
//
// 2. Post Treatment
BRep_Builder aBB;
BOPCol_MapOfOrientedShape AddedFacesMap;
BOPCol_IndexedDataMapOfShapeListOfShape aEFMap;
BOPCol_MapOfOrientedShape aMP;
TopTools_MapOfOrientedShape AddedFacesMap;
TopTools_IndexedDataMapOfShapeListOfShape aEFMap;
TopTools_MapOfOrientedShape aMP;
//
// a. collect all edges that are in loops
aIt.Initialize (myLoops);
@ -362,7 +359,7 @@ void BOPAlgo_BuilderSolid::PerformLoops()
aNbSh = myShapesToAvoid.Extent();
for (i = 1; i <= aNbSh; ++i) {
const TopoDS_Shape& aFF = myShapesToAvoid(i);
BOPTools::MapShapesAndAncestors(aFF,
TopExp::MapShapesAndAncestors(aFF,
TopAbs_EDGE, TopAbs_FACE,
aEFMap);
}
@ -386,7 +383,7 @@ void BOPAlgo_BuilderSolid::PerformLoops()
aExp.Init(aF, TopAbs_EDGE);
for (; aExp.More(); aExp.Next()) {
const TopoDS_Edge& aE = (*(TopoDS_Edge*)(&aExp.Current()));
const BOPCol_ListOfShape& aLF=aEFMap.FindFromKey(aE);
const TopTools_ListOfShape& aLF=aEFMap.FindFromKey(aE);
aIt.Initialize(aLF);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Face& aFL=(*(TopoDS_Face*)(&aIt.Value()));
@ -409,15 +406,15 @@ void BOPAlgo_BuilderSolid::PerformAreas()
myAreas.Clear();
BRep_Builder aBB;
// The new solids
BOPCol_ListOfShape aNewSolids;
TopTools_ListOfShape aNewSolids;
// The hole shells which has to be classified relatively new solids
BOPCol_IndexedMapOfShape aHoleShells;
TopTools_IndexedMapOfShape aHoleShells;
// Map of the faces of the hole shells for quick check of the growths.
// If the analyzed shell contains any of the hole faces, it is considered as growth.
BOPCol_IndexedMapOfShape aMHF;
TopTools_IndexedMapOfShape aMHF;
// Analyze the shells
BOPCol_ListIteratorOfListOfShape aItLL(myLoops);
TopTools_ListIteratorOfListOfShape aItLL(myLoops);
for (; aItLL.More(); aItLL.Next())
{
const TopoDS_Shape& aShell = aItLL.Value();
@ -440,14 +437,14 @@ void BOPAlgo_BuilderSolid::PerformAreas()
else
{
aHoleShells.Add(aShell);
BOPTools::MapShapes(aShell, TopAbs_FACE, aMHF);
TopExp::MapShapes(aShell, TopAbs_FACE, aMHF);
}
}
if (aHoleShells.IsEmpty())
{
// No holes, stop the analysis
BOPCol_ListIteratorOfListOfShape aItLS(aNewSolids);
TopTools_ListIteratorOfListOfShape aItLS(aNewSolids);
for (; aItLS.More(); aItLS.Next())
{
const TopoDS_Shape& aSol = aItLS.Value();
@ -463,7 +460,7 @@ void BOPAlgo_BuilderSolid::PerformAreas()
// Classify holes relatively solids
// Prepare tree filler with the boxes of the hole shells
BOPCol_BoxBndTree aBBTree;
BOPTools_BoxBndTree aBBTree;
NCollection_UBTreeFiller <Standard_Integer, Bnd_Box> aTreeFiller(aBBTree);
Standard_Integer i, aNbH = aHoleShells.Extent();
@ -482,9 +479,9 @@ void BOPAlgo_BuilderSolid::PerformAreas()
aTreeFiller.Fill();
// Find outer growth shell that is most close to each hole shell
BOPCol_IndexedDataMapOfShapeShape aHoleSolidMap;
TopTools_IndexedDataMapOfShapeShape aHoleSolidMap;
BOPCol_ListIteratorOfListOfShape aItLS(aNewSolids);
TopTools_ListIteratorOfListOfShape aItLS(aNewSolids);
for (; aItLS.More(); aItLS.Next())
{
const TopoDS_Shape& aSolid = aItLS.Value();
@ -495,12 +492,12 @@ void BOPAlgo_BuilderSolid::PerformAreas()
myBoxes.Bind(aSolid, aBox);
BOPCol_BoxBndTreeSelector aSelector;
BOPTools_BoxBndTreeSelector aSelector;
aSelector.SetBox(aBox);
aBBTree.Select(aSelector);
const BOPCol_ListOfInteger& aLI = aSelector.Indices();
BOPCol_ListIteratorOfListOfInteger aItLI(aLI);
const TColStd_ListOfInteger& aLI = aSelector.Indices();
TColStd_ListIteratorOfListOfInteger aItLI(aLI);
for (; aItLI.More(); aItLI.Next())
{
Standard_Integer k = aItLI.Value();
@ -526,7 +523,7 @@ void BOPAlgo_BuilderSolid::PerformAreas()
}
// Make the back map from solids to holes
BOPCol_IndexedDataMapOfShapeListOfShape aSolidHolesMap;
TopTools_IndexedDataMapOfShapeListOfShape aSolidHolesMap;
aNbH = aHoleSolidMap.Extent();
for (i = 1; i <= aNbH; ++i)
@ -534,9 +531,9 @@ void BOPAlgo_BuilderSolid::PerformAreas()
const TopoDS_Shape& aHole = aHoleSolidMap.FindKey(i);
const TopoDS_Shape& aSolid = aHoleSolidMap(i);
//
BOPCol_ListOfShape* pLHoles = aSolidHolesMap.ChangeSeek(aSolid);
TopTools_ListOfShape* pLHoles = aSolidHolesMap.ChangeSeek(aSolid);
if (!pLHoles)
pLHoles = &aSolidHolesMap(aSolidHolesMap.Add(aSolid, BOPCol_ListOfShape()));
pLHoles = &aSolidHolesMap(aSolidHolesMap.Add(aSolid, TopTools_ListOfShape()));
pLHoles->Append(aHole);
}
@ -545,11 +542,11 @@ void BOPAlgo_BuilderSolid::PerformAreas()
for ( ; aItLS.More(); aItLS.Next())
{
TopoDS_Solid& aSolid = *(TopoDS_Solid*)&aItLS.Value();
const BOPCol_ListOfShape* pLHoles = aSolidHolesMap.Seek(aSolid);
const TopTools_ListOfShape* pLHoles = aSolidHolesMap.Seek(aSolid);
if (pLHoles)
{
// update solid
BOPCol_ListIteratorOfListOfShape aItLH(*pLHoles);
TopTools_ListIteratorOfListOfShape aItLH(*pLHoles);
for (; aItLH.More(); aItLH.Next())
{
const TopoDS_Shape& aHole = aItLH.Value();
@ -599,8 +596,8 @@ void BOPAlgo_BuilderSolid::PerformInternalShapes()
return;
// Get all faces to classify
BOPCol_IndexedMapOfShape aMFs;
BOPCol_ListIteratorOfListOfShape aItLS(myLoopsInternal);
TopTools_IndexedMapOfShape aMFs;
TopTools_ListIteratorOfListOfShape aItLS(myLoopsInternal);
for (; aItLS.More(); aItLS.Next())
{
const TopoDS_Shape& aShell = aItLS.Value();
@ -618,7 +615,7 @@ void BOPAlgo_BuilderSolid::PerformInternalShapes()
TopoDS_Solid aSolid;
aBB.MakeSolid(aSolid);
//
BOPCol_ListOfShape aLSI;
TopTools_ListOfShape aLSI;
MakeInternalShells(aMFs, aLSI);
//
aItLS.Initialize(aLSI);
@ -632,20 +629,20 @@ void BOPAlgo_BuilderSolid::PerformInternalShapes()
// Classify faces relatively solids
// Prepare list of faces to classify
BOPCol_ListOfShape aLFaces;
TopTools_ListOfShape aLFaces;
Standard_Integer i, aNbF = aMFs.Extent();
for (i = 1; i <= aNbF; ++i)
aLFaces.Append(aMFs(i));
// Map of solids with IN faces
BOPCol_IndexedDataMapOfShapeListOfShape aMSLF;
TopTools_IndexedDataMapOfShapeListOfShape aMSLF;
// Perform classification
BOPAlgo_Tools::ClassifyFaces(aLFaces, myAreas, myRunParallel, myContext, aMSLF, myBoxes);
// Update Solids by internal Faces
BOPCol_MapOfShape aMFDone;
TopTools_MapOfShape aMFDone;
Standard_Integer aNbS = aMSLF.Extent();
for (i = 1; i <= aNbS; ++i)
@ -653,11 +650,11 @@ void BOPAlgo_BuilderSolid::PerformInternalShapes()
const TopoDS_Shape& aSolid = aMSLF.FindKey(i);
TopoDS_Shape *pSolid = (TopoDS_Shape*)&aSolid;
const BOPCol_ListOfShape& aLF = aMSLF(i);
const TopTools_ListOfShape& aLF = aMSLF(i);
if (aLF.IsEmpty())
continue;
BOPCol_IndexedMapOfShape aMF;
TopTools_IndexedMapOfShape aMF;
aItLS.Initialize(aLF);
for (; aItLS.More(); aItLS.Next())
{
@ -666,7 +663,7 @@ void BOPAlgo_BuilderSolid::PerformInternalShapes()
aMFDone.Add(aF);
}
//
BOPCol_ListOfShape aLSI;
TopTools_ListOfShape aLSI;
MakeInternalShells(aMF, aLSI);
//
aItLS.Initialize(aLSI);
@ -678,7 +675,7 @@ void BOPAlgo_BuilderSolid::PerformInternalShapes()
}
// Make solid from the unused faces (if any)
BOPCol_IndexedMapOfShape aMFUnUsed;
TopTools_IndexedMapOfShape aMFUnUsed;
for (i = 1; i <= aNbF; ++i)
{
const TopoDS_Shape& aF = aMFs(i);
@ -691,7 +688,7 @@ void BOPAlgo_BuilderSolid::PerformInternalShapes()
TopoDS_Solid aSolid;
aBB.MakeSolid(aSolid);
//
BOPCol_ListOfShape aLSI;
TopTools_ListOfShape aLSI;
MakeInternalShells(aMFUnUsed, aLSI);
//
aItLS.Initialize(aLSI);
@ -711,19 +708,19 @@ void BOPAlgo_BuilderSolid::PerformInternalShapes()
//function : MakeInternalShells
//purpose :
//=======================================================================
void MakeInternalShells(const BOPCol_IndexedMapOfShape& theMF,
BOPCol_ListOfShape& theShells)
void MakeInternalShells(const TopTools_IndexedMapOfShape& theMF,
TopTools_ListOfShape& theShells)
{
Standard_Integer i, aNbF;
BRep_Builder aBB;
BOPCol_ListIteratorOfListOfShape aItF;
BOPCol_IndexedDataMapOfShapeListOfShape aMEF;
BOPCol_MapOfShape aAddedFacesMap;
TopTools_ListIteratorOfListOfShape aItF;
TopTools_IndexedDataMapOfShapeListOfShape aMEF;
TopTools_MapOfShape aAddedFacesMap;
//
aNbF = theMF.Extent();
for (i = 1; i <= aNbF; ++i) {
TopoDS_Shape aF = theMF(i);
BOPTools::MapShapesAndAncestors(aF,
TopExp::MapShapesAndAncestors(aF,
TopAbs_EDGE, TopAbs_FACE,
aMEF);
}
@ -747,7 +744,7 @@ void MakeInternalShells(const BOPCol_IndexedMapOfShape& theMF,
TopExp_Explorer aEdgeExp(aF, TopAbs_EDGE);
for (; aEdgeExp.More(); aEdgeExp.Next()) {
const TopoDS_Shape& aE =aEdgeExp.Current();
const BOPCol_ListOfShape& aLF=aMEF.FindFromKey(aE);
const TopTools_ListOfShape& aLF=aMEF.FindFromKey(aE);
aItF.Initialize(aLF);
for (; aItF.More(); aItF.Next()) {
TopoDS_Shape aFL=aItF.Value();
@ -796,8 +793,8 @@ Standard_Boolean IsInside(const TopoDS_Shape& theS1,
aState=aClsf.State();
}
else {
BOPCol_IndexedMapOfShape aBounds;
BOPTools::MapShapes(*pS2, TopAbs_EDGE, aBounds);
TopTools_IndexedMapOfShape aBounds;
TopExp::MapShapes(*pS2, TopAbs_EDGE, aBounds);
const TopoDS_Face& aF = (*(TopoDS_Face*)(&aExp.Current()));
aState=BOPTools_AlgoTools::ComputeState(aF, *pS2,
Precision::Confusion(),
@ -810,7 +807,7 @@ Standard_Boolean IsInside(const TopoDS_Shape& theS1,
//purpose :
//=======================================================================
Standard_Boolean IsGrowthShell(const TopoDS_Shape& theShell,
const BOPCol_IndexedMapOfShape& theMHF)
const TopTools_IndexedMapOfShape& theMHF)
{
if (theMHF.Extent())
{

10
src/BOPAlgo/BOPAlgo_BuilderSolid.hxx
View File

@ -24,8 +24,8 @@
#include <TopoDS_Solid.hxx>
#include <BOPAlgo_BuilderArea.hxx>
#include <BOPCol_BaseAllocator.hxx>
#include <BOPCol_DataMapOfShapeBox.hxx>
#include <NCollection_BaseAllocator.hxx>
#include <TopTools_DataMapOfShapeBox.hxx>
class TopoDS_Solid;
@ -40,7 +40,7 @@ public:
Standard_EXPORT BOPAlgo_BuilderSolid();
Standard_EXPORT virtual ~BOPAlgo_BuilderSolid();
Standard_EXPORT BOPAlgo_BuilderSolid(const BOPCol_BaseAllocator& theAllocator);
Standard_EXPORT BOPAlgo_BuilderSolid(const Handle(NCollection_BaseAllocator)& theAllocator);
//! Sets the source solid <theSolid>
Standard_EXPORT void SetSolid (const TopoDS_Solid& theSolid);
@ -52,7 +52,7 @@ Standard_EXPORT virtual ~BOPAlgo_BuilderSolid();
Standard_EXPORT virtual void Perform() Standard_OVERRIDE;
//! Returns the map of solid/box pairs
const BOPCol_DataMapOfShapeBox& GetBoxesMap() const
const TopTools_DataMapOfShapeBox& GetBoxesMap() const
{
return myBoxes;
}
@ -83,7 +83,7 @@ protected:
private:
BOPCol_DataMapOfShapeBox myBoxes; // Boxes of the produced solids
TopTools_DataMapOfShapeBox myBoxes; // Boxes of the produced solids
};

46
src/BOPAlgo/BOPAlgo_Builder_1.cxx
View File

@ -18,9 +18,6 @@
#include <BOPAlgo_Builder.hxx>
#include <BOPAlgo_PaveFiller.hxx>
#include <BOPCol_DataMapOfIntegerInteger.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <BOPDS_DS.hxx>
#include <BOPDS_ListOfPaveBlock.hxx>
#include <BOPDS_PaveBlock.hxx>
@ -31,8 +28,11 @@
#include <BRep_Tool.hxx>
#include <IntTools_Context.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <TColStd_DataMapOfIntegerInteger.hxx>
#include <TopoDS_Iterator.hxx>
#include <TopoDS_Shape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
//=======================================================================
//function : FillImagesVertices
@ -41,9 +41,9 @@
void BOPAlgo_Builder::FillImagesVertices()
{
Standard_Integer nV, nVSD;
BOPCol_DataMapIteratorOfDataMapOfIntegerInteger aIt;
TColStd_DataMapIteratorOfDataMapOfIntegerInteger aIt;
//
const BOPCol_DataMapOfIntegerInteger& aMSDV=myDS->ShapesSD();
const TColStd_DataMapOfIntegerInteger& aMSDV=myDS->ShapesSD();
aIt.Initialize(aMSDV);
for (; aIt.More(); aIt.Next()) {
nV=aIt.Key();
@ -51,16 +51,16 @@ void BOPAlgo_Builder::FillImagesVertices()
const TopoDS_Shape& aV=myDS->Shape(nV);
const TopoDS_Shape& aVSD=myDS->Shape(nVSD);
//
BOPCol_ListOfShape aLVSD(myAllocator);
TopTools_ListOfShape aLVSD(myAllocator);
//
aLVSD.Append(aVSD);
myImages.Bind(aV, aLVSD);
//
myShapesSD.Bind(aV, aVSD);
//
BOPCol_ListOfShape* pLOr = myOrigins.ChangeSeek(aVSD);
TopTools_ListOfShape* pLOr = myOrigins.ChangeSeek(aVSD);
if (!pLOr) {
pLOr = myOrigins.Bound(aVSD, BOPCol_ListOfShape());
pLOr = myOrigins.Bound(aVSD, TopTools_ListOfShape());
}
pLOr->Append(aV);
}
@ -89,7 +89,7 @@ void BOPAlgo_Builder::FillImagesVertices()
// Fill the images of the edge from the list of its pave blocks.
// The small edges, having no pave blocks, will have the empty list
// of images and, thus, will be avoided in the result.
BOPCol_ListOfShape *pLS = myImages.Bound(aE, BOPCol_ListOfShape());
TopTools_ListOfShape *pLS = myImages.Bound(aE, TopTools_ListOfShape());
//
BOPDS_ListIteratorOfListOfPaveBlock aItPB(aLPB);
for (; aItPB.More(); aItPB.Next()) {
@ -100,9 +100,9 @@ void BOPAlgo_Builder::FillImagesVertices()
const TopoDS_Shape& aSpR = myDS->Shape(nSpR);
pLS->Append(aSpR);
//
BOPCol_ListOfShape* pLOr = myOrigins.ChangeSeek(aSpR);
TopTools_ListOfShape* pLOr = myOrigins.ChangeSeek(aSpR);
if (!pLOr) {
pLOr = myOrigins.Bound(aSpR, BOPCol_ListOfShape());
pLOr = myOrigins.Bound(aSpR, TopTools_ListOfShape());
}
pLOr->Append(aE);
//
@ -142,8 +142,8 @@ void BOPAlgo_Builder::FillImagesVertices()
{
TopAbs_ShapeEnum aType;
BRep_Builder aBB;
BOPCol_MapOfShape aM;
BOPCol_ListIteratorOfListOfShape aIt, aItIm;
TopTools_MapOfShape aM;
TopTools_ListIteratorOfListOfShape aIt, aItIm;
//
aIt.Initialize(myArguments);
for (; aIt.More(); aIt.Next()) {
@ -151,7 +151,7 @@ void BOPAlgo_Builder::FillImagesVertices()
aType=aS.ShapeType();
if (aType==theType) {
if (myImages.IsBound(aS)){
const BOPCol_ListOfShape& aLSIm=myImages.Find(aS);
const TopTools_ListOfShape& aLSIm=myImages.Find(aS);
aItIm.Initialize(aLSIm);
for (; aItIm.More(); aItIm.Next()) {
const TopoDS_Shape& aSIm=aItIm.Value();
@ -175,7 +175,7 @@ void BOPAlgo_Builder::FillImagesVertices()
void BOPAlgo_Builder::FillImagesContainers(const TopAbs_ShapeEnum theType)
{
Standard_Integer i, aNbS;
BOPCol_MapOfShape aMFP(100, myAllocator);
TopTools_MapOfShape aMFP(100, myAllocator);
//
aNbS=myDS->NbSourceShapes();
for (i=0; i<aNbS; ++i) {
@ -193,7 +193,7 @@ void BOPAlgo_Builder::FillImagesVertices()
void BOPAlgo_Builder::FillImagesCompounds()
{
Standard_Integer i, aNbS;
BOPCol_MapOfShape aMFP(100, myAllocator);
TopTools_MapOfShape aMFP(100, myAllocator);
//
aNbS=myDS->NbSourceShapes();
for (i=0; i<aNbS; ++i) {
@ -214,7 +214,7 @@ void BOPAlgo_Builder::FillImagesVertices()
Standard_Boolean bInterferred, bToReverse;
TopoDS_Iterator aIt;
BRep_Builder aBB;
BOPCol_ListIteratorOfListOfShape aItIm;
TopTools_ListIteratorOfListOfShape aItIm;
//
bInterferred=IsInterferred(theS);
if (!bInterferred){
@ -228,7 +228,7 @@ void BOPAlgo_Builder::FillImagesVertices()
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aSx=aIt.Value();
if (myImages.IsBound(aSx)) {
const BOPCol_ListOfShape& aLFIm=myImages.Find(aSx);
const TopTools_ListOfShape& aLFIm=myImages.Find(aSx);
aItIm.Initialize(aLFIm);
for (; aItIm.More(); aItIm.Next()) {
TopoDS_Shape aSxIm=aItIm.Value();
@ -247,7 +247,7 @@ void BOPAlgo_Builder::FillImagesVertices()
//
aCIm.Closed(BRep_Tool::IsClosed(aCIm));
//
BOPCol_ListOfShape aLSIm(myAllocator);
TopTools_ListOfShape aLSIm(myAllocator);
aLSIm.Append(aCIm);
myImages.Bind(theS, aLSIm);
}
@ -256,13 +256,13 @@ void BOPAlgo_Builder::FillImagesVertices()
//purpose :
//=======================================================================
void BOPAlgo_Builder::FillImagesCompound(const TopoDS_Shape& theS,
BOPCol_MapOfShape& theMFP)
TopTools_MapOfShape& theMFP)
{
Standard_Boolean bInterferred;
TopAbs_Orientation aOrX;
TopoDS_Iterator aIt;
BRep_Builder aBB;
BOPCol_ListIteratorOfListOfShape aItIm;
TopTools_ListIteratorOfListOfShape aItIm;
//
if (!theMFP.Add(theS)) {
return;
@ -291,7 +291,7 @@ void BOPAlgo_Builder::FillImagesVertices()
const TopoDS_Shape& aSX=aIt.Value();
aOrX=aSX.Orientation();
if (myImages.IsBound(aSX)) {
const BOPCol_ListOfShape& aLFIm=myImages.Find(aSX);
const TopTools_ListOfShape& aLFIm=myImages.Find(aSX);
aItIm.Initialize(aLFIm);
for (; aItIm.More(); aItIm.Next()) {
TopoDS_Shape aSXIm=aItIm.Value();
@ -304,7 +304,7 @@ void BOPAlgo_Builder::FillImagesVertices()
}
}
//
BOPCol_ListOfShape aLSIm(myAllocator);
TopTools_ListOfShape aLSIm(myAllocator);
aLSIm.Append(aCIm);
myImages.Bind(theS, aLSIm);
}

131
src/BOPAlgo/BOPAlgo_Builder_2.cxx
View File

@ -20,13 +20,6 @@
#include <BOPAlgo_BuilderFace.hxx>
#include <BOPAlgo_PaveFiller.hxx>
#include <BOPAlgo_Tools.hxx>
#include <BOPCol_DataMapOfIntegerListOfShape.hxx>
#include <BOPCol_DataMapOfShapeShape.hxx>
#include <BOPCol_ListOfInteger.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_MapOfInteger.hxx>
#include <BOPCol_NCVector.hxx>
#include <BOPCol_Parallel.hxx>
#include <BOPDS_DS.hxx>
#include <BOPDS_FaceInfo.hxx>
#include <BOPDS_Interf.hxx>
@ -36,7 +29,6 @@
#include <BOPDS_VectorOfCurve.hxx>
#include <BOPDS_VectorOfInterfFF.hxx>
#include <BOPDS_VectorOfPoint.hxx>
#include <BOPTools.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_AlgoTools2D.hxx>
#include <BOPTools_AlgoTools3D.hxx>
@ -44,14 +36,18 @@
#include <BOPTools_DataMapOfShapeSet.hxx>
#include <BOPTools_ListOfCoupleOfShape.hxx>
#include <BOPTools_MapOfSet.hxx>
#include <BOPTools_Parallel.hxx>
#include <BRep_Builder.hxx>
#include <BRepLib.hxx>
#include <BRep_Tool.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <GeomLib.hxx>
#include <NCollection_IncAllocator.hxx>
#include <NCollection_Vector.hxx>
#include <Precision.hxx>
#include <IntTools_Context.hxx>
#include <TColStd_ListOfInteger.hxx>
#include <TColStd_MapOfInteger.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Compound.hxx>
@ -59,12 +55,13 @@
#include <TopoDS_Face.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopTools_ListOfShape.hxx>
#include <algorithm>
//
static
TopoDS_Face BuildDraftFace(const TopoDS_Face& theFace,
const BOPCol_DataMapOfShapeListOfShape& theImages,
const TopTools_DataMapOfShapeListOfShape& theImages,
Handle(IntTools_Context)& theCtx);
//=======================================================================
@ -119,30 +116,30 @@ class BOPAlgo_PairOfShapeBoolean : public BOPAlgo_Algo {
Handle(IntTools_Context) myContext;
};
//
typedef BOPCol_NCVector<BOPAlgo_PairOfShapeBoolean> \
typedef NCollection_Vector<BOPAlgo_PairOfShapeBoolean> \
BOPAlgo_VectorOfPairOfShapeBoolean;
//
typedef BOPCol_ContextFunctor
typedef BOPTools_ContextFunctor
<BOPAlgo_PairOfShapeBoolean,
BOPAlgo_VectorOfPairOfShapeBoolean,
Handle(IntTools_Context),
IntTools_Context> BOPCol_BuilderSDFaceFunctor;
IntTools_Context> BOPAlgo_BuilderSDFaceFunctor;
//
typedef BOPCol_ContextCnt
<BOPCol_BuilderSDFaceFunctor,
typedef BOPTools_ContextCnt
<BOPAlgo_BuilderSDFaceFunctor,
BOPAlgo_VectorOfPairOfShapeBoolean,
Handle(IntTools_Context)> BOPAlgo_BuilderSDFaceCnt;
//
//=======================================================================
// BuilderFace
//
typedef BOPCol_NCVector<BOPAlgo_BuilderFace> BOPAlgo_VectorOfBuilderFace;
typedef NCollection_Vector<BOPAlgo_BuilderFace> BOPAlgo_VectorOfBuilderFace;
//
typedef BOPCol_Functor
typedef BOPTools_Functor
<BOPAlgo_BuilderFace,
BOPAlgo_VectorOfBuilderFace> BOPAlgo_BuilderFaceFunctor;
//
typedef BOPCol_Cnt
typedef BOPTools_Cnt
<BOPAlgo_BuilderFaceFunctor,
BOPAlgo_VectorOfBuilderFace> BOPAlgo_BuilderFaceCnt;
//
@ -205,15 +202,15 @@ class BOPAlgo_VFI : public BOPAlgo_Algo {
Handle(IntTools_Context) myContext;
};
//
typedef BOPCol_NCVector<BOPAlgo_VFI> BOPAlgo_VectorOfVFI;
typedef NCollection_Vector<BOPAlgo_VFI> BOPAlgo_VectorOfVFI;
//
typedef BOPCol_ContextFunctor
typedef BOPTools_ContextFunctor
<BOPAlgo_VFI,
BOPAlgo_VectorOfVFI,
Handle(IntTools_Context),
IntTools_Context> BOPAlgo_VFIFunctor;
//
typedef BOPCol_ContextCnt
typedef BOPTools_ContextCnt
<BOPAlgo_VFIFunctor,
BOPAlgo_VectorOfVFI,
Handle(IntTools_Context)> BOPAlgo_VFICnt;
@ -240,9 +237,9 @@ void BOPAlgo_Builder::BuildSplitFaces()
TopoDS_Edge aSp, aEE;
TopAbs_Orientation anOriF, anOriE;
TopExp_Explorer aExp;
BOPCol_ListIteratorOfListOfShape aIt;
BOPCol_ListOfInteger aLIAV;
BOPCol_MapOfShape aMFence;
TopTools_ListIteratorOfListOfShape aIt;
TColStd_ListOfInteger aLIAV;
TopTools_MapOfShape aMFence;
Handle(NCollection_BaseAllocator) aAllocator;
BOPAlgo_VectorOfBuilderFace aVBF;
//
@ -250,12 +247,12 @@ void BOPAlgo_Builder::BuildSplitFaces()
aAllocator=
NCollection_BaseAllocator::CommonBaseAllocator();
//
BOPCol_ListOfShape aLE(aAllocator);
BOPCol_MapOfShape aMDE(100, aAllocator);
TopTools_ListOfShape aLE(aAllocator);
TopTools_MapOfShape aMDE(100, aAllocator);
//
// Build temporary map of faces images to avoid rebuilding
// of the faces without any IN or section edges
NCollection_IndexedDataMap<Standard_Integer, BOPCol_ListOfShape> aFacesIm;
NCollection_IndexedDataMap<Standard_Integer, TopTools_ListOfShape> aFacesIm;
//
aNbS=myDS->NbSourceShapes();
//
@ -302,7 +299,7 @@ void BOPAlgo_Builder::BuildSplitFaces()
TopoDS_Face aFD = BuildDraftFace(aF, myImages, myContext);
if (!aFD.IsNull())
{
aFacesIm(aFacesIm.Add(i, BOPCol_ListOfShape())).Append(aFD);
aFacesIm(aFacesIm.Add(i, TopTools_ListOfShape())).Append(aFD);
continue;
}
}
@ -359,7 +356,7 @@ void BOPAlgo_Builder::BuildSplitFaces()
bIsDegenerated=BRep_Tool::Degenerated(aE);
const BOPCol_ListOfShape& aLIE=myImages.Find(aE);
const TopTools_ListOfShape& aLIE=myImages.Find(aE);
aIt.Initialize(aLIE);
for (; aIt.More(); aIt.Next()) {
aSp=(*(TopoDS_Edge*)(&aIt.Value()));
@ -431,7 +428,7 @@ void BOPAlgo_Builder::BuildSplitFaces()
BRepLib::BuildPCurveForEdgesOnPlane(aLE, aFF);
}
// 3 Build split faces
BOPAlgo_BuilderFace& aBF=aVBF.Append1();
BOPAlgo_BuilderFace& aBF=aVBF.Appended();
aBF.SetFace(aF);
aBF.SetShapes(aLE);
aBF.SetRunParallel(myRunParallel);
@ -443,7 +440,7 @@ void BOPAlgo_Builder::BuildSplitFaces()
BOPAlgo_BuilderFaceCnt::Perform(myRunParallel, aVBF);
//===================================================
//
Standard_Integer aNbBF = aVBF.Extent();
Standard_Integer aNbBF = aVBF.Length();
for (k = 0; k < aNbBF; ++k)
{
BOPAlgo_BuilderFace& aBF = aVBF(k);
@ -455,9 +452,9 @@ void BOPAlgo_Builder::BuildSplitFaces()
{
const TopoDS_Face& aF = TopoDS::Face(myDS->Shape(aFacesIm.FindKey(k)));
anOriF = aF.Orientation();
const BOPCol_ListOfShape& aLFR = aFacesIm(k);
const TopTools_ListOfShape& aLFR = aFacesIm(k);
//
BOPCol_ListOfShape* pLFIm = mySplits.Bound(aF, BOPCol_ListOfShape());
TopTools_ListOfShape* pLFIm = mySplits.Bound(aF, TopTools_ListOfShape());
aIt.Initialize(aLFR);
for (; aIt.More(); aIt.Next()) {
TopoDS_Shape& aFR=aIt.ChangeValue();
@ -476,7 +473,7 @@ void BOPAlgo_Builder::BuildSplitFaces()
//=======================================================================
typedef
NCollection_IndexedDataMap<BOPTools_Set,
BOPCol_ListOfShape,
TopTools_ListOfShape,
BOPTools_SetMapHasher> BOPAlgo_IndexedDataMapOfSetListOfShape;
static void AddEdgeSet(const TopoDS_Shape& theS,
@ -487,9 +484,9 @@ static void AddEdgeSet(const TopoDS_Shape& theS,
BOPTools_Set aSE;
aSE.Add(theS, TopAbs_EDGE);
// Add set to the map, keeping connection to the shape
BOPCol_ListOfShape* pLF = theMap.ChangeSeek(aSE);
TopTools_ListOfShape* pLF = theMap.ChangeSeek(aSE);
if (!pLF)
pLF = &theMap(theMap.Add(aSE, BOPCol_ListOfShape(theAllocator)));
pLF = &theMap(theMap.Add(aSE, TopTools_ListOfShape(theAllocator)));
pLF->Append(theS);
}
@ -502,7 +499,7 @@ void BOPAlgo_Builder::FillSameDomainFaces()
// It is necessary to analyze all Face/Face intersections
// and find all faces with equal sets of edges
const BOPDS_VectorOfInterfFF& aFFs = myDS->InterfFF();
Standard_Integer aNbFFs = aFFs.Extent();
Standard_Integer aNbFFs = aFFs.Length();
if (!aNbFFs)
return;
@ -511,9 +508,9 @@ void BOPAlgo_Builder::FillSameDomainFaces()
// Vector to store the indices of faces for future sorting
// for making the SD face for the group from the face with
// smallest index in Data structure
BOPCol_NCVector<Standard_Integer> aFIVec(256, aAllocator);
NCollection_Vector<Standard_Integer> aFIVec(256, aAllocator);
// Fence map to avoid repeated checks of the same face.
BOPCol_MapOfInteger aMFence(1, aAllocator);
TColStd_MapOfInteger aMFence(1, aAllocator);
// Fill the vector with indices of faces
for (Standard_Integer i = 0; i < aNbFFs; ++i)
@ -531,7 +528,7 @@ void BOPAlgo_Builder::FillSameDomainFaces()
if (!aMFence.Add(nF[j]))
continue;
aFIVec.Append1() = nF[j];
aFIVec.Appended() = nF[j];
}
}
@ -540,13 +537,13 @@ void BOPAlgo_Builder::FillSameDomainFaces()
// Data map of set of edges with all faces having this set
NCollection_IndexedDataMap<BOPTools_Set,
BOPCol_ListOfShape,
TopTools_ListOfShape,
BOPTools_SetMapHasher> anESetFaces(1, aAllocator);
// Map of planar bounded faces. If such faces have the same Edge set
// they are considered Same domain, without additional check.
BOPCol_MapOfShape aMFPlanar(1, aAllocator);
TopTools_MapOfShape aMFPlanar(1, aAllocator);
Standard_Integer aNbF = aFIVec.Extent();
Standard_Integer aNbF = aFIVec.Length();
for (Standard_Integer i = 0; i < aNbF; ++i)
{
const Standard_Integer nF = aFIVec(i);
@ -567,10 +564,10 @@ void BOPAlgo_Builder::FillSameDomainFaces()
}
}
const BOPCol_ListOfShape* pLFSp = mySplits.Seek(aF);
const TopTools_ListOfShape* pLFSp = mySplits.Seek(aF);
if (pLFSp)
{
BOPCol_ListIteratorOfListOfShape aItLF(*pLFSp);
TopTools_ListIteratorOfListOfShape aItLF(*pLFSp);
for (; aItLF.More(); aItLF.Next())
{
AddEdgeSet(aItLF.Value(), anESetFaces, aAllocator);
@ -590,23 +587,23 @@ void BOPAlgo_Builder::FillSameDomainFaces()
BOPAlgo_VectorOfPairOfShapeBoolean aVPSB;
// Back and forth map of SD faces to make the blocks
BOPCol_IndexedDataMapOfShapeListOfShape aDMSLS(1, aAllocator);
TopTools_IndexedDataMapOfShapeListOfShape aDMSLS(1, aAllocator);
Standard_Integer aNbSets = anESetFaces.Extent();
for (Standard_Integer i = 1; i <= aNbSets; ++i)
{
const BOPCol_ListOfShape& aLF = anESetFaces(i);
const TopTools_ListOfShape& aLF = anESetFaces(i);
if (aLF.Extent() < 2)
continue;
// All possible pairs from <aLF> should be checked
BOPCol_ListIteratorOfListOfShape aIt1(aLF);
TopTools_ListIteratorOfListOfShape aIt1(aLF);
for (; aIt1.More(); aIt1.Next())
{
const TopoDS_Shape& aF1 = aIt1.Value();
Standard_Boolean bCheckPlanar = aMFPlanar.Contains(aF1);
BOPCol_ListIteratorOfListOfShape aIt2 = aIt1;
TopTools_ListIteratorOfListOfShape aIt2 = aIt1;
for (aIt2.Next(); aIt2.More(); aIt2.Next())
{
const TopoDS_Shape& aF2 = aIt2.Value();
@ -617,7 +614,7 @@ void BOPAlgo_Builder::FillSameDomainFaces()
continue;
}
// Add pair for analysis
BOPAlgo_PairOfShapeBoolean& aPSB = aVPSB.Append1();
BOPAlgo_PairOfShapeBoolean& aPSB = aVPSB.Appended();
aPSB.Shape1() = aF1;
aPSB.Shape2() = aF2;
aPSB.SetFuzzyValue(myFuzzyValue);
@ -631,9 +628,9 @@ void BOPAlgo_Builder::FillSameDomainFaces()
BOPAlgo_BuilderSDFaceCnt::Perform(myRunParallel, aVPSB, myContext);
//================================================================
NCollection_List<BOPCol_ListOfShape> aMBlocks(aAllocator);
NCollection_List<TopTools_ListOfShape> aMBlocks(aAllocator);
// Fill map with SD faces to make the blocks
Standard_Integer aNbPairs = aVPSB.Extent();
Standard_Integer aNbPairs = aVPSB.Length();
for (Standard_Integer i = 0; i < aNbPairs; ++i)
{
BOPAlgo_PairOfShapeBoolean& aPSB = aVPSB(i);
@ -648,20 +645,20 @@ void BOPAlgo_Builder::FillSameDomainFaces()
(aDMSLS, aMBlocks, aAllocator);
// Fill same domain faces map
NCollection_List<BOPCol_ListOfShape>::Iterator aItB(aMBlocks);
NCollection_List<TopTools_ListOfShape>::Iterator aItB(aMBlocks);
for (; aItB.More(); aItB.Next())
{
const BOPCol_ListOfShape& aLSD = aItB.Value();
const TopTools_ListOfShape& aLSD = aItB.Value();
// First face will be SD face for all faces in the group
const TopoDS_Shape& aFSD1 = aLSD.First();
BOPCol_ListIteratorOfListOfShape aItLF(aLSD);
TopTools_ListIteratorOfListOfShape aItLF(aLSD);
for (; aItLF.More(); aItLF.Next())
{
const TopoDS_Shape& aFSD = aItLF.Value();
myShapesSD.Bind(aFSD, aFSD1);
// If the face has no splits but have an SD face, it is considered as being split
if (myDS->Index(aFSD) >= 0)
mySplits.Bound(aFSD, BOPCol_ListOfShape())->Append(aFSD);
mySplits.Bound(aFSD, TopTools_ListOfShape())->Append(aFSD);
}
}
aMBlocks.Clear();
@ -677,10 +674,10 @@ void BOPAlgo_Builder::FillImagesFaces1()
TopoDS_Face aFSD;
TopoDS_Vertex aVx;
BRep_Builder aBB;
BOPCol_ListOfInteger aLIAV;
BOPCol_ListOfShape aLFIm;
BOPCol_ListIteratorOfListOfInteger aItV;
BOPCol_ListIteratorOfListOfShape aItLS, aItF;
TColStd_ListOfInteger aLIAV;
TopTools_ListOfShape aLFIm;
TColStd_ListIteratorOfListOfInteger aItV;
TopTools_ListIteratorOfListOfShape aItLS, aItF;
BOPAlgo_VectorOfVFI aVVFI;
//
aNbS=myDS->NbSourceShapes();
@ -701,7 +698,7 @@ void BOPAlgo_Builder::FillImagesFaces1()
myDS->AloneVertices(i, aLIAV);
aLFIm.Clear();
//
const BOPCol_ListOfShape& aLSp=mySplits.Find(aF);
const TopTools_ListOfShape& aLSp=mySplits.Find(aF);
aItLS.Initialize(aLSp);
for (; aItLS.More(); aItLS.Next()) {
const TopoDS_Face& aFSp=(*(TopoDS_Face*)(&aItLS.Value()));
@ -727,9 +724,9 @@ void BOPAlgo_Builder::FillImagesFaces1()
for (; aItLS.More(); aItLS.Next()) {
const TopoDS_Face& aFSp=(*(TopoDS_Face*)(&aItLS.Value()));
//
BOPCol_ListOfShape* pLOr = myOrigins.ChangeSeek(aFSp);
TopTools_ListOfShape* pLOr = myOrigins.ChangeSeek(aFSp);
if (!pLOr) {
pLOr = myOrigins.Bound(aFSp, BOPCol_ListOfShape());
pLOr = myOrigins.Bound(aFSp, TopTools_ListOfShape());
}
pLOr->Append(aF);
}
@ -745,7 +742,7 @@ void BOPAlgo_Builder::FillImagesFaces1()
for (; aItF.More(); aItF.Next()) {
TopoDS_Face& aFy=(*(TopoDS_Face*)(&aItF.Value()));
//
BOPAlgo_VFI& aVFI=aVVFI.Append1();
BOPAlgo_VFI& aVFI=aVVFI.Appended();
aVFI.SetVertex(aVx);
aVFI.SetFace(aFy);
aVFI.SetFuzzyValue(myFuzzyValue);
@ -755,7 +752,7 @@ void BOPAlgo_Builder::FillImagesFaces1()
}// for (i=0; i<aNbS; ++i) {
//
// 4.
aNbVFI=aVVFI.Extent();
aNbVFI=aVVFI.Length();
//================================================================
BOPAlgo_VFICnt::Perform(myRunParallel, aVVFI, myContext);
//================================================================
@ -777,7 +774,7 @@ void BOPAlgo_Builder::FillImagesFaces1()
// according to the information stored into the <theImages> map
//=======================================================================
TopoDS_Face BuildDraftFace(const TopoDS_Face& theFace,
const BOPCol_DataMapOfShapeListOfShape& theImages,
const TopTools_DataMapOfShapeListOfShape& theImages,
Handle(IntTools_Context)& theCtx)
{
BRep_Builder aBB;
@ -818,7 +815,7 @@ TopoDS_Face BuildDraftFace(const TopoDS_Face& theFace,
return aNull;
}
const BOPCol_ListOfShape* pLEIm = theImages.Seek(aE);
const TopTools_ListOfShape* pLEIm = theImages.Seek(aE);
if (!pLEIm)
{
aBB.Add(aNewWire, aE);
@ -830,7 +827,7 @@ TopoDS_Face BuildDraftFace(const TopoDS_Face& theFace,
// Check if the original edge is closed on the face
Standard_Boolean bIsClosed = BRep_Tool::IsClosed(aE, theFace);
BOPCol_ListIteratorOfListOfShape aItLEIm(*pLEIm);
TopTools_ListIteratorOfListOfShape aItLEIm(*pLEIm);
for (; aItLEIm.More(); aItLEIm.Next())
{
TopoDS_Edge& aSp = TopoDS::Edge(aItLEIm.Value());

150
src/BOPAlgo/BOPAlgo_Builder_3.cxx
View File

@ -41,36 +41,32 @@
#include <BOPAlgo_Tools.hxx>
#include <BOPAlgo_BuilderSolid.hxx>
//
#include <BOPCol_IndexedMapOfShape.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <BOPCol_IndexedDataMapOfShapeListOfShape.hxx>
#include <BOPCol_IndexedDataMapOfShapeShape.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_BoxBndTree.hxx>
#include <BOPCol_ListOfInteger.hxx>
#include <BOPCol_DataMapOfIntegerShape.hxx>
#include <BOPCol_NCVector.hxx>
#include <BOPCol_Parallel.hxx>
//
#include <IntTools_Context.hxx>
//
#include <BOPDS_DS.hxx>
#include <BOPDS_ShapeInfo.hxx>
//
#include <BOPTools.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_MapOfSet.hxx>
#include <BOPTools_Set.hxx>
#include <BOPTools_Parallel.hxx>
//
#include <BOPAlgo_Tools.hxx>
#include <NCollection_Array1.hxx>
#include <NCollection_IncAllocator.hxx>
#include <NCollection_Vector.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_IndexedDataMapOfShapeShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <algorithm>
static
void OwnInternalShapes(const TopoDS_Shape& ,
BOPCol_IndexedMapOfShape& );
TopTools_IndexedMapOfShape& );
//=======================================================================
@ -100,8 +96,8 @@ void BOPAlgo_Builder::FillImagesSolids()
//
aAlr=NCollection_BaseAllocator::CommonBaseAllocator();
//
BOPCol_DataMapOfShapeListOfShape theInParts(100, aAlr);
BOPCol_DataMapOfShapeShape theDraftSolids(100, aAlr);
TopTools_DataMapOfShapeListOfShape theInParts(100, aAlr);
TopTools_DataMapOfShapeShape theDraftSolids(100, aAlr);
//
FillIn3DParts(theInParts, theDraftSolids, aAlr);
BuildSplitSolids(theInParts, theDraftSolids, aAlr);
@ -115,22 +111,22 @@ void BOPAlgo_Builder::FillImagesSolids()
//purpose :
//=======================================================================
void BOPAlgo_Builder::FillIn3DParts
(BOPCol_DataMapOfShapeListOfShape& theInParts,
BOPCol_DataMapOfShapeShape& theDraftSolids,
const BOPCol_BaseAllocator& )
(TopTools_DataMapOfShapeListOfShape& theInParts,
TopTools_DataMapOfShapeShape& theDraftSolids,
const Handle(NCollection_BaseAllocator)& )
{
Handle(NCollection_BaseAllocator) anAlloc = new NCollection_IncAllocator;
// Find all faces that are IN solids
// Store boxes of the shapes into a map
BOPCol_DataMapOfShapeBox aShapeBoxMap(1, anAlloc);
TopTools_DataMapOfShapeBox aShapeBoxMap(1, anAlloc);
// Fence map
BOPCol_MapOfShape aMFence(1, anAlloc);
TopTools_MapOfShape aMFence(1, anAlloc);
// Get all faces
BOPCol_ListOfShape aLFaces(anAlloc);
TopTools_ListOfShape aLFaces(anAlloc);
Standard_Integer i, aNbS = myDS->NbSourceShapes();
for (i = 0; i < aNbS; ++i)
@ -140,11 +136,11 @@ void BOPAlgo_Builder::FillIn3DParts
continue;
const TopoDS_Shape& aS = aSI.Shape();
const BOPCol_ListOfShape* pLSIm = myImages.Seek(aS);
const TopTools_ListOfShape* pLSIm = myImages.Seek(aS);
if (pLSIm)
{
BOPCol_ListIteratorOfListOfShape aItLSIm(*pLSIm);
TopTools_ListIteratorOfListOfShape aItLSIm(*pLSIm);
for (; aItLSIm.More(); aItLSIm.Next())
{
const TopoDS_Shape& aSIm = aItLSIm.Value();
@ -162,11 +158,11 @@ void BOPAlgo_Builder::FillIn3DParts
BRep_Builder aBB;
// Get all solids
BOPCol_ListOfShape aLSolids(anAlloc);
TopTools_ListOfShape aLSolids(anAlloc);
// Keep INTERNAL faces of the solids
BOPCol_DataMapOfShapeListOfShape aSolidsIF(1, anAlloc);
TopTools_DataMapOfShapeListOfShape aSolidsIF(1, anAlloc);
// Draft solids
BOPCol_IndexedDataMapOfShapeShape aDraftSolid(1, anAlloc);
TopTools_IndexedDataMapOfShapeShape aDraftSolid(1, anAlloc);
for (i = 0; i < aNbS; ++i)
{
@ -183,7 +179,7 @@ void BOPAlgo_Builder::FillIn3DParts
myDS->BuildBndBoxSolid(i, aBoxS, myCheckInverted);
// Build Draft Solid
BOPCol_ListOfShape aLIF;
TopTools_ListOfShape aLIF;
TopoDS_Solid aSD;
aBB.MakeSolid(aSD);
BuildDraftSolid(aSolid, aSD, aLIF);
@ -195,7 +191,7 @@ void BOPAlgo_Builder::FillIn3DParts
}
// Perform classification of the faces
BOPCol_IndexedDataMapOfShapeListOfShape anInParts;
TopTools_IndexedDataMapOfShapeListOfShape anInParts;
BOPAlgo_Tools::ClassifyFaces(aLFaces, aLSolids, myRunParallel,
myContext, anInParts, aShapeBoxMap, aSolidsIF);
@ -206,8 +202,8 @@ void BOPAlgo_Builder::FillIn3DParts
{
const TopoDS_Solid& aSolid = TopoDS::Solid(aDraftSolid.FindKey(i));
const TopoDS_Solid& aSDraft = TopoDS::Solid(aDraftSolid(i));
const BOPCol_ListOfShape& aLInFaces = anInParts.FindFromKey(aSDraft);
const BOPCol_ListOfShape& aLInternal = aSolidsIF.Find(aSDraft);
const TopTools_ListOfShape& aLInFaces = anInParts.FindFromKey(aSDraft);
const TopTools_ListOfShape& aLInternal = aSolidsIF.Find(aSDraft);
Standard_Integer aNbIN = aLInFaces.Extent();
@ -229,9 +225,9 @@ void BOPAlgo_Builder::FillIn3DParts
if (aNbInt || aNbIN)
{
// Combine the lists
BOPCol_ListOfShape *pLIN = theInParts.Bound(aSolid, BOPCol_ListOfShape());
TopTools_ListOfShape *pLIN = theInParts.Bound(aSolid, TopTools_ListOfShape());
BOPCol_ListIteratorOfListOfShape aItLS(aLInFaces);
TopTools_ListIteratorOfListOfShape aItLS(aLInFaces);
for (; aItLS.More(); aItLS.Next())
pLIN->Append(aItLS.Value());
@ -247,7 +243,7 @@ void BOPAlgo_Builder::FillIn3DParts
//=======================================================================
void BOPAlgo_Builder::BuildDraftSolid(const TopoDS_Shape& theSolid,
TopoDS_Shape& theDraftSolid,
BOPCol_ListOfShape& theLIF)
TopTools_ListOfShape& theLIF)
{
Standard_Boolean bToReverse;
Standard_Integer iFlag;
@ -256,7 +252,7 @@ void BOPAlgo_Builder::BuildDraftSolid(const TopoDS_Shape& theSolid,
TopoDS_Shell aShD;
TopoDS_Shape aFSDx, aFx;
BRep_Builder aBB;
BOPCol_ListIteratorOfListOfShape aItS;
TopTools_ListIteratorOfListOfShape aItS;
//
aOrSd=theSolid.Orientation();
theDraftSolid.Orientation(aOrSd);
@ -279,7 +275,7 @@ void BOPAlgo_Builder::BuildDraftSolid(const TopoDS_Shape& theSolid,
aOrF=aF.Orientation();
//
if (myImages.IsBound(aF)) {
const BOPCol_ListOfShape& aLSp=myImages.Find(aF);
const TopTools_ListOfShape& aLSp=myImages.Find(aF);
aItS.Initialize(aLSp);
for (; aItS.More(); aItS.Next()) {
aFx=aItS.Value();
@ -335,12 +331,12 @@ void BOPAlgo_Builder::BuildDraftSolid(const TopoDS_Shape& theSolid,
//=======================================================================
// Vector of Solid Builders
typedef BOPCol_NCVector<BOPAlgo_BuilderSolid> BOPAlgo_VectorOfBuilderSolid;
typedef NCollection_Vector<BOPAlgo_BuilderSolid> BOPAlgo_VectorOfBuilderSolid;
// Functors to split solids
typedef BOPCol_Functor<BOPAlgo_BuilderSolid,
typedef BOPTools_Functor<BOPAlgo_BuilderSolid,
BOPAlgo_VectorOfBuilderSolid> BOPAlgo_BuilderSolidFunctor;
//
typedef BOPCol_Cnt<BOPAlgo_BuilderSolidFunctor,
typedef BOPTools_Cnt<BOPAlgo_BuilderSolidFunctor,
BOPAlgo_VectorOfBuilderSolid> BOPAlgo_BuilderSolidCnt;
//=======================================================================
@ -349,20 +345,20 @@ typedef BOPCol_Cnt<BOPAlgo_BuilderSolidFunctor,
//purpose :
//=======================================================================
void BOPAlgo_Builder::BuildSplitSolids
(BOPCol_DataMapOfShapeListOfShape& theInParts,
BOPCol_DataMapOfShapeShape& theDraftSolids,
const BOPCol_BaseAllocator& )
(TopTools_DataMapOfShapeListOfShape& theInParts,
TopTools_DataMapOfShapeShape& theDraftSolids,
const Handle(NCollection_BaseAllocator)& )
{
Standard_Boolean bFlagSD;
Standard_Integer i, aNbS;
TopExp_Explorer aExp;
BOPCol_ListIteratorOfListOfShape aIt;
TopTools_ListIteratorOfListOfShape aIt;
//
Handle(NCollection_BaseAllocator) aAlr0;
aAlr0=NCollection_BaseAllocator::CommonBaseAllocator();
//
BOPCol_ListOfShape aSFS(aAlr0), aLSEmpty(aAlr0);
BOPCol_MapOfShape aMFence(100, aAlr0);
TopTools_ListOfShape aSFS(aAlr0), aLSEmpty(aAlr0);
TopTools_MapOfShape aMFence(100, aAlr0);
BOPTools_MapOfSet aMST(100, aAlr0);
BOPAlgo_VectorOfBuilderSolid aVBS;
//
@ -392,7 +388,7 @@ void BOPAlgo_Builder::BuildSplitSolids
//
// Build temporary map of solids images to avoid rebuilding
// of the solids without internal faces
BOPCol_IndexedDataMapOfShapeListOfShape aSolidsIm;
TopTools_IndexedDataMapOfShapeListOfShape aSolidsIm;
// 1. Build solids for interfered source solids
for (i = 0; i < aNbS; ++i) {
const BOPDS_ShapeInfo& aSI = myDS->ShapeInfo(i);
@ -405,10 +401,10 @@ void BOPAlgo_Builder::BuildSplitSolids
continue;
const TopoDS_Shape& aSD = theDraftSolids.Find(aS);
const BOPCol_ListOfShape* pLFIN = theInParts.Seek(aS);
const TopTools_ListOfShape* pLFIN = theInParts.Seek(aS);
if (!pLFIN || pLFIN->IsEmpty())
{
aSolidsIm(aSolidsIm.Add(aS, BOPCol_ListOfShape())).Append(aSD);
aSolidsIm(aSolidsIm.Add(aS, TopTools_ListOfShape())).Append(aSD);
continue;
}
@ -433,7 +429,7 @@ void BOPAlgo_Builder::BuildSplitSolids
}
//
// 1.3 Build new solids
BOPAlgo_BuilderSolid& aBS=aVBS.Append1();
BOPAlgo_BuilderSolid& aBS=aVBS.Appended();
aBS.SetSolid(aSolid);
aBS.SetShapes(aSFS);
aBS.SetRunParallel(myRunParallel);
@ -442,7 +438,7 @@ void BOPAlgo_Builder::BuildSplitSolids
//
Standard_Integer k, aNbBS;
//
aNbBS=aVBS.Extent();
aNbBS=aVBS.Length();
//
//===================================================
BOPAlgo_BuilderSolidCnt::Perform(myRunParallel, aVBS);
@ -459,10 +455,10 @@ void BOPAlgo_Builder::BuildSplitSolids
for (k = 1; k <= aNbBS; ++k)
{
const TopoDS_Shape& aS = aSolidsIm.FindKey(k);
const BOPCol_ListOfShape& aLSR = aSolidsIm(k);
const TopTools_ListOfShape& aLSR = aSolidsIm(k);
//
if (!myImages.IsBound(aS)) {
BOPCol_ListOfShape* pLSx = myImages.Bound(aS, BOPCol_ListOfShape());
TopTools_ListOfShape* pLSx = myImages.Bound(aS, TopTools_ListOfShape());
//
aIt.Initialize(aLSR);
for (; aIt.More(); aIt.Next()) {
@ -477,9 +473,9 @@ void BOPAlgo_Builder::BuildSplitSolids
const TopoDS_Shape& aSx=aSTx.Shape();
pLSx->Append(aSx);
//
BOPCol_ListOfShape* pLOr = myOrigins.ChangeSeek(aSx);
TopTools_ListOfShape* pLOr = myOrigins.ChangeSeek(aSx);
if (!pLOr) {
pLOr = myOrigins.Bound(aSx, BOPCol_ListOfShape());
pLOr = myOrigins.Bound(aSx, TopTools_ListOfShape());
}
pLOr->Append(aS);
//
@ -501,28 +497,28 @@ void BOPAlgo_Builder::FillInternalShapes()
TopAbs_State aState;
TopoDS_Iterator aItS;
BRep_Builder aBB;
BOPCol_ListIteratorOfListOfShape aIt, aIt1;
TopTools_ListIteratorOfListOfShape aIt, aIt1;
//
Handle(NCollection_BaseAllocator) aAllocator;
//-----------------------------------------------------scope f
aAllocator=NCollection_BaseAllocator::CommonBaseAllocator();
//
BOPCol_IndexedDataMapOfShapeListOfShape aMSx(100, aAllocator);
BOPCol_IndexedMapOfShape aMx(100, aAllocator);
BOPCol_IndexedMapOfShape aMSI(100, aAllocator);
BOPCol_MapOfShape aMFence(100, aAllocator);
BOPCol_MapOfShape aMSOr(100, aAllocator);
BOPCol_ListOfShape aLSd(aAllocator);
BOPCol_ListOfShape aLArgs(aAllocator);
BOPCol_ListOfShape aLSC(aAllocator);
BOPCol_ListOfShape aLSI(aAllocator);
TopTools_IndexedDataMapOfShapeListOfShape aMSx(100, aAllocator);
TopTools_IndexedMapOfShape aMx(100, aAllocator);
TopTools_IndexedMapOfShape aMSI(100, aAllocator);
TopTools_MapOfShape aMFence(100, aAllocator);
TopTools_MapOfShape aMSOr(100, aAllocator);
TopTools_ListOfShape aLSd(aAllocator);
TopTools_ListOfShape aLArgs(aAllocator);
TopTools_ListOfShape aLSC(aAllocator);
TopTools_ListOfShape aLSI(aAllocator);
//
// 1. Shapes to process
//
// 1.1 Shapes from pure arguments aMSI
// 1.1.1 vertex, edge, wire
//
const BOPCol_ListOfShape& aArguments=myDS->Arguments();
const TopTools_ListOfShape& aArguments=myDS->Arguments();
aIt.Initialize(aArguments);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS=aIt.Value();
@ -556,7 +552,7 @@ void BOPAlgo_Builder::FillInternalShapes()
aType==TopAbs_WIRE) {
if (aMFence.Add(aS)) {
if (myImages.IsBound(aS)) {
const BOPCol_ListOfShape &aLSp=myImages.Find(aS);
const TopTools_ListOfShape &aLSp=myImages.Find(aS);
aIt1.Initialize(aLSp);
for (; aIt1.More(); aIt1.Next()) {
const TopoDS_Shape& aSp=aIt1.Value();
@ -595,7 +591,7 @@ void BOPAlgo_Builder::FillInternalShapes()
for (j=1; j<=aNbSx; ++j) {
const TopoDS_Shape& aSi=aMx(j);
if (myImages.IsBound(aSi)) {
const BOPCol_ListOfShape &aLSp=myImages.Find(aSi);
const TopTools_ListOfShape &aLSp=myImages.Find(aSi);
aIt1.Initialize(aLSp);
for (; aIt1.More(); aIt1.Next()) {
const TopoDS_Shape& aSp=aIt1.Value();
@ -609,23 +605,23 @@ void BOPAlgo_Builder::FillInternalShapes()
//
// build aux map from splits of solids
if (myImages.IsBound(aS)) {
const BOPCol_ListOfShape &aLSp=myImages.Find(aS);
const TopTools_ListOfShape &aLSp=myImages.Find(aS);
aIt.Initialize(aLSp);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aSp=aIt.Value();
if (aMFence.Add(aSp)) {
BOPTools::MapShapesAndAncestors(aSp, TopAbs_VERTEX, TopAbs_EDGE, aMSx);
BOPTools::MapShapesAndAncestors(aSp, TopAbs_VERTEX, TopAbs_FACE, aMSx);
BOPTools::MapShapesAndAncestors(aSp, TopAbs_EDGE , TopAbs_FACE, aMSx);
TopExp::MapShapesAndAncestors(aSp, TopAbs_VERTEX, TopAbs_EDGE, aMSx);
TopExp::MapShapesAndAncestors(aSp, TopAbs_VERTEX, TopAbs_FACE, aMSx);
TopExp::MapShapesAndAncestors(aSp, TopAbs_EDGE , TopAbs_FACE, aMSx);
aLSd.Append(aSp);
}
}
}
else {
if (aMFence.Add(aS)) {
BOPTools::MapShapesAndAncestors(aS, TopAbs_VERTEX, TopAbs_EDGE, aMSx);
BOPTools::MapShapesAndAncestors(aS, TopAbs_VERTEX, TopAbs_FACE, aMSx);
BOPTools::MapShapesAndAncestors(aS, TopAbs_EDGE , TopAbs_FACE, aMSx);
TopExp::MapShapesAndAncestors(aS, TopAbs_VERTEX, TopAbs_EDGE, aMSx);
TopExp::MapShapesAndAncestors(aS, TopAbs_VERTEX, TopAbs_FACE, aMSx);
TopExp::MapShapesAndAncestors(aS, TopAbs_EDGE , TopAbs_FACE, aMSx);
aLSd.Append(aS);
aMSOr.Add(aS);
}
@ -638,7 +634,7 @@ void BOPAlgo_Builder::FillInternalShapes()
for (i = 1; i <= aNbSI; ++i) {
const TopoDS_Shape& aSI = aMSI(i);
if (aMSx.Contains(aSI)) {
const BOPCol_ListOfShape &aLSx=aMSx.FindFromKey(aSI);
const TopTools_ListOfShape &aLSx=aMSx.FindFromKey(aSI);
aNbSx = aLSx.Extent();
if (!aNbSx) {
aLSI.Append(aSI);
@ -688,10 +684,10 @@ void BOPAlgo_Builder::FillInternalShapes()
aBB.Add(aSdx, aSI);
//
// no need to check for images of aSd as aMSOr contains only original solids
BOPCol_ListOfShape* pLS = myImages.Bound(aSd, BOPCol_ListOfShape());
TopTools_ListOfShape* pLS = myImages.Bound(aSd, TopTools_ListOfShape());
pLS->Append(aSdx);
//
BOPCol_ListOfShape* pLOr = myOrigins.Bound(aSdx, BOPCol_ListOfShape());
TopTools_ListOfShape* pLOr = myOrigins.Bound(aSdx, TopTools_ListOfShape());
pLOr->Append(aSd);
//
aMSOr.Remove(aSd);
@ -719,7 +715,7 @@ void BOPAlgo_Builder::FillInternalShapes()
//purpose :
//=======================================================================
void OwnInternalShapes(const TopoDS_Shape& theS,
BOPCol_IndexedMapOfShape& theMx)
TopTools_IndexedMapOfShape& theMx)
{
TopoDS_Iterator aIt;
//

30
src/BOPAlgo/BOPAlgo_Builder_4.cxx
View File

@ -18,14 +18,14 @@
#include <BOPAlgo_Builder.hxx>
#include <BOPAlgo_PaveFiller.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <BOPDS_DS.hxx>
#include <BOPTools.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <IntTools_Context.hxx>
#include <TopExp.hxx>
#include <TopoDS_Iterator.hxx>
#include <TopoDS_Shape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
//=======================================================================
//function : Generated
@ -46,7 +46,7 @@ const TopTools_ListOfShape& BOPAlgo_Builder::Modified
{
Standard_Boolean bHasImage, bToReverse;
TopAbs_ShapeEnum aType;
BOPCol_ListIteratorOfListOfShape aIt;
TopTools_ListIteratorOfListOfShape aIt;
//
myHistShapes.Clear();
//
@ -68,7 +68,7 @@ const TopTools_ListOfShape& BOPAlgo_Builder::Modified
//
//PrepareHistory();
//
const BOPCol_ListOfShape& aLSp=myImages.Find(theS);
const TopTools_ListOfShape& aLSp=myImages.Find(theS);
aIt.Initialize(aLSp);
for (; aIt.More(); aIt.Next()) {
TopoDS_Shape aSp=aIt.Value();
@ -104,7 +104,7 @@ Standard_Boolean BOPAlgo_Builder::IsDeleted
{
Standard_Boolean bRet;
TopAbs_ShapeEnum aType;
BOPCol_ListIteratorOfListOfShape aIt;
TopTools_ListIteratorOfListOfShape aIt;
//
bRet = Standard_True;
//
@ -123,7 +123,7 @@ Standard_Boolean BOPAlgo_Builder::IsDeleted
return bRet;
}
//
const BOPCol_ListOfShape& aLSp = myImages.Find(theS);
const TopTools_ListOfShape& aLSp = myImages.Find(theS);
aIt.Initialize(aLSp);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aSp = aIt.Value();
@ -154,22 +154,22 @@ void BOPAlgo_Builder::PrepareHistory()
//
Standard_Boolean bHasImage;
TopAbs_ShapeEnum aType;
BOPCol_MapOfShape aMS;
BOPCol_ListIteratorOfListOfShape aIt;
BOPCol_MapIteratorOfMapOfShape aItM;
TopTools_MapOfShape aMS;
TopTools_ListIteratorOfListOfShape aIt;
TopTools_MapIteratorOfMapOfShape aItM;
//
// 1. Clearing
BOPAlgo_BuilderShape::PrepareHistory();
//
// 2. myMapShape - all shapes of result with theirs sub-shapes
BOPTools::MapShapes(myShape, myMapShape);
TopExp::MapShapes(myShape, myMapShape);
//
// 3. MS - all argument shapes with theirs sub-shapes
const BOPCol_ListOfShape& aArguments=myDS->Arguments();
const TopTools_ListOfShape& aArguments=myDS->Arguments();
aIt.Initialize(aArguments);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aSx=aIt.Value();
BOPTools::MapShapes(aSx, aMS);
TopExp::MapShapes(aSx, aMS);
}
//
// 4. Treatment
@ -185,7 +185,7 @@ void BOPAlgo_Builder::PrepareHistory()
// 4.1 .myImagesResult
bHasImage=myImages.IsBound(aSx);
//
BOPCol_ListOfShape aLSx;
TopTools_ListOfShape aLSx;
if (!bHasImage) {
if (myMapShape.Contains(aSx)) {
aLSx.Append(aSx);
@ -193,7 +193,7 @@ void BOPAlgo_Builder::PrepareHistory()
}
}
else {
const BOPCol_ListOfShape& aLSp=myImages.Find(aSx);
const TopTools_ListOfShape& aLSp=myImages.Find(aSx);
aIt.Initialize(aLSp);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aSp=aIt.Value();

156
src/BOPAlgo/BOPAlgo_CellsBuilder.cxx
View File

@ -22,13 +22,13 @@
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <BOPTools.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPAlgo_BuilderSolid.hxx>
#include <BOPAlgo_Alerts.hxx>
#include <BOPCol_MapOfInteger.hxx>
#include <TColStd_MapOfInteger.hxx>
#include <TopExp.hxx>
#include <ShapeUpgrade_UnifySameDomain.hxx>
@ -40,7 +40,7 @@ static
void MakeTypedContainers(const TopoDS_Shape& theSC,
TopoDS_Shape& theResult);
static void CollectMaterialBoundaries(const BOPCol_ListOfShape& theLS,
static void CollectMaterialBoundaries(const TopTools_ListOfShape& theLS,
TopTools_MapOfShape& theMapKeepBnd);
//=======================================================================
@ -146,10 +146,10 @@ void BOPAlgo_CellsBuilder::IndexParts()
TopoDS_Compound anAllParts;
aBB.MakeCompound(anAllParts);
//
BOPCol_MapOfShape aMFence;
BOPCol_MapOfInteger aMDims;
TopTools_MapOfShape aMFence;
TColStd_MapOfInteger aMDims;
//
BOPCol_ListIteratorOfListOfShape aIt(myArguments);
TopTools_ListIteratorOfListOfShape aIt(myArguments);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS = aIt.Value();
//
@ -160,11 +160,11 @@ void BOPAlgo_CellsBuilder::IndexParts()
TopExp_Explorer aExp(aS, aType);
for (; aExp.More(); aExp.Next()) {
const TopoDS_Shape& aST = aExp.Current();
const BOPCol_ListOfShape* pLSIm = myImages.Seek(aST);
const TopTools_ListOfShape* pLSIm = myImages.Seek(aST);
if (!pLSIm) {
BOPCol_ListOfShape* pLS = myIndex.ChangeSeek(aST);
TopTools_ListOfShape* pLS = myIndex.ChangeSeek(aST);
if (!pLS) {
pLS = &myIndex(myIndex.Add(aST, BOPCol_ListOfShape()));
pLS = &myIndex(myIndex.Add(aST, TopTools_ListOfShape()));
}
pLS->Append(aS);
//
@ -175,13 +175,13 @@ void BOPAlgo_CellsBuilder::IndexParts()
continue;
}
//
BOPCol_ListIteratorOfListOfShape aItIm(*pLSIm);
TopTools_ListIteratorOfListOfShape aItIm(*pLSIm);
for (; aItIm.More(); aItIm.Next()) {
const TopoDS_Shape& aSTIm = aItIm.Value();
//
BOPCol_ListOfShape* pLS = myIndex.ChangeSeek(aSTIm);
TopTools_ListOfShape* pLS = myIndex.ChangeSeek(aSTIm);
if (!pLS) {
pLS = &myIndex(myIndex.Add(aSTIm, BOPCol_ListOfShape()));
pLS = &myIndex(myIndex.Add(aSTIm, TopTools_ListOfShape()));
}
pLS->Append(aS);
//
@ -207,7 +207,7 @@ void BOPAlgo_CellsBuilder::IndexParts()
const TopTools_ListOfShape& aLSOr = myIndex(i);
//
Standard_Integer iType = BOPTools_AlgoTools::Dimension(aSP);
BOPCol_MapIteratorOfMapOfInteger aItM(aMDims);
TColStd_MapIteratorOfMapOfInteger aItM(aMDims);
for (; aItM.More(); aItM.Next()) {
Standard_Integer k = aItM.Value();
if (k >= iType) {
@ -217,17 +217,17 @@ void BOPAlgo_CellsBuilder::IndexParts()
TopExp_Explorer aExp(aSP, TypeToExplore(k));
for (; aExp.More(); aExp.Next()) {
const TopoDS_Shape& aSS = aExp.Current();
BOPCol_ListOfShape* pLSSOr = myIndex.ChangeSeek(aSS);
TopTools_ListOfShape* pLSSOr = myIndex.ChangeSeek(aSS);
if (!pLSSOr) {
myIndex.Add(aSS, aLSOr);
continue;
}
// add ancestors of the shape to the ancestors of the sub-shape
BOPCol_ListIteratorOfListOfShape aItLS(aLSOr);
TopTools_ListIteratorOfListOfShape aItLS(aLSOr);
for (; aItLS.More(); aItLS.Next()) {
const TopoDS_Shape& aSOr = aItLS.Value();
// provide uniqueness of the ancestors
BOPCol_ListIteratorOfListOfShape aItLSS(*pLSSOr);
TopTools_ListIteratorOfListOfShape aItLSS(*pLSSOr);
for (; aItLSS.More(); aItLSS.Next()) {
if (aSOr.IsSame(aItLSS.Value())) {
break;
@ -247,20 +247,20 @@ void BOPAlgo_CellsBuilder::IndexParts()
//function : AddToResult
//purpose :
//=======================================================================
void BOPAlgo_CellsBuilder::AddToResult(const BOPCol_ListOfShape& theLSToTake,
const BOPCol_ListOfShape& theLSToAvoid,
void BOPAlgo_CellsBuilder::AddToResult(const TopTools_ListOfShape& theLSToTake,
const TopTools_ListOfShape& theLSToAvoid,
const Standard_Integer theMaterial,
const Standard_Boolean theUpdate)
{
// find parts
BOPCol_ListOfShape aParts;
TopTools_ListOfShape aParts;
FindParts(theLSToTake, theLSToAvoid, aParts);
if (aParts.IsEmpty()) {
return;
}
//
// collect result parts to avoid multiple adding of the same parts
BOPCol_MapOfShape aResParts;
TopTools_MapOfShape aResParts;
TopoDS_Iterator aIt(myShape);
for (; aIt.More(); aIt.Next()) {
aResParts.Add(aIt.Value());
@ -268,7 +268,7 @@ void BOPAlgo_CellsBuilder::AddToResult(const BOPCol_ListOfShape& theLSToTake,
//
Standard_Boolean bChanged = Standard_False;
// add parts to result
BOPCol_ListIteratorOfListOfShape aItLP(aParts);
TopTools_ListIteratorOfListOfShape aItLP(aParts);
for (; aItLP.More(); aItLP.Next()) {
const TopoDS_Shape& aPart = aItLP.Value();
// provide uniqueness of the parts
@ -280,7 +280,7 @@ void BOPAlgo_CellsBuilder::AddToResult(const BOPCol_ListOfShape& theLSToTake,
//
// update the material
if (theMaterial != 0) {
BOPCol_ListOfShape aLSP;
TopTools_ListOfShape aLSP;
aItLP.Initialize(aParts);
for (; aItLP.More(); aItLP.Next()) {
const TopoDS_Shape& aPart = aItLP.Value();
@ -291,9 +291,9 @@ void BOPAlgo_CellsBuilder::AddToResult(const BOPCol_ListOfShape& theLSToTake,
} // for (; aIt.More(); aIt.Next()) {
//
if (aLSP.Extent()) {
BOPCol_ListOfShape* pLS = myMaterials.ChangeSeek(theMaterial);
TopTools_ListOfShape* pLS = myMaterials.ChangeSeek(theMaterial);
if (!pLS) {
pLS = myMaterials.Bound(theMaterial, BOPCol_ListOfShape());
pLS = myMaterials.Bound(theMaterial, TopTools_ListOfShape());
}
pLS->Append(aLSP);
} // if (aLSP.Extent()) {
@ -323,7 +323,7 @@ void BOPAlgo_CellsBuilder::AddAllToResult(const Standard_Integer theMaterial,
myShape = myAllParts;
//
if (theMaterial != 0) {
BOPCol_ListOfShape* pLSM = myMaterials.Bound(theMaterial, BOPCol_ListOfShape());
TopTools_ListOfShape* pLSM = myMaterials.Bound(theMaterial, TopTools_ListOfShape());
//
TopoDS_Iterator aIt(myAllParts);
for (; aIt.More(); aIt.Next()) {
@ -345,28 +345,28 @@ void BOPAlgo_CellsBuilder::AddAllToResult(const Standard_Integer theMaterial,
//function : RemoveFromResult
//purpose :
//=======================================================================
void BOPAlgo_CellsBuilder::RemoveFromResult(const BOPCol_ListOfShape& theLSToTake,
const BOPCol_ListOfShape& theLSToAvoid)
void BOPAlgo_CellsBuilder::RemoveFromResult(const TopTools_ListOfShape& theLSToTake,
const TopTools_ListOfShape& theLSToAvoid)
{
// find parts
BOPCol_ListOfShape aParts;
TopTools_ListOfShape aParts;
FindParts(theLSToTake, theLSToAvoid, aParts);
if (aParts.IsEmpty()) {
return;
}
//
// collect parts into the map and remove parts from materials
BOPCol_MapOfShape aPartsToRemove;
BOPCol_ListIteratorOfListOfShape aItP(aParts);
TopTools_MapOfShape aPartsToRemove;
TopTools_ListIteratorOfListOfShape aItP(aParts);
for (; aItP.More(); aItP.Next()) {
const TopoDS_Shape& aPart = aItP.Value();
aPartsToRemove.Add(aPart);
//
const Standard_Integer* pMaterial = myShapeMaterial.Seek(aPart);
if (pMaterial) {
BOPCol_ListOfShape* pLSM = myMaterials.ChangeSeek(*pMaterial);
TopTools_ListOfShape* pLSM = myMaterials.ChangeSeek(*pMaterial);
if (pLSM) {
BOPCol_ListIteratorOfListOfShape aItM(*pLSM);
TopTools_ListIteratorOfListOfShape aItM(*pLSM);
for (; aItM.More(); aItM.Next()) {
if (aPart.IsSame(aItM.Value())) {
pLSM->Remove(aItM);
@ -463,12 +463,12 @@ void BOPAlgo_CellsBuilder::RemoveInternalBoundaries()
Standard_Boolean bChanged = Standard_False;
// try to remove the internal boundaries between the
// shapes of the same material
BOPCol_DataMapIteratorOfDataMapOfIntegerListOfShape aItM(myMaterials);
BOPCol_ListOfShape aLSUnify[2];
TopTools_DataMapIteratorOfDataMapOfIntegerListOfShape aItM(myMaterials);
TopTools_ListOfShape aLSUnify[2];
TopTools_MapOfShape aKeepMap[2];
for (; aItM.More(); aItM.Next()) {
Standard_Integer iMaterial = aItM.Key();
BOPCol_ListOfShape& aLS = aItM.ChangeValue();
TopTools_ListOfShape& aLS = aItM.ChangeValue();
//
if (aLS.IsEmpty()) {
continue;
@ -485,7 +485,7 @@ void BOPAlgo_CellsBuilder::RemoveInternalBoundaries()
}
//
// check the shapes of the same material to be of the same type
BOPCol_ListIteratorOfListOfShape aItLS(aLS);
TopTools_ListIteratorOfListOfShape aItLS(aLS);
TopAbs_ShapeEnum aType = aItLS.Value().ShapeType();
for (aItLS.Next(); aItLS.More(); aItLS.Next()) {
if (aType != aItLS.Value().ShapeType()) {
@ -511,7 +511,7 @@ void BOPAlgo_CellsBuilder::RemoveInternalBoundaries()
Standard_Integer iType = (aType == TopAbs_EDGE ? 0 : 1);
CollectMaterialBoundaries(aLS, aKeepMap[iType]);
// save shapes to unify later
BOPCol_ListOfShape aCopy(aLS);
TopTools_ListOfShape aCopy(aLS);
aLSUnify[iType].Append(aCopy);
continue;
}
@ -519,7 +519,7 @@ void BOPAlgo_CellsBuilder::RemoveInternalBoundaries()
{
// aType is Solid;
// remove internal faces between solids of the same material just now
BOPCol_ListOfShape aLSNew;
TopTools_ListOfShape aLSNew;
if (RemoveInternals(aLS, aLSNew))
{
bChanged = Standard_True;
@ -544,11 +544,11 @@ void BOPAlgo_CellsBuilder::RemoveInternalBoundaries()
{
if (aLSUnify[iType].IsEmpty())
continue;
BOPCol_ListOfShape aLSN;
TopTools_ListOfShape aLSN;
if (RemoveInternals(aLSUnify[iType], aLSN, aKeepMap[iType]))
bChanged = Standard_True;
// add shapes to result ([unified] edges or faces)
for (BOPCol_ListIteratorOfListOfShape aItLS(aLSN); aItLS.More(); aItLS.Next()) {
for (TopTools_ListIteratorOfListOfShape aItLS(aLSN); aItLS.More(); aItLS.Next()) {
const TopoDS_Shape& aS = aItLS.Value();
aBB.Add(aResult, aS);
}
@ -611,24 +611,24 @@ void BOPAlgo_CellsBuilder::RemoveInternalBoundaries()
//function : FindPart
//purpose :
//=======================================================================
void BOPAlgo_CellsBuilder::FindParts(const BOPCol_ListOfShape& theLSToTake,
const BOPCol_ListOfShape& theLSToAvoid,
BOPCol_ListOfShape& theParts)
void BOPAlgo_CellsBuilder::FindParts(const TopTools_ListOfShape& theLSToTake,
const TopTools_ListOfShape& theLSToAvoid,
TopTools_ListOfShape& theParts)
{
if (theLSToTake.IsEmpty()) {
return;
}
//
// map shapes to avoid
BOPCol_MapOfShape aMSToAvoid;
BOPCol_ListIteratorOfListOfShape aItArgs(theLSToAvoid);
TopTools_MapOfShape aMSToAvoid;
TopTools_ListIteratorOfListOfShape aItArgs(theLSToAvoid);
for (; aItArgs.More(); aItArgs.Next()) {
const TopoDS_Shape& aS = aItArgs.Value();
aMSToAvoid.Add(aS);
}
//
// map shapes to be taken
BOPCol_MapOfShape aMSToTake;
TopTools_MapOfShape aMSToTake;
aItArgs.Initialize(theLSToTake);
for (; aItArgs.More(); aItArgs.Next()) {
const TopoDS_Shape& aS = aItArgs.Value();
@ -659,14 +659,14 @@ void BOPAlgo_CellsBuilder::FindParts(const BOPCol_ListOfShape& theLSToTake,
for (; aExp.More(); aExp.Next()) {
const TopoDS_Shape& aST = aExp.Current();
// get split parts of the shape
BOPCol_ListOfShape aLSTIm;
TopTools_ListOfShape aLSTIm;
if (!myImages.IsBound(aST)) {
aLSTIm.Append(aST);
} else {
aLSTIm = myImages.Find(aST);
}
//
BOPCol_ListIteratorOfListOfShape aItIm(aLSTIm);
TopTools_ListIteratorOfListOfShape aItIm(aLSTIm);
for (; aItIm.More(); aItIm.Next()) {
const TopoDS_Shape& aPart = aItIm.Value();
//
@ -675,13 +675,13 @@ void BOPAlgo_CellsBuilder::FindParts(const BOPCol_ListOfShape& theLSToTake,
}
//
// get input shapes in which the split part is contained
const BOPCol_ListOfShape& aLS = myIndex.FindFromKey(aPart);
const TopTools_ListOfShape& aLS = myIndex.FindFromKey(aPart);
if (aLS.Extent() < aNbS) {
continue;
}
//
// check that input shapes containing the part should not be avoided
BOPCol_MapOfShape aMS;
TopTools_MapOfShape aMS;
aItArgs.Initialize(aLS);
for (; aItArgs.More(); aItArgs.Next()) {
const TopoDS_Shape& aS = aItArgs.Value();
@ -721,7 +721,7 @@ void BOPAlgo_CellsBuilder::MakeContainers()
aBB.MakeCompound(aResult);
//
// basic elements of type EDGE, FACE and SOLID added into result
BOPCol_ListOfShape aLS[3];
TopTools_ListOfShape aLS[3];
//
TopoDS_Iterator aIt(myShape);
for (; aIt.More(); aIt.Next()) {
@ -743,7 +743,7 @@ void BOPAlgo_CellsBuilder::MakeContainers()
//
TopoDS_Compound aC;
aBB.MakeCompound(aC);
BOPCol_ListIteratorOfListOfShape aItLS(aLS[i]);
TopTools_ListIteratorOfListOfShape aItLS(aLS[i]);
for (; aItLS.More(); aItLS.Next()) {
aBB.Add(aC, aItLS.Value());
}
@ -757,8 +757,8 @@ void BOPAlgo_CellsBuilder::MakeContainers()
//function : RemoveInternals
//purpose :
//=======================================================================
Standard_Boolean BOPAlgo_CellsBuilder::RemoveInternals(const BOPCol_ListOfShape& theLS,
BOPCol_ListOfShape& theLSNew,
Standard_Boolean BOPAlgo_CellsBuilder::RemoveInternals(const TopTools_ListOfShape& theLS,
TopTools_ListOfShape& theLSNew,
const TopTools_MapOfShape& theMapKeepBnd)
{
Standard_Boolean bRemoved = Standard_False;
@ -779,7 +779,7 @@ Standard_Boolean BOPAlgo_CellsBuilder::RemoveInternals(const BOPCol_ListOfShape&
BOPTools_AlgoTools::MakeContainer
((aType == TopAbs_FACE) ? TopAbs_SHELL : TopAbs_WIRE, aShape);
//
for (BOPCol_ListIteratorOfListOfShape aIt(theLS); aIt.More(); aIt.Next()) {
for (TopTools_ListIteratorOfListOfShape aIt(theLS); aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS = aIt.Value();
aBB.Add(aShape, aS);
}
@ -812,12 +812,12 @@ Standard_Boolean BOPAlgo_CellsBuilder::RemoveInternals(const BOPCol_ListOfShape&
}
//
// fill map of modified shapes
BOPCol_IndexedMapOfShape aMG;
TopTools_IndexedMapOfShape aMG;
Standard_Integer i, aNb;
//
BOPTools::MapShapes(aShape, TopAbs_VERTEX, aMG);
BOPTools::MapShapes(aShape, TopAbs_EDGE, aMG);
BOPTools::MapShapes(aShape, TopAbs_FACE, aMG);
TopExp::MapShapes(aShape, TopAbs_VERTEX, aMG);
TopExp::MapShapes(aShape, TopAbs_EDGE, aMG);
TopExp::MapShapes(aShape, TopAbs_FACE, aMG);
//
aNb = aMG.Extent();
for (i = 1; i <= aNb; ++i) {
@ -839,7 +839,7 @@ Standard_Boolean BOPAlgo_CellsBuilder::RemoveInternals(const BOPCol_ListOfShape&
TopoDS_Compound aSolids;
aBB.MakeCompound(aSolids);
//
BOPCol_ListIteratorOfListOfShape aItLS(theLS);
TopTools_ListIteratorOfListOfShape aItLS(theLS);
for (; aItLS.More(); aItLS.Next()) {
const TopoDS_Shape& aSol = aItLS.Value();
aBB.Add(aSolids, aSol);
@ -847,18 +847,18 @@ Standard_Boolean BOPAlgo_CellsBuilder::RemoveInternals(const BOPCol_ListOfShape&
//
// Make connexity blocks of solids to create from each isolated block one solid.
// It will allow attaching internal entities of the solids to new solid.
BOPCol_ListOfShape aLCB;
TopTools_ListOfShape aLCB;
BOPTools_AlgoTools::MakeConnexityBlocks(aSolids, TopAbs_FACE, TopAbs_SOLID, aLCB);
//
// for each block remove internal faces
BOPCol_ListIteratorOfListOfShape aItLCB(aLCB);
TopTools_ListIteratorOfListOfShape aItLCB(aLCB);
for (; aItLCB.More(); aItLCB.Next()) {
const TopoDS_Shape& aCB = aItLCB.Value();
//
// Map faces and solids to find boundary faces that can be removed
BOPCol_IndexedDataMapOfShapeListOfShape aDMFS;
TopTools_IndexedDataMapOfShapeListOfShape aDMFS;
// internal entities
BOPCol_ListOfShape aLSInt;
TopTools_ListOfShape aLSInt;
//
TopoDS_Iterator aItS(aCB);
for (; aItS.More(); aItS.Next()) {
@ -874,9 +874,9 @@ Standard_Boolean BOPAlgo_CellsBuilder::RemoveInternals(const BOPCol_ListOfShape&
TopoDS_Iterator aItF(aSI);
for (; aItF.More(); aItF.Next()) {
const TopoDS_Shape& aF = aItF.Value();
BOPCol_ListOfShape *pLSols = aDMFS.ChangeSeek(aF);
TopTools_ListOfShape *pLSols = aDMFS.ChangeSeek(aF);
if (!pLSols) {
pLSols = &aDMFS(aDMFS.Add(aF, BOPCol_ListOfShape()));
pLSols = &aDMFS(aDMFS.Add(aF, TopTools_ListOfShape()));
}
pLSols->Append(aSol);
}
@ -885,7 +885,7 @@ Standard_Boolean BOPAlgo_CellsBuilder::RemoveInternals(const BOPCol_ListOfShape&
}
//
// to build unified solid, select only faces attached to only one solid
BOPCol_ListOfShape aLFUnique;
TopTools_ListOfShape aLFUnique;
Standard_Integer i, aNb = aDMFS.Extent();
for (i = 1; i <= aNb; ++i) {
if (aDMFS(i).Extent() == 1) {
@ -912,7 +912,7 @@ Standard_Boolean BOPAlgo_CellsBuilder::RemoveInternals(const BOPCol_ListOfShape&
{
TopoDS_Compound aUniqeFaces;
aBB.MakeCompound(aUniqeFaces);
BOPCol_ListIteratorOfListOfShape aItLFUniqe(aLFUnique);
TopTools_ListIteratorOfListOfShape aItLFUniqe(aLFUnique);
for (; aItLFUniqe.More(); aItLFUniqe.Next()) {
aBB.Add(aUniqeFaces, aItLFUniqe.Value());
}
@ -931,7 +931,7 @@ Standard_Boolean BOPAlgo_CellsBuilder::RemoveInternals(const BOPCol_ListOfShape&
//
// put all internal parts into new solid
aSNew.Free(Standard_True);
BOPCol_ListIteratorOfListOfShape aItLSI(aLSInt);
TopTools_ListIteratorOfListOfShape aItLSI(aLSInt);
for (; aItLSI.More(); aItLSI.Next()) {
aBB.Add(aSNew, aItLSI.Value());
}
@ -979,8 +979,8 @@ Standard_Boolean BOPAlgo_CellsBuilder::IsDeleted(const TopoDS_Shape& theS)
}
//
if (bHasImage) {
const BOPCol_ListOfShape& aLSp = myImages.Find(theS);
BOPCol_ListIteratorOfListOfShape aIt(aLSp);
const TopTools_ListOfShape& aLSp = myImages.Find(theS);
TopTools_ListIteratorOfListOfShape aIt(aLSp);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aSp = aIt.Value();
const TopoDS_Shape& aSpR = myShapesSD.IsBound(aSp) ?
@ -1028,9 +1028,9 @@ const TopTools_ListOfShape& BOPAlgo_CellsBuilder::Modified(const TopoDS_Shape& t
return myHistShapes;
}
//
BOPCol_MapOfShape aMFence;
const BOPCol_ListOfShape& aLSp = myImages.Find(theS);
BOPCol_ListIteratorOfListOfShape aIt(aLSp);
TopTools_MapOfShape aMFence;
const TopTools_ListOfShape& aLSp = myImages.Find(theS);
TopTools_ListIteratorOfListOfShape aIt(aLSp);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape aSp = aIt.Value();
const TopoDS_Shape& aSpR = myShapesSD.IsBound(aSp) ?
@ -1083,7 +1083,7 @@ void MakeTypedContainers(const TopoDS_Shape& theSC,
return;
}
//
BOPCol_ListOfShape aLCB;
TopTools_ListOfShape aLCB;
BOPTools_AlgoTools::MakeConnexityBlocks(theSC, aConnexityType, aPartType, aLCB);
if (aLCB.IsEmpty()) {
return;
@ -1091,7 +1091,7 @@ void MakeTypedContainers(const TopoDS_Shape& theSC,
//
BRep_Builder aBB;
TopExp_Explorer aExp;
BOPCol_ListIteratorOfListOfShape aItCB;
TopTools_ListIteratorOfListOfShape aItCB;
//
aItCB.Initialize(aLCB);
for (; aItCB.More(); aItCB.Next()) {
@ -1117,13 +1117,13 @@ void MakeTypedContainers(const TopoDS_Shape& theSC,
//function : CollectMaterialBoundaries
//purpose : Add to theMapKeepBnd the boundary shapes of the area defined by shapes from the list
//=======================================================================
static void CollectMaterialBoundaries(const BOPCol_ListOfShape& theLS,
static void CollectMaterialBoundaries(const TopTools_ListOfShape& theLS,
TopTools_MapOfShape& theMapKeepBnd)
{
TopAbs_ShapeEnum aType = theLS.First().ShapeType();
TopAbs_ShapeEnum aTypeSubsh = (aType == TopAbs_FACE ? TopAbs_EDGE : TopAbs_VERTEX);
TopTools_IndexedDataMapOfShapeListOfShape aMapSubSh;
BOPCol_ListIteratorOfListOfShape anIt(theLS);
TopTools_ListIteratorOfListOfShape anIt(theLS);
for (; anIt.More(); anIt.Next())
{
const TopoDS_Shape& aS = anIt.Value();

42
src/BOPAlgo/BOPAlgo_CellsBuilder.hxx
View File

@ -26,11 +26,11 @@
#include <TopTools_MapOfShape.hxx>
#include <BOPAlgo_Builder.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_IndexedDataMapOfShapeListOfShape.hxx>
#include <BOPCol_DataMapOfIntegerListOfShape.hxx>
#include <BOPCol_DataMapOfShapeInteger.hxx>
#include <BOPCol_DataMapOfShapeShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_DataMapOfIntegerListOfShape.hxx>
#include <TopTools_DataMapOfShapeInteger.hxx>
#include <TopTools_DataMapOfShapeShape.hxx>
//!
//! The algorithm is based on the General Fuse algorithm (GFA). The result of
@ -112,7 +112,7 @@
//! Examples:<br>
//! 1. API<br>
//! BOPAlgo_CellsBuilder aCBuilder;<br>
//! BOPCol_ListOfShape aLS = ...; // arguments<br>
//! TopTools_ListOfShape aLS = ...; // arguments<br>
//! /* parallel or single mode (the default value is FALSE)*/<br>
//! Standard_Boolean bRunParallel = Standard_False;<br>
//! /* fuzzy option (default value is 0)*/<br>
@ -131,8 +131,8 @@
//! /* all split parts */<br>
//! const TopoDS_Shape& aRes = aCBuilder.GetAllParts();<br>
//! //<br>
//! BOPCol_ListOfShape aLSToTake = ...; // parts of these arguments will be taken into result<br>
//! BOPCol_ListOfShape aLSToAvoid = ...; // parts of these arguments will not be taken into result<br>
//! TopTools_ListOfShape aLSToTake = ...; // parts of these arguments will be taken into result<br>
//! TopTools_ListOfShape aLSToAvoid = ...; // parts of these arguments will not be taken into result<br>
//! //<br>
//! /* defines the material common for the cells, i.e.
//! the boundaries between cells with the same material
@ -202,8 +202,8 @@ class BOPAlgo_CellsBuilder : public BOPAlgo_Builder
//! cells with the same material will be removed. Default value is 0.<br>
//! Thus, to remove any boundary the value of this variable should not be equal to 0.<br>
//! <theUpdate> parameter defines whether to remove boundaries now or not.
Standard_EXPORT void AddToResult(const BOPCol_ListOfShape& theLSToTake,
const BOPCol_ListOfShape& theLSToAvoid,
Standard_EXPORT void AddToResult(const TopTools_ListOfShape& theLSToTake,
const TopTools_ListOfShape& theLSToAvoid,
const Standard_Integer theMaterial = 0,
const Standard_Boolean theUpdate = Standard_False);
@ -219,8 +219,8 @@ class BOPAlgo_CellsBuilder : public BOPAlgo_Builder
//! <theLSToAvoid> defines the arguments which parts should not be removed from result.<br>
//! To be removed from the result the part must be IN for all shapes from the list
//! <theLSToTake> and must be OUT of all shapes from the list <theLSToAvoid>.
Standard_EXPORT void RemoveFromResult(const BOPCol_ListOfShape& theLSToTake,
const BOPCol_ListOfShape& theLSToAvoid);
Standard_EXPORT void RemoveFromResult(const TopTools_ListOfShape& theLSToTake,
const TopTools_ListOfShape& theLSToAvoid);
//! Remove all parts from result.
Standard_EXPORT void RemoveAllFromResult();
@ -258,22 +258,22 @@ class BOPAlgo_CellsBuilder : public BOPAlgo_Builder
Standard_EXPORT void IndexParts();
//! Looking for the parts defined by two lists.
Standard_EXPORT void FindParts(const BOPCol_ListOfShape& theLSToTake,
const BOPCol_ListOfShape& theLSToAvoid,
BOPCol_ListOfShape& theParts);
Standard_EXPORT void FindParts(const TopTools_ListOfShape& theLSToTake,
const TopTools_ListOfShape& theLSToAvoid,
TopTools_ListOfShape& theParts);
//! Removes internal boundaries between cells with the same material.<br>
//! Returns TRUE if any internal boundaries have been removed.
Standard_EXPORT Standard_Boolean RemoveInternals(const BOPCol_ListOfShape& theLS,
BOPCol_ListOfShape& theLSNew,
Standard_EXPORT Standard_Boolean RemoveInternals(const TopTools_ListOfShape& theLS,
TopTools_ListOfShape& theLSNew,
const TopTools_MapOfShape& theMapKeepBnd = TopTools_MapOfShape());
// fields
TopoDS_Shape myAllParts;
BOPCol_IndexedDataMapOfShapeListOfShape myIndex;
BOPCol_DataMapOfIntegerListOfShape myMaterials;
BOPCol_DataMapOfShapeInteger myShapeMaterial;
BOPCol_DataMapOfShapeShape myMapModified;
TopTools_IndexedDataMapOfShapeListOfShape myIndex;
TopTools_DataMapOfIntegerListOfShape myMaterials;
TopTools_DataMapOfShapeInteger myShapeMaterial;
TopTools_DataMapOfShapeShape myMapModified;
};
#endif //_BOPAlgo_CellsBuilder_HeaderFile

4
src/BOPAlgo/BOPAlgo_CheckResult.cxx
View File

@ -61,12 +61,12 @@ const TopoDS_Shape & BOPAlgo_CheckResult::GetShape2() const
return myShape2;
}
const BOPCol_ListOfShape& BOPAlgo_CheckResult::GetFaultyShapes1() const
const TopTools_ListOfShape& BOPAlgo_CheckResult::GetFaultyShapes1() const
{
return myFaulty1;
}
const BOPCol_ListOfShape& BOPAlgo_CheckResult::GetFaultyShapes2() const
const TopTools_ListOfShape& BOPAlgo_CheckResult::GetFaultyShapes2() const
{
return myFaulty2;
}

10
src/BOPAlgo/BOPAlgo_CheckResult.hxx
View File

@ -22,7 +22,7 @@
#include <TopoDS_Shape.hxx>
#include <BOPAlgo_CheckStatus.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <Standard_Real.hxx>
class TopoDS_Shape;
@ -58,10 +58,10 @@ public:
Standard_EXPORT const TopoDS_Shape& GetShape2() const;
//! returns list of faulty shapes for object
Standard_EXPORT const BOPCol_ListOfShape& GetFaultyShapes1() const;
Standard_EXPORT const TopTools_ListOfShape& GetFaultyShapes1() const;
//! returns list of faulty shapes for tool
Standard_EXPORT const BOPCol_ListOfShape& GetFaultyShapes2() const;
Standard_EXPORT const TopTools_ListOfShape& GetFaultyShapes2() const;
//! set status of faulty
Standard_EXPORT void SetCheckStatus (const BOPAlgo_CheckStatus TheStatus);
@ -109,8 +109,8 @@ private:
TopoDS_Shape myShape1;
TopoDS_Shape myShape2;
BOPAlgo_CheckStatus myStatus;
BOPCol_ListOfShape myFaulty1;
BOPCol_ListOfShape myFaulty2;
TopTools_ListOfShape myFaulty1;
TopTools_ListOfShape myFaulty2;
Standard_Real myMaxDist1;
Standard_Real myMaxDist2;
Standard_Real myMaxPar1;

44
src/BOPAlgo/BOPAlgo_CheckerSI.cxx
View File

@ -19,8 +19,6 @@
#include <BOPAlgo_CheckerSI.hxx>
#include <BOPAlgo_Alerts.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <BOPCol_Parallel.hxx>
#include <BOPDS_DS.hxx>
#include <BOPDS_Interf.hxx>
#include <BOPDS_IteratorSI.hxx>
@ -32,8 +30,11 @@
#include <BOPDS_VectorOfInterfVE.hxx>
#include <BOPDS_VectorOfInterfVF.hxx>
#include <BOPDS_VectorOfInterfVV.hxx>
#include <BOPTools.hxx>
#include <BRep_Tool.hxx>
#include <gp_Torus.hxx>
#include <TopExp.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_Parallel.hxx>
#include <BRepBuilderAPI_Copy.hxx>
#include <IntTools_Context.hxx>
#include <IntTools_Tools.hxx>
@ -41,8 +42,7 @@
#include <Standard_ErrorHandler.hxx>
#include <Standard_Failure.hxx>
#include <TopTools_ListOfShape.hxx>
#include <BRep_Tool.hxx>
#include <gp_Torus.hxx>
#include <TopTools_MapOfShape.hxx>
//=======================================================================
//class : BOPAlgo_FaceSelfIntersect
@ -102,14 +102,14 @@ class BOPAlgo_FaceSelfIntersect :
//=======================================================================
typedef BOPCol_NCVector
typedef NCollection_Vector
<BOPAlgo_FaceSelfIntersect> BOPAlgo_VectorOfFaceSelfIntersect;
//
typedef BOPCol_Functor
typedef BOPTools_Functor
<BOPAlgo_FaceSelfIntersect,
BOPAlgo_VectorOfFaceSelfIntersect> BOPAlgo_FaceSelfIntersectFunctor;
//
typedef BOPCol_Cnt
typedef BOPTools_Cnt
<BOPAlgo_FaceSelfIntersectFunctor,
BOPAlgo_VectorOfFaceSelfIntersect> BOPAlgo_FaceSelfIntersectCnt;
@ -224,7 +224,7 @@ void BOPAlgo_CheckerSI::PostTreat()
// 0
BOPDS_VectorOfInterfVV& aVVs=myDS->InterfVV();
aNb=aVVs.Extent();
aNb=aVVs.Length();
for (i=0; i!=aNb; ++i) {
const BOPDS_InterfVV& aVV=aVVs(i);
aVV.Indices(n1, n2);
@ -237,7 +237,7 @@ void BOPAlgo_CheckerSI::PostTreat()
//
// 1
BOPDS_VectorOfInterfVE& aVEs=myDS->InterfVE();
aNb=aVEs.Extent();
aNb=aVEs.Length();
for (i=0; i!=aNb; ++i) {
const BOPDS_InterfVE& aVE=aVEs(i);
aVE.Indices(n1, n2);
@ -250,7 +250,7 @@ void BOPAlgo_CheckerSI::PostTreat()
//
// 2
BOPDS_VectorOfInterfEE& aEEs=myDS->InterfEE();
aNb=aEEs.Extent();
aNb=aEEs.Length();
for (i=0; i!=aNb; ++i) {
const BOPDS_InterfEE& aEE=aEEs(i);
aEE.Indices(n1, n2);
@ -263,7 +263,7 @@ void BOPAlgo_CheckerSI::PostTreat()
//
// 3
BOPDS_VectorOfInterfVF& aVFs=myDS->InterfVF();
aNb=aVFs.Extent();
aNb=aVFs.Length();
for (i=0; i!=aNb; ++i) {
const BOPDS_InterfVF& aVF=aVFs(i);
aVF.Indices(n1, n2);
@ -276,7 +276,7 @@ void BOPAlgo_CheckerSI::PostTreat()
//
// 4
BOPDS_VectorOfInterfEF& aEFs=myDS->InterfEF();
aNb=aEFs.Extent();
aNb=aEFs.Length();
for (i=0; i!=aNb; ++i) {
const BOPDS_InterfEF& aEF=aEFs(i);
if (aEF.CommonPart().Type()==TopAbs_SHAPE) {
@ -292,7 +292,7 @@ void BOPAlgo_CheckerSI::PostTreat()
//
// 5
BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
aNb=aFFs.Extent();
aNb=aFFs.Length();
for (i=0; i!=aNb; ++i) {
Standard_Boolean bTangentFaces, bFlag;
Standard_Integer aNbC, aNbP, j, iFound;
@ -301,9 +301,9 @@ void BOPAlgo_CheckerSI::PostTreat()
aFF.Indices(n1, n2);
//
bTangentFaces=aFF.TangentFaces();
aNbP=aFF.Points().Extent();
aNbP=aFF.Points().Length();
const BOPDS_VectorOfCurve& aVC=aFF.Curves();
aNbC=aVC.Extent();
aNbC=aVC.Length();
if (!aNbP && !aNbC && !bTangentFaces) {
continue;
}
@ -344,7 +344,7 @@ void BOPAlgo_CheckerSI::PostTreat()
//
// 6
BOPDS_VectorOfInterfVZ& aVZs=myDS->InterfVZ();
aNb=aVZs.Extent();
aNb=aVZs.Length();
for (i=0; i!=aNb; ++i) {
//
const BOPDS_InterfVZ& aVZ=aVZs(i);
@ -358,7 +358,7 @@ void BOPAlgo_CheckerSI::PostTreat()
//
// 7
BOPDS_VectorOfInterfEZ& aEZs=myDS->InterfEZ();
aNb=aEZs.Extent();
aNb=aEZs.Length();
for (i=0; i!=aNb; ++i) {
//
const BOPDS_InterfEZ& aEZ=aEZs(i);
@ -369,7 +369,7 @@ void BOPAlgo_CheckerSI::PostTreat()
//
// 8
BOPDS_VectorOfInterfFZ& aFZs=myDS->InterfFZ();
aNb=aFZs.Extent();
aNb=aFZs.Length();
for (i=0; i!=aNb; ++i) {
//
const BOPDS_InterfFZ& aFZ=aFZs(i);
@ -380,7 +380,7 @@ void BOPAlgo_CheckerSI::PostTreat()
//
// 9
BOPDS_VectorOfInterfZZ& aZZs=myDS->InterfZZ();
aNb=aZZs.Extent();
aNb=aZZs.Length();
for (i=0; i!=aNb; ++i) {
//
const BOPDS_InterfZZ& aZZ=aZZs(i);
@ -436,7 +436,7 @@ void BOPAlgo_CheckerSI::CheckFaceSelfIntersection()
Standard_Real aTolF = BRep_Tool::Tolerance(aF);
BOPAlgo_FaceSelfIntersect& aFaceSelfIntersect = aVFace.Append1();
BOPAlgo_FaceSelfIntersect& aFaceSelfIntersect = aVFace.Appended();
//
aFaceSelfIntersect.SetIndex(i);
aFaceSelfIntersect.SetFace(aF);
@ -445,7 +445,7 @@ void BOPAlgo_CheckerSI::CheckFaceSelfIntersection()
aFaceSelfIntersect.SetProgressIndicator(myProgressIndicator);
}
Standard_Integer aNbFace = aVFace.Extent();
Standard_Integer aNbFace = aVFace.Length();
//======================================================
BOPAlgo_FaceSelfIntersectCnt::Perform(myRunParallel, aVFace);
//======================================================

45
src/BOPAlgo/BOPAlgo_CheckerSI_1.cxx
View File

@ -21,8 +21,7 @@
#include <BOPDS_Interf.hxx>
#include <BOPDS_IteratorSI.hxx>
#include <BOPCol_NCVector.hxx>
#include <BOPCol_Parallel.hxx>
#include <BOPTools_Parallel.hxx>
#include <BRep_Tool.hxx>
#include <BRepClass3d_SolidClassifier.hxx>
@ -30,8 +29,10 @@
#include <IntTools_Context.hxx>
#include <gp_Pnt.hxx>
#include <TopoDS_Vertex.hxx>
#include <NCollection_Vector.hxx>
#include <TopAbs_State.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Solid.hxx>
@ -114,16 +115,16 @@ class BOPAlgo_VertexSolid {
Handle(IntTools_Context) myContext;
};
//=======================================================================
typedef BOPCol_NCVector
typedef NCollection_Vector
<BOPAlgo_VertexSolid> BOPAlgo_VectorOfVertexSolid;
//
typedef BOPCol_ContextFunctor
typedef BOPTools_ContextFunctor
<BOPAlgo_VertexSolid,
BOPAlgo_VectorOfVertexSolid,
Handle(IntTools_Context),
IntTools_Context> BOPAlgo_VertexSolidFunctor;
//
typedef BOPCol_ContextCnt
typedef BOPTools_ContextCnt
<BOPAlgo_VertexSolidFunctor,
BOPAlgo_VectorOfVertexSolid,
Handle(IntTools_Context)> BOPAlgo_VertexSolidCnt;
@ -184,14 +185,14 @@ class BOPAlgo_ShapeSolid {
BOPDS_DS* myDS;
};
//=======================================================================
typedef BOPCol_NCVector
typedef NCollection_Vector
<BOPAlgo_ShapeSolid> BOPAlgo_VectorOfShapeSolid;
//
typedef BOPCol_Functor
typedef BOPTools_Functor
<BOPAlgo_ShapeSolid,
BOPAlgo_VectorOfShapeSolid> BOPAlgo_ShapeSolidFunctor;
//
typedef BOPCol_Cnt
typedef BOPTools_Cnt
<BOPAlgo_ShapeSolidFunctor,
BOPAlgo_VectorOfShapeSolid> BOPAlgo_ShapeSolidCnt;
//
@ -224,14 +225,14 @@ class BOPAlgo_SolidSolid : public BOPAlgo_ShapeSolid {
};
};
//=======================================================================
typedef BOPCol_NCVector
typedef NCollection_Vector
<BOPAlgo_SolidSolid> BOPAlgo_VectorOfSolidSolid;
//
typedef BOPCol_Functor
typedef BOPTools_Functor
<BOPAlgo_SolidSolid,
BOPAlgo_VectorOfSolidSolid> BOPAlgo_SolidSolidFunctor;
//
typedef BOPCol_Cnt
typedef BOPTools_Cnt
<BOPAlgo_SolidSolidFunctor,
BOPAlgo_VectorOfSolidSolid> BOPAlgo_SolidSolidCnt;
//
@ -277,13 +278,13 @@ void BOPAlgo_CheckerSI::PerformVZ()
const TopoDS_Vertex& aV=*((TopoDS_Vertex*)&myDS->Shape(nVSD));
const TopoDS_Solid& aZ=*((TopoDS_Solid*)&myDS->Shape(nZ));
//
BOPAlgo_VertexSolid& aVertexSolid=aVVS.Append1();
BOPAlgo_VertexSolid& aVertexSolid=aVVS.Appended();
aVertexSolid.SetIndices(nV, nZ);
aVertexSolid.SetVertex(aV);
aVertexSolid.SetSolid(aZ);
}
//
aNbVVS=aVVS.Extent();
aNbVVS=aVVS.Length();
//=============================================================
BOPAlgo_VertexSolidCnt::Perform(myRunParallel, aVVS, myContext);
//=============================================================
@ -293,7 +294,7 @@ void BOPAlgo_CheckerSI::PerformVZ()
if (aState==TopAbs_IN) {
aVertexSolid.Indices(nV, nZ);
//
BOPDS_InterfVZ& aVZ=aVZs.Append1();
BOPDS_InterfVZ& aVZ=aVZs.Appended();
aVZ.SetIndices(nV, nZ);
//
myDS->AddInterf(nV, nZ);
@ -336,12 +337,12 @@ void BOPAlgo_CheckerSI::PerformZZ()
for (; myIterator->More(); myIterator->Next()) {
myIterator->Value(nZ1, nZ);
//
BOPAlgo_SolidSolid& aSolidSolid=aVSolidSolid.Append1();
BOPAlgo_SolidSolid& aSolidSolid=aVSolidSolid.Appended();
aSolidSolid.SetIndices(nZ1, nZ);
aSolidSolid.SetDS(myDS);
}
//
aNbSolidSolid=aVSolidSolid.Extent();
aNbSolidSolid=aVSolidSolid.Length();
//======================================================
BOPAlgo_SolidSolidCnt::Perform(myRunParallel, aVSolidSolid);
//======================================================
@ -356,7 +357,7 @@ void BOPAlgo_CheckerSI::PerformZZ()
if (bHasInterf) {
aSolidSolid.Indices(nZ1, nZ);
//
BOPDS_InterfZZ& aZZ=aZZs.Append1();
BOPDS_InterfZZ& aZZ=aZZs.Appended();
aZZ.SetIndices(nZ1, nZ);
//
myDS->AddInterf(nZ1, nZ);
@ -383,12 +384,12 @@ void BOPAlgo_CheckerSI::PerformSZ(const TopAbs_ShapeEnum aTS)
for (; myIterator->More(); myIterator->Next()) {
myIterator->Value(nS, nZ);
//
BOPAlgo_ShapeSolid& aShapeSolid=aVShapeSolid.Append1();
BOPAlgo_ShapeSolid& aShapeSolid=aVShapeSolid.Appended();
aShapeSolid.SetIndices(nS, nZ);
aShapeSolid.SetDS(myDS);
}
//
aNbShapeSolid=aVShapeSolid.Extent();
aNbShapeSolid=aVShapeSolid.Length();
//======================================================
BOPAlgo_ShapeSolidCnt::Perform(myRunParallel, aVShapeSolid);
//======================================================
@ -410,11 +411,11 @@ void BOPAlgo_CheckerSI::PerformSZ(const TopAbs_ShapeEnum aTS)
aShapeSolid.Indices(nS, nZ);
//
if (aTS==TopAbs_EDGE) {
BOPDS_InterfEZ& aEZ=aEZs.Append1();
BOPDS_InterfEZ& aEZ=aEZs.Appended();
aEZ.SetIndices(nS, nZ);
}
else {//if (aTS==TopAbs_FACE)
BOPDS_InterfFZ& aFZ=aFZs.Append1();
BOPDS_InterfFZ& aFZ=aFZs.Appended();
aFZ.SetIndices(nS, nZ);
}
//

55
src/BOPAlgo/BOPAlgo_MakerVolume.cxx
View File

@ -18,18 +18,17 @@
#include <BOPAlgo_PaveFiller.hxx>
#include <BOPAlgo_Tools.hxx>
#include <BOPAlgo_Alerts.hxx>
#include <BOPCol_DataMapOfShapeListOfShape.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPDS_DS.hxx>
#include <BOPTools.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BRepPrimAPI_MakeBox.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS_Solid.hxx>
#include <TopTools_ListOfShape.hxx>
static
void AddFace(const TopoDS_Shape& theF,
BOPCol_ListOfShape& theLF);
TopTools_ListOfShape& theLF);
//=======================================================================
//function : CheckData
@ -69,8 +68,8 @@ void BOPAlgo_MakerVolume::Perform()
//to create the compound of them and use it as one argument
TopoDS_Compound anArgs;
BRep_Builder aBB;
BOPCol_ListIteratorOfListOfShape aIt;
BOPCol_ListOfShape aLS;
TopTools_ListIteratorOfListOfShape aIt;
TopTools_ListOfShape aLS;
//
aBB.MakeCompound(anArgs);
aIt.Initialize(myArguments);
@ -150,8 +149,8 @@ void BOPAlgo_MakerVolume::PerformInternal1
return;
}
//
BOPCol_MapOfShape aBoxFaces;
BOPCol_ListOfShape aLSR;
TopTools_MapOfShape aBoxFaces;
TopTools_ListOfShape aLSR;
//
// 5. Create bounding box
MakeBox(aBoxFaces);
@ -187,8 +186,8 @@ void BOPAlgo_MakerVolume::CollectFaces()
UserBreak();
//
Standard_Integer i, aNbShapes;
BOPCol_ListIteratorOfListOfShape aIt;
BOPCol_MapOfShape aMFence;
TopTools_ListIteratorOfListOfShape aIt;
TopTools_MapOfShape aMFence;
//
aNbShapes = myDS->NbSourceShapes();
for (i = 0; i < aNbShapes; ++i) {
@ -202,7 +201,7 @@ void BOPAlgo_MakerVolume::CollectFaces()
//
const TopoDS_Shape& aF = aSI.Shape();
if (myImages.IsBound(aF)) {
const BOPCol_ListOfShape& aLFIm = myImages.Find(aF);
const TopTools_ListOfShape& aLFIm = myImages.Find(aF);
aIt.Initialize(aLFIm);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aFIm = aIt.Value();
@ -221,7 +220,7 @@ void BOPAlgo_MakerVolume::CollectFaces()
//function : MakeBox
//purpose :
//=======================================================================
void BOPAlgo_MakerVolume::MakeBox(BOPCol_MapOfShape& theBoxFaces)
void BOPAlgo_MakerVolume::MakeBox(TopTools_MapOfShape& theBoxFaces)
{
UserBreak();
//
@ -248,7 +247,7 @@ void BOPAlgo_MakerVolume::MakeBox(BOPCol_MapOfShape& theBoxFaces)
//function : BuildSolids
//purpose :
//=======================================================================
void BOPAlgo_MakerVolume::BuildSolids(BOPCol_ListOfShape& theLSR)
void BOPAlgo_MakerVolume::BuildSolids(TopTools_ListOfShape& theLSR)
{
UserBreak();
//
@ -272,12 +271,12 @@ void BOPAlgo_MakerVolume::BuildSolids(BOPCol_ListOfShape& theLSR)
//function : TreatResult
//purpose :
//=======================================================================
void BOPAlgo_MakerVolume::RemoveBox(BOPCol_ListOfShape& theLSR,
const BOPCol_MapOfShape& theBoxFaces)
void BOPAlgo_MakerVolume::RemoveBox(TopTools_ListOfShape& theLSR,
const TopTools_MapOfShape& theBoxFaces)
{
UserBreak();
//
BOPCol_ListIteratorOfListOfShape aIt;
TopTools_ListIteratorOfListOfShape aIt;
TopExp_Explorer aExp;
Standard_Boolean bFound;
//
@ -305,14 +304,14 @@ void BOPAlgo_MakerVolume::RemoveBox(BOPCol_ListOfShape& theLSR,
//function : BuildShape
//purpose :
//=======================================================================
void BOPAlgo_MakerVolume::BuildShape(const BOPCol_ListOfShape& theLSR)
void BOPAlgo_MakerVolume::BuildShape(const TopTools_ListOfShape& theLSR)
{
if (theLSR.Extent() == 1) {
myShape = theLSR.First();
}
else {
BRep_Builder aBB;
BOPCol_ListIteratorOfListOfShape aIt;
TopTools_ListIteratorOfListOfShape aIt;
//
aIt.Initialize(theLSR);
for (; aIt.More(); aIt.Next()) {
@ -326,7 +325,7 @@ void BOPAlgo_MakerVolume::BuildShape(const BOPCol_ListOfShape& theLSR)
//function : FillInternalShapes
//purpose :
//=======================================================================
void BOPAlgo_MakerVolume::FillInternalShapes(const BOPCol_ListOfShape& theLSR)
void BOPAlgo_MakerVolume::FillInternalShapes(const TopTools_ListOfShape& theLSR)
{
if (myAvoidInternalShapes) {
return;
@ -339,13 +338,13 @@ void BOPAlgo_MakerVolume::FillInternalShapes(const BOPCol_ListOfShape& theLSR)
TopAbs_State aState;
TopoDS_Iterator aItS;
BRep_Builder aBB;
BOPCol_MapOfShape aMFence;
BOPCol_IndexedMapOfShape aMSS;
BOPCol_ListOfShape aLVE, aLSC, aLSIn;
BOPCol_ListIteratorOfListOfShape aIt, aIt1;
TopTools_MapOfShape aMFence;
TopTools_IndexedMapOfShape aMSS;
TopTools_ListOfShape aLVE, aLSC, aLSIn;
TopTools_ListIteratorOfListOfShape aIt, aIt1;
//
// 1. Collect shapes to process: vertices, edges, wires
const BOPCol_ListOfShape& anArguments = myDS->Arguments();
const TopTools_ListOfShape& anArguments = myDS->Arguments();
aIt.Initialize(anArguments);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS = aIt.Value();
@ -373,15 +372,15 @@ void BOPAlgo_MakerVolume::FillInternalShapes(const BOPCol_ListOfShape& theLSR)
aIt.Initialize(theLSR);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS = aIt.Value();
BOPTools::MapShapes(aS, TopAbs_EDGE, aMSS);
BOPTools::MapShapes(aS, TopAbs_VERTEX, aMSS);
TopExp::MapShapes(aS, TopAbs_EDGE, aMSS);
TopExp::MapShapes(aS, TopAbs_VERTEX, aMSS);
}
//
aIt.Initialize(aLVE);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS = aIt.Value();
if (myImages.IsBound(aS)) {
const BOPCol_ListOfShape &aLSp = myImages.Find(aS);
const TopTools_ListOfShape &aLSp = myImages.Find(aS);
aIt1.Initialize(aLSp);
for (; aIt1.More(); aIt1.Next()) {
const TopoDS_Shape& aSp = aIt1.Value();
@ -429,7 +428,7 @@ void BOPAlgo_MakerVolume::FillInternalShapes(const BOPCol_ListOfShape& theLSR)
//purpose :
//=======================================================================
void AddFace(const TopoDS_Shape& theF,
BOPCol_ListOfShape& theLF)
TopTools_ListOfShape& theLF)
{
TopoDS_Shape aFF = theF;
aFF.Orientation(TopAbs_FORWARD);

28
src/BOPAlgo/BOPAlgo_MakerVolume.hxx
View File

@ -18,14 +18,14 @@
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Boolean.hxx>
#include <Bnd_Box.hxx>
#include <TopoDS_Solid.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPAlgo_Builder.hxx>
#include <BOPCol_BaseAllocator.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <Bnd_Box.hxx>
#include <NCollection_BaseAllocator.hxx>
#include <TopoDS_Solid.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
class TopoDS_Solid;
class BOPAlgo_PaveFiller;
@ -120,7 +120,7 @@ public:
virtual ~BOPAlgo_MakerVolume();
//! Empty contructor.
BOPAlgo_MakerVolume(const BOPCol_BaseAllocator& theAllocator);
BOPAlgo_MakerVolume(const Handle(NCollection_BaseAllocator)& theAllocator);
//! Clears the data.
virtual void Clear() Standard_OVERRIDE;
@ -137,7 +137,7 @@ public:
const TopoDS_Solid& Box() const;
//! Returns the processed faces <myFaces>.
const BOPCol_ListOfShape& Faces() const;
const TopTools_ListOfShape& Faces() const;
//! Defines the preventing of addition of internal for solid parts into the result.
//! By default the internal parts are added into result.
@ -165,25 +165,25 @@ protected:
Standard_EXPORT void CollectFaces();
//! Makes solid box.
Standard_EXPORT void MakeBox (BOPCol_MapOfShape& theBoxFaces);
Standard_EXPORT void MakeBox (TopTools_MapOfShape& theBoxFaces);
//! Builds solids.
Standard_EXPORT void BuildSolids (BOPCol_ListOfShape& theLSR);
Standard_EXPORT void BuildSolids (TopTools_ListOfShape& theLSR);
//! Removes the covering box.
Standard_EXPORT void RemoveBox (BOPCol_ListOfShape& theLSR, const BOPCol_MapOfShape& theBoxFaces);
Standard_EXPORT void RemoveBox (TopTools_ListOfShape& theLSR, const TopTools_MapOfShape& theBoxFaces);
//! Fills the solids with internal shapes.
Standard_EXPORT void FillInternalShapes (const BOPCol_ListOfShape& theLSR);
Standard_EXPORT void FillInternalShapes (const TopTools_ListOfShape& theLSR);
//! Builds the result.
Standard_EXPORT void BuildShape (const BOPCol_ListOfShape& theLSR);
Standard_EXPORT void BuildShape (const TopTools_ListOfShape& theLSR);
Standard_Boolean myIntersect;
Bnd_Box myBBox;
TopoDS_Solid mySBox;
BOPCol_ListOfShape myFaces;
TopTools_ListOfShape myFaces;
Standard_Boolean myAvoidInternalShapes;
private:

2
src/BOPAlgo/BOPAlgo_MakerVolume.lxx
View File

@ -91,7 +91,7 @@ inline const TopoDS_Solid& BOPAlgo_MakerVolume::Box()const
//function : Faces
//purpose :
//=======================================================================
inline const BOPCol_ListOfShape& BOPAlgo_MakerVolume::Faces()const
inline const TopTools_ListOfShape& BOPAlgo_MakerVolume::Faces()const
{
return myFaces;
}

8
src/BOPAlgo/BOPAlgo_Options.hxx
View File

@ -18,7 +18,7 @@
#include <Message_Report.hxx>
#include <Standard_OStream.hxx>
#include <BOPCol_BaseAllocator.hxx>
#include <NCollection_BaseAllocator.hxx>
class Message_ProgressIndicator;
@ -47,13 +47,13 @@ public:
Standard_EXPORT BOPAlgo_Options();
//! Constructor with allocator
Standard_EXPORT BOPAlgo_Options(const BOPCol_BaseAllocator& theAllocator);
Standard_EXPORT BOPAlgo_Options(const Handle(NCollection_BaseAllocator)& theAllocator);
//! Destructor
Standard_EXPORT virtual ~BOPAlgo_Options();
//! Returns allocator
const BOPCol_BaseAllocator& Allocator() const
const Handle(NCollection_BaseAllocator)& Allocator() const
{
return myAllocator;
}
@ -184,7 +184,7 @@ protected:
protected:
BOPCol_BaseAllocator myAllocator;
Handle(NCollection_BaseAllocator) myAllocator;
Handle(Message_Report) myReport;
Standard_Boolean myRunParallel;
Standard_Real myFuzzyValue;

6
src/BOPAlgo/BOPAlgo_PaveFiller.cxx
View File

@ -172,7 +172,7 @@ void BOPAlgo_PaveFiller::SetSectionAttribute
//function : SetArguments
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::SetArguments(const BOPCol_ListOfShape& theLS)
void BOPAlgo_PaveFiller::SetArguments(const TopTools_ListOfShape& theLS)
{
myArguments=theLS;
}
@ -180,7 +180,7 @@ void BOPAlgo_PaveFiller::SetArguments(const BOPCol_ListOfShape& theLS)
//function : Arguments
//purpose :
//=======================================================================
const BOPCol_ListOfShape& BOPAlgo_PaveFiller::Arguments()const
const TopTools_ListOfShape& BOPAlgo_PaveFiller::Arguments()const
{
return myArguments;
}
@ -195,7 +195,7 @@ void BOPAlgo_PaveFiller::Init()
return;
}
//
BOPCol_ListIteratorOfListOfShape aIt(myArguments);
TopTools_ListIteratorOfListOfShape aIt(myArguments);
for (; aIt.More(); aIt.Next()) {
if (aIt.Value().IsNull()) {
AddError (new BOPAlgo_AlertNullInputShapes);

141
src/BOPAlgo/BOPAlgo_PaveFiller.hxx
View File

@ -22,36 +22,35 @@
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPAlgo_Algo.hxx>
#include <BOPAlgo_GlueEnum.hxx>
#include <BOPAlgo_SectionAttribute.hxx>
#include <BOPDS_DataMapOfPaveBlockListOfPaveBlock.hxx>
#include <BOPDS_IndexedDataMapOfPaveBlockListOfInteger.hxx>
#include <BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks.hxx>
#include <BOPDS_IndexedMapOfPaveBlock.hxx>
#include <BOPDS_ListOfPaveBlock.hxx>
#include <BOPDS_MapOfPair.hxx>
#include <BOPDS_MapOfPaveBlock.hxx>
#include <BOPDS_PDS.hxx>
#include <BOPDS_PIterator.hxx>
#include <BOPAlgo_SectionAttribute.hxx>
#include <Standard_Real.hxx>
#include <BOPAlgo_Algo.hxx>
#include <BOPCol_BaseAllocator.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <Standard_Integer.hxx>
#include <BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks.hxx>
#include <Standard_Boolean.hxx>
#include <BOPCol_IndexedMapOfShape.hxx>
#include <BOPCol_MapOfInteger.hxx>
#include <BOPCol_DataMapOfIntegerReal.hxx>
#include <BOPCol_ListOfInteger.hxx>
#include <BOPDS_IndexedMapOfPaveBlock.hxx>
#include <BOPCol_DataMapOfShapeInteger.hxx>
#include <BOPDS_DataMapOfPaveBlockListOfPaveBlock.hxx>
#include <BOPCol_DataMapOfIntegerInteger.hxx>
#include <BOPDS_ListOfPaveBlock.hxx>
#include <IntSurf_ListOfPntOn2S.hxx>
#include <BOPCol_DataMapOfIntegerListOfInteger.hxx>
#include <BOPDS_MapOfPaveBlock.hxx>
#include <BOPDS_MapOfPair.hxx>
#include <BOPDS_VectorOfCurve.hxx>
#include <BOPDS_IndexedDataMapOfPaveBlockListOfInteger.hxx>
#include <BOPCol_IndexedDataMapOfShapeInteger.hxx>
#include <BOPCol_IndexedDataMapOfShapeListOfShape.hxx>
#include <BOPAlgo_GlueEnum.hxx>
#include <IntSurf_ListOfPntOn2S.hxx>
#include <IntTools_ShrunkRange.hxx>
#include <NCollection_BaseAllocator.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
#include <TColStd_DataMapOfIntegerInteger.hxx>
#include <TColStd_DataMapOfIntegerListOfInteger.hxx>
#include <TColStd_DataMapOfIntegerReal.hxx>
#include <TColStd_ListOfInteger.hxx>
#include <TColStd_MapOfInteger.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <TopTools_DataMapOfShapeInteger.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
class IntTools_Context;
class BOPDS_DS;
class BOPAlgo_SectionAttribute;
@ -118,7 +117,7 @@ public:
Standard_EXPORT virtual ~BOPAlgo_PaveFiller();
Standard_EXPORT BOPAlgo_PaveFiller(const BOPCol_BaseAllocator& theAllocator);
Standard_EXPORT BOPAlgo_PaveFiller(const Handle(NCollection_BaseAllocator)& theAllocator);
Standard_EXPORT const BOPDS_DS& DS();
@ -126,9 +125,9 @@ public:
Standard_EXPORT const BOPDS_PIterator& Iterator();
Standard_EXPORT void SetArguments (const BOPCol_ListOfShape& theLS);
Standard_EXPORT void SetArguments (const TopTools_ListOfShape& theLS);
Standard_EXPORT const BOPCol_ListOfShape& Arguments() const;
Standard_EXPORT const TopTools_ListOfShape& Arguments() const;
Standard_EXPORT const Handle(IntTools_Context)& Context();
@ -206,7 +205,7 @@ protected:
//! into common table of interferences or not.<br>
//! If some of the Pave Blocks are forming the Common Blocks, the splits
//! of the Pave Blocks will also form a Common Block.
Standard_EXPORT void SplitPaveBlocks(const BOPCol_MapOfInteger& theMEdges,
Standard_EXPORT void SplitPaveBlocks(const TColStd_MapOfInteger& theMEdges,
const Standard_Boolean theAddInterfs);
Standard_EXPORT virtual void PerformVF();
@ -219,8 +218,8 @@ protected:
Standard_EXPORT void TreatVerticesEE();
Standard_EXPORT void MakeSDVerticesFF(const BOPCol_DataMapOfIntegerListOfInteger& aDMVLV,
BOPCol_DataMapOfIntegerInteger& theDMNewSD);
Standard_EXPORT void MakeSDVerticesFF(const TColStd_DataMapOfIntegerListOfInteger& aDMVLV,
TColStd_DataMapOfIntegerInteger& theDMNewSD);
Standard_EXPORT void MakeSplitEdges();
@ -228,7 +227,7 @@ protected:
Standard_EXPORT void MakePCurves();
Standard_EXPORT Standard_Integer MakeSDVertices(const BOPCol_ListOfInteger& theVertIndices,
Standard_EXPORT Standard_Integer MakeSDVertices(const TColStd_ListOfInteger& theVertIndices,
const Standard_Boolean theAddInterfs = 1);
Standard_EXPORT void ProcessDE();
@ -245,25 +244,25 @@ protected:
//! Performs intersection of new vertices, obtained in E/E and E/F intersections
Standard_EXPORT void PerformNewVertices(BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& theMVCPB,
const BOPCol_BaseAllocator& theAllocator,
const Handle(NCollection_BaseAllocator)& theAllocator,
const Standard_Boolean theIsEEIntersection = Standard_True);
Standard_EXPORT Standard_Boolean CheckFacePaves (const TopoDS_Vertex& theVnew, const BOPCol_MapOfInteger& theMIF);
Standard_EXPORT Standard_Boolean CheckFacePaves (const TopoDS_Vertex& theVnew, const TColStd_MapOfInteger& theMIF);
Standard_EXPORT static Standard_Boolean CheckFacePaves (const Standard_Integer theN, const BOPCol_MapOfInteger& theMIFOn, const BOPCol_MapOfInteger& theMIFIn);
Standard_EXPORT static Standard_Boolean CheckFacePaves (const Standard_Integer theN, const TColStd_MapOfInteger& theMIFOn, const TColStd_MapOfInteger& theMIFIn);
Standard_EXPORT Standard_Boolean IsExistingVertex (const gp_Pnt& theP, const Standard_Real theTol, const BOPCol_MapOfInteger& theMVOn) const;
Standard_EXPORT Standard_Boolean IsExistingVertex (const gp_Pnt& theP, const Standard_Real theTol, const TColStd_MapOfInteger& theMVOn) const;
//! Checks and puts paves from <theMVOn> on the curve <theNC>.
Standard_EXPORT void PutPavesOnCurve (const BOPCol_MapOfInteger& theMVOn,
Standard_EXPORT void PutPavesOnCurve (const TColStd_MapOfInteger& theMVOn,
BOPDS_Curve& theNC,
const Standard_Integer nF1,
const Standard_Integer nF2,
const BOPCol_MapOfInteger& theMI,
const BOPCol_MapOfInteger& theMVEF,
BOPCol_DataMapOfIntegerReal& theMVTol,
BOPCol_DataMapOfIntegerListOfInteger& aDMVLV);
const TColStd_MapOfInteger& theMI,
const TColStd_MapOfInteger& theMVEF,
TColStd_DataMapOfIntegerReal& theMVTol,
TColStd_DataMapOfIntegerListOfInteger& aDMVLV);
Standard_EXPORT void FilterPavesOnCurves(const BOPDS_VectorOfCurve& theVNC);
@ -275,12 +274,12 @@ protected:
//! 1 - checks only EE;
//! 2 - checks only EF;
//! other - checks both types of intersections.
Standard_EXPORT Standard_Boolean ExtendedTolerance (const Standard_Integer nV, const BOPCol_MapOfInteger& aMI, Standard_Real& aTolVExt, const Standard_Integer aType = 0);
Standard_EXPORT Standard_Boolean ExtendedTolerance (const Standard_Integer nV, const TColStd_MapOfInteger& aMI, Standard_Real& aTolVExt, const Standard_Integer aType = 0);
Standard_EXPORT void PutBoundPaveOnCurve(const TopoDS_Face& theF1,
const TopoDS_Face& theF2,
BOPDS_Curve& theNC,
BOPCol_ListOfInteger& theLBV);
TColStd_ListOfInteger& theLBV);
Standard_EXPORT Standard_Boolean IsExistingPaveBlock
(const Handle(BOPDS_PaveBlock)& thePB, const BOPDS_Curve& theNC,
@ -288,16 +287,16 @@ protected:
const BOPDS_MapOfPaveBlock& theMPBCommon,
Handle(BOPDS_PaveBlock)& thePBOut, Standard_Real& theTolNew);
Standard_EXPORT Standard_Boolean IsExistingPaveBlock (const Handle(BOPDS_PaveBlock)& thePB, const BOPDS_Curve& theNC, const BOPCol_ListOfInteger& theLSE);
Standard_EXPORT Standard_Boolean IsExistingPaveBlock (const Handle(BOPDS_PaveBlock)& thePB, const BOPDS_Curve& theNC, const TColStd_ListOfInteger& theLSE);
//! Treatment of section edges.
Standard_EXPORT void PostTreatFF (BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& theMSCPB,
BOPDS_DataMapOfPaveBlockListOfPaveBlock& theDMExEdges,
BOPCol_DataMapOfIntegerInteger& theDMNewSD,
const BOPCol_IndexedMapOfShape& theMicroEdges,
const BOPCol_IndexedMapOfShape& theVertsOnRejectedPB,
const BOPCol_BaseAllocator& theAllocator);
TColStd_DataMapOfIntegerInteger& theDMNewSD,
const TopTools_IndexedMapOfShape& theMicroEdges,
const TopTools_IndexedMapOfShape& theVertsOnRejectedPB,
const Handle(NCollection_BaseAllocator)& theAllocator);
Standard_EXPORT void FindPaveBlocks (const Standard_Integer theV, const Standard_Integer theF, BOPDS_ListOfPaveBlock& theLPB);
@ -310,38 +309,38 @@ protected:
//! Checks and puts paves created in EF intersections on the curve <theNC>.
Standard_EXPORT void PutEFPavesOnCurve (BOPDS_Curve& theNC,
const BOPCol_MapOfInteger& theMI,
const BOPCol_MapOfInteger& theMVEF,
BOPCol_DataMapOfIntegerReal& theMVTol,
BOPCol_DataMapOfIntegerListOfInteger& aDMVLV);
const TColStd_MapOfInteger& theMI,
const TColStd_MapOfInteger& theMVEF,
TColStd_DataMapOfIntegerReal& theMVTol,
TColStd_DataMapOfIntegerListOfInteger& aDMVLV);
//! Puts stick paves on the curve <theNC>
Standard_EXPORT void PutStickPavesOnCurve (const TopoDS_Face& aF1,
const TopoDS_Face& aF2,
const BOPCol_MapOfInteger& theMI,
const TColStd_MapOfInteger& theMI,
BOPDS_Curve& theNC,
const BOPCol_MapOfInteger& theMVStick,
BOPCol_DataMapOfIntegerReal& theMVTol,
BOPCol_DataMapOfIntegerListOfInteger& aDMVLV);
const TColStd_MapOfInteger& theMVStick,
TColStd_DataMapOfIntegerReal& theMVTol,
TColStd_DataMapOfIntegerListOfInteger& aDMVLV);
//! Collects indices of vertices created in all intersections between
//! two faces (<nF1> and <nF2>) to the map <theMVStick>.
//! Also, it collects indices of EF vertices to the <theMVEF> map
//! and indices of all subshapes of these two faces to the <theMI> map.
Standard_EXPORT void GetStickVertices (const Standard_Integer nF1, const Standard_Integer nF2, BOPCol_MapOfInteger& theMVStick, BOPCol_MapOfInteger& theMVEF, BOPCol_MapOfInteger& theMI);
Standard_EXPORT void GetStickVertices (const Standard_Integer nF1, const Standard_Integer nF2, TColStd_MapOfInteger& theMVStick, TColStd_MapOfInteger& theMVEF, TColStd_MapOfInteger& theMI);
//! Collects index nF and indices of all subshapes of the shape with index <nF>
//! to the map <theMI>.
Standard_EXPORT void GetFullShapeMap (const Standard_Integer nF, BOPCol_MapOfInteger& theMI);
Standard_EXPORT void GetFullShapeMap (const Standard_Integer nF, TColStd_MapOfInteger& theMI);
//! Removes indices of vertices that are already on the
//! curve <theNC> from the map <theMV>.
//! It is used in PutEFPavesOnCurve and PutStickPavesOnCurve methods.
Standard_EXPORT void RemoveUsedVertices (BOPDS_Curve& theNC, BOPCol_MapOfInteger& theMV);
Standard_EXPORT void RemoveUsedVertices (BOPDS_Curve& theNC, TColStd_MapOfInteger& theMV);
//! Puts the pave nV on the curve theNC.
@ -352,15 +351,15 @@ protected:
Standard_EXPORT void PutPaveOnCurve (const Standard_Integer nV,
const Standard_Real theTolR3D,
const BOPDS_Curve& theNC,
const BOPCol_MapOfInteger& theMI,
BOPCol_DataMapOfIntegerReal& theMVTol,
BOPCol_DataMapOfIntegerListOfInteger& aDMVLV,
const TColStd_MapOfInteger& theMI,
TColStd_DataMapOfIntegerReal& theMVTol,
TColStd_DataMapOfIntegerListOfInteger& aDMVLV,
const Standard_Integer aType = 0);
//! Adds the existing edges from the map <theMPBOnIn> which interfere
//! with the vertices from <theMVB> map to the post treatment of section edges.
Standard_EXPORT void ProcessExistingPaveBlocks (const Standard_Integer theInt, const BOPDS_IndexedMapOfPaveBlock& theMPBOnIn, const BOPCol_DataMapOfIntegerListOfInteger& theDMBV, BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& theMSCPB, BOPCol_DataMapOfShapeInteger& theMVI, BOPDS_MapOfPaveBlock& theMPB);
Standard_EXPORT void ProcessExistingPaveBlocks (const Standard_Integer theInt, const BOPDS_IndexedMapOfPaveBlock& theMPBOnIn, const TColStd_DataMapOfIntegerListOfInteger& theDMBV, BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& theMSCPB, TopTools_DataMapOfShapeInteger& theMVI, BOPDS_MapOfPaveBlock& theMPB);
//! Replaces existing pave block <thePB> with new pave blocks <theLPB>.
@ -370,7 +369,7 @@ protected:
//! Treatment of vertices that were created in EE intersections.
Standard_EXPORT void TreatNewVertices(const BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& theMVCPB, BOPCol_IndexedDataMapOfShapeListOfShape& theImages);
Standard_EXPORT void TreatNewVertices(const BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& theMVCPB, TopTools_IndexedDataMapOfShapeListOfShape& theImages);
//! Put paves on the curve <aBC> in case when <aBC>
@ -379,10 +378,10 @@ protected:
//! Keeps data for post treatment
Standard_EXPORT void PreparePostTreatFF (const Standard_Integer aInt, const Standard_Integer aCur, const Handle(BOPDS_PaveBlock)& aPB, BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& aMSCPB, BOPCol_DataMapOfShapeInteger& aMVI, BOPDS_ListOfPaveBlock& aLPB);
Standard_EXPORT void PreparePostTreatFF (const Standard_Integer aInt, const Standard_Integer aCur, const Handle(BOPDS_PaveBlock)& aPB, BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& aMSCPB, TopTools_DataMapOfShapeInteger& aMVI, BOPDS_ListOfPaveBlock& aLPB);
//! Updates the information about faces
Standard_EXPORT void UpdateFaceInfo (BOPDS_DataMapOfPaveBlockListOfPaveBlock& theDME, const BOPCol_DataMapOfIntegerInteger& theDMV);
Standard_EXPORT void UpdateFaceInfo (BOPDS_DataMapOfPaveBlockListOfPaveBlock& theDME, const TColStd_DataMapOfIntegerInteger& theDMV);
//! Updates tolerance of vertex with index <nV>
@ -390,7 +389,7 @@ protected:
//! Returns TRUE if intersection happened.
Standard_EXPORT Standard_Boolean ForceInterfVE(const Standard_Integer nV,
Handle(BOPDS_PaveBlock)& aPB,
BOPCol_MapOfInteger& theMEdges);
TColStd_MapOfInteger& theMEdges);
//! Updates tolerance of vertex with index <nV>
//! to make it interfere with face with index <nF>
@ -409,7 +408,7 @@ protected:
//! Updates pave blocks which have the paves with indices contained
//! in the map <aDMNewSD>.
Standard_EXPORT void UpdatePaveBlocks(const BOPCol_DataMapOfIntegerInteger& aDMNewSD);
Standard_EXPORT void UpdatePaveBlocks(const TColStd_DataMapOfIntegerInteger& aDMNewSD);
//! Updates tolerance vertex nV due to V/E interference.
//! It always creates new vertex if nV is from arguments.
@ -432,7 +431,7 @@ protected:
Standard_EXPORT void UpdateEdgeTolerance(const Standard_Integer nE,
const Standard_Real aTolNew);
Standard_EXPORT void RemovePaveBlocks(const BOPCol_MapOfInteger theEdges);
Standard_EXPORT void RemovePaveBlocks(const TColStd_MapOfInteger theEdges);
Standard_EXPORT void CorrectToleranceOfSE();
@ -491,7 +490,7 @@ protected:
Standard_EXPORT void ForceInterfEE();
BOPCol_ListOfShape myArguments;
TopTools_ListOfShape myArguments;
BOPDS_PDS myDS;
BOPDS_PIterator myIterator;
Handle(IntTools_Context) myContext;

29
src/BOPAlgo/BOPAlgo_PaveFiller_1.cxx
View File

@ -20,11 +20,6 @@
#include <BOPAlgo_PaveFiller.hxx>
#include <BOPAlgo_Tools.hxx>
#include <BOPAlgo_Alerts.hxx>
#include <BOPCol_DataMapOfIntegerInteger.hxx>
#include <BOPCol_DataMapOfIntegerListOfInteger.hxx>
#include <BOPCol_IndexedDataMapOfIntegerListOfInteger.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_MapOfInteger.hxx>
#include <BOPDS_DS.hxx>
#include <BOPDS_Iterator.hxx>
#include <BOPDS_PaveBlock.hxx>
@ -38,10 +33,12 @@
#include <IntTools_Context.hxx>
#include <NCollection_BaseAllocator.hxx>
#include <Precision.hxx>
#include <TColStd_DataMapOfIntegerInteger.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Compound.hxx>
#include <TopTools_ListOfShape.hxx>
//=======================================================================
// function: PerformVV
@ -64,8 +61,8 @@ void BOPAlgo_PaveFiller::PerformVV()
//-----------------------------------------------------scope f
aAllocator=
NCollection_BaseAllocator::CommonBaseAllocator();
BOPCol_IndexedDataMapOfIntegerListOfInteger aMILI(100, aAllocator);
NCollection_List<BOPCol_ListOfInteger> aMBlocks(aAllocator);
NCollection_IndexedDataMap<Standard_Integer, TColStd_ListOfInteger>aMILI(100, aAllocator);
NCollection_List<TColStd_ListOfInteger> aMBlocks(aAllocator);
//
// 1. Map V/LV
for (; myIterator->More(); myIterator->Next()) {
@ -84,15 +81,15 @@ void BOPAlgo_PaveFiller::PerformVV()
BOPAlgo_Tools::MakeBlocks<Standard_Integer, TColStd_MapIntegerHasher>(aMILI, aMBlocks, aAllocator);
//
// 3. Make vertices
NCollection_List<BOPCol_ListOfInteger>::Iterator aItB(aMBlocks);
NCollection_List<TColStd_ListOfInteger>::Iterator aItB(aMBlocks);
for (; aItB.More(); aItB.Next()) {
const BOPCol_ListOfInteger& aLI = aItB.Value();
const TColStd_ListOfInteger& aLI = aItB.Value();
MakeSDVertices(aLI);
}
//
BOPCol_DataMapIteratorOfDataMapOfIntegerInteger aItDMII;
TColStd_DataMapIteratorOfDataMapOfIntegerInteger aItDMII;
//
BOPCol_DataMapOfIntegerInteger& aDMII=myDS->ShapesSD();
TColStd_DataMapOfIntegerInteger& aDMII=myDS->ShapesSD();
aItDMII.Initialize(aDMII);
for (; aItDMII.More(); aItDMII.Next()) {
n1=aItDMII.Key();
@ -109,13 +106,13 @@ void BOPAlgo_PaveFiller::PerformVV()
// purpose:
//=======================================================================
Standard_Integer BOPAlgo_PaveFiller::MakeSDVertices
(const BOPCol_ListOfInteger& theVertIndices,
(const TColStd_ListOfInteger& theVertIndices,
const Standard_Boolean theAddInterfs)
{
TopoDS_Vertex aVSD, aVn;
Standard_Integer nSD = -1;
BOPCol_ListIteratorOfListOfInteger aItLI(theVertIndices);
BOPCol_ListOfShape aLV;
TColStd_ListIteratorOfListOfInteger aItLI(theVertIndices);
TopTools_ListOfShape aLV;
for (; aItLI.More(); aItLI.Next()) {
Standard_Integer nX = aItLI.Value(), nSD1;
if (myDS->HasShapeSD(nX, nSD1)) {
@ -167,7 +164,7 @@ Standard_Integer BOPAlgo_PaveFiller::MakeSDVertices
Standard_Integer iR1 = myDS->Rank(n1);
const TopoDS_Shape& aV1 = myDS->Shape(n1);
//
BOPCol_ListIteratorOfListOfInteger aItLI2 = aItLI;
TColStd_ListIteratorOfListOfInteger aItLI2 = aItLI;
aItLI2.Next();
for (; aItLI2.More(); aItLI2.Next()) {
Standard_Integer n2 = aItLI2.Value();
@ -186,7 +183,7 @@ Standard_Integer BOPAlgo_PaveFiller::MakeSDVertices
//
if (theAddInterfs) {
myDS->AddInterf(n1, n2);
BOPDS_InterfVV& aVV = aVVs.Append1();
BOPDS_InterfVV& aVV = aVVs.Appended();
//
aVV.SetIndices(n1, n2);
aVV.SetIndexNew(nV);

10
src/BOPAlgo/BOPAlgo_PaveFiller_10.cxx
View File

@ -48,7 +48,7 @@ void BOPAlgo_PaveFiller::SetNonDestructive()
}
//
Standard_Boolean bFlag;
BOPCol_ListIteratorOfListOfShape aItLS;
TopTools_ListIteratorOfListOfShape aItLS;
//
bFlag=Standard_False;
aItLS.Initialize(myArguments);
@ -69,10 +69,10 @@ void BOPAlgo_PaveFiller::UpdateEdgeTolerance (const Standard_Integer nE,
Standard_Integer nV, nVx;
Standard_Real aTolV;
BRep_Builder aBB;
BOPCol_ListIteratorOfListOfInteger aIt;
TColStd_ListIteratorOfListOfInteger aIt;
//
BOPDS_ShapeInfo& aSIE=myDS->ChangeShapeInfo(nE);
const BOPCol_ListOfInteger& aLI=aSIE.SubShapes();
const TColStd_ListOfInteger& aLI=aSIE.SubShapes();
//
if (myNonDestructive) {
bIsNewShape=myDS->IsNewShape(nE);
@ -196,7 +196,7 @@ void BOPAlgo_PaveFiller::UpdateCommonBlocksWithSDVertices()
Standard_Integer aNbPBP;
//
BOPDS_VectorOfListOfPaveBlock& aPBP=myDS->ChangePaveBlocksPool();
aNbPBP=aPBP.Extent();
aNbPBP=aPBP.Length();
if(!aNbPBP) {
return;
}
@ -237,7 +237,7 @@ namespace
//purpose :
//=======================================================================
template <class InterfType>
void UpdateIntfsWithSDVertices(BOPDS_PDS theDS, BOPCol_NCVector<InterfType>& theInterfs)
void UpdateIntfsWithSDVertices(BOPDS_PDS theDS, NCollection_Vector<InterfType>& theInterfs)
{
for (Standard_Integer i = 0; i < theInterfs.Length(); i++)
{

28
src/BOPAlgo/BOPAlgo_PaveFiller_11.cxx
View File

@ -42,7 +42,7 @@ void BOPAlgo_PaveFiller::CheckSelfInterference()
//
// Map of connections of interfering shapes
NCollection_IndexedDataMap<TopoDS_Shape,
BOPCol_IndexedMapOfShape,
TopTools_IndexedMapOfShape,
TopTools_ShapeMapHasher> aMCSI;
BOPDS_MapOfCommonBlock aMCBFence;
//
@ -63,8 +63,8 @@ void BOPAlgo_PaveFiller::CheckSelfInterference()
//
// Analyze the shared vertices and common blocks
//
BOPCol_MapOfInteger aMSubS;
BOPCol_ListIteratorOfListOfInteger aItLI(aSI.SubShapes());
TColStd_MapOfInteger aMSubS;
TColStd_ListIteratorOfListOfInteger aItLI(aSI.SubShapes());
for (; aItLI.More(); aItLI.Next()) {
Standard_Integer nV = aItLI.Value();
myDS->HasShapeSD(nV, nV);
@ -86,9 +86,9 @@ void BOPAlgo_PaveFiller::CheckSelfInterference()
if (!aR.Contains(nV[k]) && !aMSubS.Contains(nV[k])) {
// Add connection
const TopoDS_Shape& aV = myDS->Shape(nV[k]);
BOPCol_IndexedMapOfShape* pMSOr = aMCSI.ChangeSeek(aV);
TopTools_IndexedMapOfShape* pMSOr = aMCSI.ChangeSeek(aV);
if (!pMSOr) {
pMSOr = &aMCSI(aMCSI.Add(aV, BOPCol_IndexedMapOfShape()));
pMSOr = &aMCSI(aMCSI.Add(aV, TopTools_IndexedMapOfShape()));
}
pMSOr->Add(aS);
}
@ -101,7 +101,7 @@ void BOPAlgo_PaveFiller::CheckSelfInterference()
if (aMCBFence.Add(aCB)) {
const BOPDS_ListOfPaveBlock& aLPBCB = aCB->PaveBlocks();
//
BOPCol_ListOfInteger aLE;
TColStd_ListOfInteger aLE;
BOPDS_ListIteratorOfListOfPaveBlock aItCB(aLPBCB);
for (; aItCB.More(); aItCB.Next()) {
const Handle(BOPDS_PaveBlock)& aPBCB = aItCB.Value();
@ -117,7 +117,7 @@ void BOPAlgo_PaveFiller::CheckSelfInterference()
TopoDS_Compound aWC;
aBB.MakeCompound(aWC);
//
BOPCol_ListIteratorOfListOfInteger aItLE(aLE);
TColStd_ListIteratorOfListOfInteger aItLE(aLE);
for (; aItLE.More(); aItLE.Next()) {
const TopoDS_Shape& aE1 = myDS->Shape(aItLE.Value());
aBB.Add(aWC, aE1);
@ -134,14 +134,14 @@ void BOPAlgo_PaveFiller::CheckSelfInterference()
const BOPDS_FaceInfo& aFI = myDS->FaceInfo(j);
//
for (Standard_Integer k = 0; k < 2; ++k) {
const BOPCol_MapOfInteger& aMVF = !k ? aFI.VerticesIn() : aFI.VerticesSc();
BOPCol_MapIteratorOfMapOfInteger aItM(aMVF);
const TColStd_MapOfInteger& aMVF = !k ? aFI.VerticesIn() : aFI.VerticesSc();
TColStd_MapIteratorOfMapOfInteger aItM(aMVF);
for (; aItM.More(); aItM.Next()) {
const TopoDS_Shape& aV = myDS->Shape(aItM.Value());
// add connection
BOPCol_IndexedMapOfShape* pMSOr = aMCSI.ChangeSeek(aV);
TopTools_IndexedMapOfShape* pMSOr = aMCSI.ChangeSeek(aV);
if (!pMSOr) {
pMSOr = &aMCSI(aMCSI.Add(aV, BOPCol_IndexedMapOfShape()));
pMSOr = &aMCSI(aMCSI.Add(aV, TopTools_IndexedMapOfShape()));
}
pMSOr->Add(aS);
}
@ -154,9 +154,9 @@ void BOPAlgo_PaveFiller::CheckSelfInterference()
const Handle(BOPDS_PaveBlock)& aPB = aMPBF(iPB);
const TopoDS_Shape& aE = myDS->Shape(aPB->Edge());
// add connection
BOPCol_IndexedMapOfShape* pMSOr = aMCSI.ChangeSeek(aE);
TopTools_IndexedMapOfShape* pMSOr = aMCSI.ChangeSeek(aE);
if (!pMSOr) {
pMSOr = &aMCSI(aMCSI.Add(aE, BOPCol_IndexedMapOfShape()));
pMSOr = &aMCSI(aMCSI.Add(aE, TopTools_IndexedMapOfShape()));
}
pMSOr->Add(aS);
}
@ -167,7 +167,7 @@ void BOPAlgo_PaveFiller::CheckSelfInterference()
// Analyze connections
Standard_Integer aNbC = aMCSI.Extent();
for (j = 1; j <= aNbC; ++j) {
const BOPCol_IndexedMapOfShape& aMCS = aMCSI(j);
const TopTools_IndexedMapOfShape& aMCS = aMCSI(j);
if (aMCS.Extent() > 1) {
// Add acquired self-interference warning:
// Several faces from one argument contain the same vertex or edge

44
src/BOPAlgo/BOPAlgo_PaveFiller_2.cxx
View File

@ -19,8 +19,6 @@
#include <BOPAlgo_PaveFiller.hxx>
#include <BOPAlgo_Alerts.hxx>
#include <BOPAlgo_Tools.hxx>
#include <BOPCol_NCVector.hxx>
#include <BOPCol_Parallel.hxx>
#include <BOPDS_DS.hxx>
#include <BOPDS_Interf.hxx>
#include <BOPDS_Iterator.hxx>
@ -28,10 +26,12 @@
#include <BOPDS_PaveBlock.hxx>
#include <BOPDS_VectorOfInterfVE.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_Parallel.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <gp_Pnt.hxx>
#include <IntTools_Context.hxx>
#include <NCollection_Vector.hxx>
#include <Precision.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
@ -136,16 +136,16 @@ class BOPAlgo_VertexEdge : public BOPAlgo_Algo {
Handle(BOPDS_PaveBlock) myPB;
};
//=======================================================================
typedef BOPCol_NCVector
typedef NCollection_Vector
<BOPAlgo_VertexEdge> BOPAlgo_VectorOfVertexEdge;
//
typedef BOPCol_ContextFunctor
typedef BOPTools_ContextFunctor
<BOPAlgo_VertexEdge,
BOPAlgo_VectorOfVertexEdge,
Handle(IntTools_Context),
IntTools_Context> BOPAlgo_VertexEdgeFunctor;
//
typedef BOPCol_ContextCnt
typedef BOPTools_ContextCnt
<BOPAlgo_VertexEdgeFunctor,
BOPAlgo_VectorOfVertexEdge,
Handle(IntTools_Context)> BOPAlgo_VertexEdgeCnt;
@ -194,9 +194,9 @@ void BOPAlgo_PaveFiller::PerformVE()
continue;
}
//
BOPCol_ListOfInteger* pLV = aMVEPairs.ChangeSeek(aPB);
TColStd_ListOfInteger* pLV = aMVEPairs.ChangeSeek(aPB);
if (!pLV)
pLV = &aMVEPairs(aMVEPairs.Add(aPB, BOPCol_ListOfInteger()));
pLV = &aMVEPairs(aMVEPairs.Add(aPB, TColStd_ListOfInteger()));
pLV->Append(nV);
}
//
@ -227,14 +227,14 @@ void BOPAlgo_PaveFiller::IntersectVE
// for all vertices having the same SD vertex.
// It will also be used as a Fence map to avoid repeated
// intersection of the same SD vertex with edge
NCollection_DataMap<BOPDS_Pair, BOPCol_ListOfInteger, BOPDS_PairMapHasher> aDMVSD;
NCollection_DataMap<BOPDS_Pair, TColStd_ListOfInteger, BOPDS_PairMapHasher> aDMVSD;
//
for (i = 1; i <= aNbVE; ++i) {
const Handle(BOPDS_PaveBlock)& aPB = theVEPairs.FindKey(i);
Standard_Integer nE = aPB->OriginalEdge();
//
const BOPCol_ListOfInteger& aLV = theVEPairs(i);
BOPCol_ListIteratorOfListOfInteger aItLV(aLV);
const TColStd_ListOfInteger& aLV = theVEPairs(i);
TColStd_ListIteratorOfListOfInteger aItLV(aLV);
for (; aItLV.More(); aItLV.Next()) {
Standard_Integer nV = aItLV.Value();
//
@ -242,20 +242,20 @@ void BOPAlgo_PaveFiller::IntersectVE
myDS->HasShapeSD(nV, nVSD);
//
BOPDS_Pair aPair(nVSD, nE);
BOPCol_ListOfInteger* pLI = aDMVSD.ChangeSeek(aPair);
TColStd_ListOfInteger* pLI = aDMVSD.ChangeSeek(aPair);
if (pLI) {
// Already added
pLI->Append(nV);
continue;
}
// New pair
pLI = aDMVSD.Bound(aPair, BOPCol_ListOfInteger());
pLI = aDMVSD.Bound(aPair, TColStd_ListOfInteger());
pLI->Append(nV);
//
const TopoDS_Vertex& aV = TopoDS::Vertex(myDS->Shape(nVSD));
const TopoDS_Edge& aE = TopoDS::Edge(myDS->Shape(nE));
//
BOPAlgo_VertexEdge& aVESolver = aVVE.Append1();
BOPAlgo_VertexEdge& aVESolver = aVVE.Appended();
aVESolver.SetIndices(nVSD, nE);
aVESolver.SetVertex(aV);
aVESolver.SetEdge(aE);
@ -271,10 +271,10 @@ void BOPAlgo_PaveFiller::IntersectVE
//=============================================================
//
// Keep the modified edges for further update
BOPCol_MapOfInteger aMEdges;
TColStd_MapOfInteger aMEdges;
//
// Analyze intersections
aNbVE = aVVE.Extent();
aNbVE = aVVE.Length();
for (i = 0; i < aNbVE; ++i) {
const BOPAlgo_VertexEdge& aVESolver = aVVE(i);
if (aVESolver.Flag() != 0) {
@ -305,12 +305,12 @@ void BOPAlgo_PaveFiller::IntersectVE
if (theAddInterfs) {
// Add interferences into DS
BOPDS_Pair aPair(nV, nE);
const BOPCol_ListOfInteger& aLI = aDMVSD.Find(aPair);
BOPCol_ListIteratorOfListOfInteger aItLI(aLI);
const TColStd_ListOfInteger& aLI = aDMVSD.Find(aPair);
TColStd_ListIteratorOfListOfInteger aItLI(aLI);
for (; aItLI.More(); aItLI.Next()) {
const Standard_Integer nVOld = aItLI.Value();
// 3. Create interference V/E
BOPDS_InterfVE& aVE = aVEs.Append1();
BOPDS_InterfVE& aVE = aVEs.Appended();
aVE.SetIndices(nVOld, nE);
aVE.SetParameter(aT);
// 2. Add a pair in the whole table of interferences
@ -336,7 +336,7 @@ void BOPAlgo_PaveFiller::IntersectVE
//=======================================================================
static
void MakeNewCommonBlock(const BOPDS_ListOfPaveBlock& theLPB,
const BOPCol_ListOfInteger& theLFaces,
const TColStd_ListOfInteger& theLFaces,
BOPDS_PDS& theDS)
{
// Make Common Block from the pave blocks in the list
@ -354,7 +354,7 @@ static
// function: SplitPaveBlocks
// purpose:
//=======================================================================
void BOPAlgo_PaveFiller::SplitPaveBlocks(const BOPCol_MapOfInteger& theMEdges,
void BOPAlgo_PaveFiller::SplitPaveBlocks(const TColStd_MapOfInteger& theMEdges,
const Standard_Boolean theAddInterfs)
{
// Fence map to avoid unification of the same vertices twice
@ -364,7 +364,7 @@ void BOPAlgo_PaveFiller::SplitPaveBlocks(const BOPCol_MapOfInteger& theMEdges,
BOPDS_ListOfPaveBlock,
TColStd_MapTransientHasher> aMCBNewPB;
//
BOPCol_MapIteratorOfMapOfInteger aItM(theMEdges);
TColStd_MapIteratorOfMapOfInteger aItM(theMEdges);
for (; aItM.More(); aItM.Next()) {
Standard_Integer nE = aItM.Value();
BOPDS_ListOfPaveBlock& aLPB = myDS->ChangePaveBlocks(nE);
@ -400,7 +400,7 @@ void BOPAlgo_PaveFiller::SplitPaveBlocks(const BOPCol_MapOfInteger& theMEdges,
BOPDS_Pair aPair;
aPair.SetIndices(nV1, nV2);
if (aMPairs.Add(aPair)) {
BOPCol_ListOfInteger aLV;
TColStd_ListOfInteger aLV;
aLV.Append(nV1);
aLV.Append(nV2);
MakeSDVertices(aLV, theAddInterfs);

60
src/BOPAlgo/BOPAlgo_PaveFiller_3.cxx
View File

@ -20,8 +20,6 @@
#include <BOPAlgo_PaveFiller.hxx>
#include <BOPAlgo_Tools.hxx>
#include <BOPAlgo_Alerts.hxx>
#include <BOPCol_NCVector.hxx>
#include <BOPCol_Parallel.hxx>
#include <BOPDS_CommonBlock.hxx>
#include <BOPDS_CoupleOfPaveBlocks.hxx>
#include <BOPDS_DS.hxx>
@ -32,6 +30,7 @@
#include <BOPDS_PaveBlock.hxx>
#include <BOPDS_VectorOfInterfEE.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_Parallel.hxx>
#include <BndLib_Add3dCurve.hxx>
#include <BRep_Tool.hxx>
#include <BRep_Builder.hxx>
@ -46,6 +45,7 @@
#include <IntTools_ShrunkRange.hxx>
#include <IntTools_Tools.hxx>
#include <NCollection_IncAllocator.hxx>
#include <NCollection_Vector.hxx>
#include <Precision.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
@ -112,14 +112,14 @@ class BOPAlgo_EdgeEdge :
};
//
//=======================================================================
typedef BOPCol_NCVector
typedef NCollection_Vector
<BOPAlgo_EdgeEdge> BOPAlgo_VectorOfEdgeEdge;
//
typedef BOPCol_Functor
typedef BOPTools_Functor
<BOPAlgo_EdgeEdge,
BOPAlgo_VectorOfEdgeEdge> BOPAlgo_EdgeEdgeFunctor;
//
typedef BOPCol_Cnt
typedef BOPTools_Cnt
<BOPAlgo_EdgeEdgeFunctor,
BOPAlgo_VectorOfEdgeEdge> BOPAlgo_EdgeEdgeCnt;
//
@ -148,7 +148,7 @@ void BOPAlgo_PaveFiller::PerformEE()
BOPAlgo_VectorOfEdgeEdge aVEdgeEdge;
BOPDS_MapIteratorOfMapOfPaveBlock aItPB;
// keep modified edges for further update
BOPCol_MapOfInteger aMEdges;
TColStd_MapOfInteger aMEdges;
//
aAllocator=NCollection_BaseAllocator::CommonBaseAllocator();
//-----------------------------------------------------scope f
@ -215,7 +215,7 @@ void BOPAlgo_PaveFiller::PerformEE()
bExpressCompute=((nV11==nV21 && nV12==nV22) ||
(nV12==nV21 && nV11==nV22));
//
BOPAlgo_EdgeEdge& anEdgeEdge=aVEdgeEdge.Append1();
BOPAlgo_EdgeEdge& anEdgeEdge=aVEdgeEdge.Appended();
//
anEdgeEdge.UseQuickCoincidenceCheck(bExpressCompute);
//
@ -230,7 +230,7 @@ void BOPAlgo_PaveFiller::PerformEE()
}//for (; aIt1.More(); aIt1.Next()) {
}//for (; myIterator->More(); myIterator->Next()) {
//
aNbEdgeEdge=aVEdgeEdge.Extent();
aNbEdgeEdge=aVEdgeEdge.Length();
//======================================================
BOPAlgo_EdgeEdgeCnt::Perform(myRunParallel, aVEdgeEdge);
//======================================================
@ -353,7 +353,7 @@ void BOPAlgo_PaveFiller::PerformEE()
}
}
if (bFlag) {
BOPDS_InterfEE& aEE = aEEs.Append1();
BOPDS_InterfEE& aEE = aEEs.Appended();
aEE.SetIndices(nE1, nE2);
aEE.SetCommonPart(aCPart);
continue;
@ -374,7 +374,7 @@ void BOPAlgo_PaveFiller::PerformEE()
{
Standard_Integer nVS[2], iFound;
Standard_Real aTolVx, aD2, aDT2;
BOPCol_MapOfInteger aMV;
TColStd_MapOfInteger aMV;
gp_Pnt aPnew, aPx;
//
iFound=0;
@ -413,8 +413,8 @@ void BOPAlgo_PaveFiller::PerformEE()
}
//
// 1
BOPDS_InterfEE& aEE=aEEs.Append1();
iX=aEEs.Extent()-1;
BOPDS_InterfEE& aEE=aEEs.Appended();
iX=aEEs.Length()-1;
aEE.SetIndices(nE1, nE2);
aEE.SetCommonPart(aCPart);
// 2
@ -440,8 +440,8 @@ void BOPAlgo_PaveFiller::PerformEE()
break;
}
// 1
BOPDS_InterfEE& aEE=aEEs.Append1();
iX=aEEs.Extent()-1;
BOPDS_InterfEE& aEE=aEEs.Appended();
iX=aEEs.Length()-1;
aEE.SetIndices(nE1, nE2);
aEE.SetCommonPart(aCPart);
// 2
@ -497,7 +497,7 @@ void BOPAlgo_PaveFiller::PerformNewVertices
Standard_Real aTolAdd = myFuzzyValue / 2.;
//
// 1. Fuse the new vertices
BOPCol_IndexedDataMapOfShapeListOfShape aImages;
TopTools_IndexedDataMapOfShapeListOfShape aImages;
TreatNewVertices(theMVCPB, aImages);
//
// 2. Add new vertices to myDS and connect indices to CPB structure
@ -507,7 +507,7 @@ void BOPAlgo_PaveFiller::PerformNewVertices
Standard_Integer i, aNb = aImages.Extent();
for (i = 1; i <= aNb; ++i) {
const TopoDS_Vertex& aV = TopoDS::Vertex(aImages.FindKey(i));
const BOPCol_ListOfShape& aLVSD = aImages.FindFromIndex(i);
const TopTools_ListOfShape& aLVSD = aImages.FindFromIndex(i);
//
BOPDS_ShapeInfo aSI;
aSI.SetShapeType(TopAbs_VERTEX);
@ -519,7 +519,7 @@ void BOPAlgo_PaveFiller::PerformNewVertices
aBox.Add(BRep_Tool::Pnt(aV));
aBox.SetGap(BRep_Tool::Tolerance(aV) + aTolAdd);
//
BOPCol_ListIteratorOfListOfShape aItLS(aLVSD);
TopTools_ListIteratorOfListOfShape aItLS(aLVSD);
for (; aItLS.More(); aItLS.Next()) {
const TopoDS_Shape& aVx = aItLS.Value();
BOPDS_CoupleOfPaveBlocks &aCPB = theMVCPB.ChangeFromKey(aVx);
@ -540,9 +540,9 @@ void BOPAlgo_PaveFiller::PerformNewVertices
Handle(BOPDS_PaveBlock) aPB[2];
aCPB.PaveBlocks(aPB[0], aPB[1]);
for (Standard_Integer j = 0; j < 2; ++j) {
BOPCol_ListOfInteger *pLI = aMPBLI.ChangeSeek(aPB[j]);
TColStd_ListOfInteger *pLI = aMPBLI.ChangeSeek(aPB[j]);
if (!pLI) {
pLI = &aMPBLI(aMPBLI.Add(aPB[j], BOPCol_ListOfInteger(theAllocator)));
pLI = &aMPBLI(aMPBLI.Add(aPB[j], TColStd_ListOfInteger(theAllocator)));
}
pLI->Append(iV);
//
@ -561,11 +561,11 @@ void BOPAlgo_PaveFiller::PerformNewVertices
//=======================================================================
void BOPAlgo_PaveFiller::TreatNewVertices
(const BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& theMVCPB,
BOPCol_IndexedDataMapOfShapeListOfShape& myImages)
TopTools_IndexedDataMapOfShapeListOfShape& myImages)
{
//
// Prepare for intersection
BOPCol_IndexedDataMapOfShapeReal aVerts;
TopTools_IndexedDataMapOfShapeReal aVerts;
Standard_Integer i, aNbV = theMVCPB.Extent();
for (i = 1; i <= aNbV; ++i) {
const TopoDS_Shape& aV = theMVCPB.FindKey(i);
@ -574,13 +574,13 @@ void BOPAlgo_PaveFiller::TreatNewVertices
}
//
// Perform intersection
BOPCol_ListOfListOfShape aChains;
TopTools_ListOfListOfShape aChains;
BOPAlgo_Tools::IntersectVertices(aVerts, myRunParallel, myFuzzyValue, aChains);
//
// Treat the results - make new vertices for each chain
BOPCol_ListOfListOfShape::Iterator aItC(aChains);
TopTools_ListOfListOfShape::Iterator aItC(aChains);
for (; aItC.More(); aItC.Next()) {
const BOPCol_ListOfShape& aLVSD = aItC.Value();
const TopTools_ListOfShape& aLVSD = aItC.Value();
//
TopoDS_Vertex aVNew;
BOPTools_AlgoTools::MakeVertex(aLVSD, aVNew);
@ -666,7 +666,7 @@ void BOPAlgo_PaveFiller::AnalyzeShrunkData(const Handle(BOPDS_PaveBlock)& thePB,
//=======================================================================
Standard_Boolean BOPAlgo_PaveFiller::ForceInterfVE(const Standard_Integer nV,
Handle(BOPDS_PaveBlock)& aPB,
BOPCol_MapOfInteger& theMEdges)
TColStd_MapOfInteger& theMEdges)
{
Standard_Integer nE, nVx, nVSD, iFlag;
Standard_Real aT, aTolVNew;
@ -707,7 +707,7 @@ Standard_Boolean BOPAlgo_PaveFiller::ForceInterfVE(const Standard_Integer nV,
BOPDS_VectorOfInterfVE& aVEs=myDS->InterfVE();
aVEs.SetIncrement(10);
// 1
BOPDS_InterfVE& aVE=aVEs.Append1();
BOPDS_InterfVE& aVE=aVEs.Appended();
aVE.SetIndices(nV, nE);
aVE.SetParameter(aT);
// 2
@ -820,7 +820,7 @@ void BOPAlgo_PaveFiller::ForceInterfEE()
BOPDS_MapOfPaveBlock aMPBFence(1, anAlloc);
BOPDS_VectorOfListOfPaveBlock& aPBP = myDS->ChangePaveBlocksPool();
Standard_Integer aNbPBP = aPBP.Extent();
Standard_Integer aNbPBP = aPBP.Length();
for (i = 0; i < aNbPBP; ++i)
{
BOPDS_ListOfPaveBlock& aLPB = aPBP(i);
@ -911,7 +911,7 @@ void BOPAlgo_PaveFiller::ForceInterfEE()
aPB2->Range(aT21, aT22);
// Add pair for intersection
BOPAlgo_EdgeEdge& anEdgeEdge = aVEdgeEdge.Append1();
BOPAlgo_EdgeEdge& anEdgeEdge = aVEdgeEdge.Appended();
anEdgeEdge.UseQuickCoincidenceCheck(Standard_True);
anEdgeEdge.SetPaveBlock1(aPB1);
anEdgeEdge.SetPaveBlock2(aPB2);
@ -923,7 +923,7 @@ void BOPAlgo_PaveFiller::ForceInterfEE()
}
}
Standard_Integer aNbPairs = aVEdgeEdge.Extent();
Standard_Integer aNbPairs = aVEdgeEdge.Length();
if (!aNbPairs)
return;
@ -968,7 +968,7 @@ void BOPAlgo_PaveFiller::ForceInterfEE()
const Standard_Integer nE1 = aPB[0]->OriginalEdge();
const Standard_Integer nE2 = aPB[1]->OriginalEdge();
BOPDS_InterfEE& aEE = aEEs.Append1();
BOPDS_InterfEE& aEE = aEEs.Appended();
aEE.SetIndices(nE1, nE2);
aEE.SetCommonPart(aCP);
myDS->AddInterf(nE1, nE2);

36
src/BOPAlgo/BOPAlgo_PaveFiller_4.cxx
View File

@ -19,9 +19,6 @@
#include <BOPAlgo_PaveFiller.hxx>
#include <BOPAlgo_Alerts.hxx>
#include <BOPAlgo_SectionAttribute.hxx>
#include <BOPCol_MapOfInteger.hxx>
#include <BOPCol_NCVector.hxx>
#include <BOPCol_Parallel.hxx>
#include <BOPDS_Curve.hxx>
#include <BOPDS_DS.hxx>
#include <BOPDS_FaceInfo.hxx>
@ -31,11 +28,14 @@
#include <BOPDS_PaveBlock.hxx>
#include <BOPDS_SubIterator.hxx>
#include <BOPDS_VectorOfInterfVF.hxx>
#include <BOPTools_Parallel.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <BRepBndLib.hxx>
#include <gp_Pnt.hxx>
#include <IntTools_Context.hxx>
#include <NCollection_Vector.hxx>
#include <TColStd_MapOfInteger.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Vertex.hxx>
@ -132,16 +132,16 @@ class BOPAlgo_VertexFace : public BOPAlgo_Algo {
Handle(IntTools_Context) myContext;
};
//=======================================================================
typedef BOPCol_NCVector<BOPAlgo_VertexFace>
typedef NCollection_Vector<BOPAlgo_VertexFace>
BOPAlgo_VectorOfVertexFace;
//
typedef BOPCol_ContextFunctor
typedef BOPTools_ContextFunctor
<BOPAlgo_VertexFace,
BOPAlgo_VectorOfVertexFace,
Handle(IntTools_Context),
IntTools_Context> BOPAlgo_VertexFaceFunctor;
//
typedef BOPCol_ContextCnt
typedef BOPTools_ContextCnt
<BOPAlgo_VertexFaceFunctor,
BOPAlgo_VectorOfVertexFace,
Handle(IntTools_Context)> BOPAlgo_VertexFaceCnt;
@ -204,7 +204,7 @@ void BOPAlgo_PaveFiller::PerformVF()
const TopoDS_Vertex& aV=(*(TopoDS_Vertex *)(&myDS->Shape(nVx)));
const TopoDS_Face& aF=(*(TopoDS_Face *)(&myDS->Shape(nF)));
//
BOPAlgo_VertexFace& aVertexFace=aVVF.Append1();
BOPAlgo_VertexFace& aVertexFace=aVVF.Appended();
//
aVertexFace.SetIndices(nV, nF);
aVertexFace.SetVertex(aV);
@ -213,7 +213,7 @@ void BOPAlgo_PaveFiller::PerformVF()
aVertexFace.SetProgressIndicator(myProgressIndicator);
}//for (; myIterator->More(); myIterator->Next()) {
//
aNbVF=aVVF.Extent();
aNbVF=aVVF.Length();
//================================================================
BOPAlgo_VertexFaceCnt::Perform(myRunParallel, aVVF, myContext);
//================================================================
@ -234,7 +234,7 @@ void BOPAlgo_PaveFiller::PerformVF()
aVertexFace.Indices(nV, nF);
aVertexFace.Parameters(aT1, aT2);
// 1
BOPDS_InterfVF& aVF=aVFs.Append1();
BOPDS_InterfVF& aVF=aVFs.Appended();
aVF.SetIndices(nV, nF);
aVF.SetUV(aT1, aT2);
// 2
@ -250,7 +250,7 @@ void BOPAlgo_PaveFiller::PerformVF()
}
// 5 update FaceInfo
BOPDS_FaceInfo& aFI=myDS->ChangeFaceInfo(nF);
BOPCol_MapOfInteger& aMVIn=aFI.ChangeVerticesIn();
TColStd_MapOfInteger& aMVIn=aFI.ChangeVerticesIn();
aMVIn.Add(nVx);
}//for (k=0; k < aNbVF; ++k) {
//
@ -264,19 +264,19 @@ void BOPAlgo_PaveFiller::TreatVerticesEE()
{
Standard_Integer i, aNbS,aNbEEs, nF, nV, iFlag;
Standard_Real aT1, aT2, dummy;
BOPCol_ListIteratorOfListOfInteger aItLI;
TColStd_ListIteratorOfListOfInteger aItLI;
Handle(NCollection_BaseAllocator) aAllocator;
//
aAllocator=
NCollection_BaseAllocator::CommonBaseAllocator();
BOPCol_ListOfInteger aLIV(aAllocator), aLIF(aAllocator);
BOPCol_MapOfInteger aMI(100, aAllocator);
TColStd_ListOfInteger aLIV(aAllocator), aLIF(aAllocator);
TColStd_MapOfInteger aMI(100, aAllocator);
BOPDS_MapOfPaveBlock aMPBF(100, aAllocator);
//
aNbS=myDS->NbSourceShapes();
//
BOPDS_VectorOfInterfEE& aEEs=myDS->InterfEE();
aNbEEs=aEEs.Extent();
aNbEEs=aEEs.Length();
for (i=0; i<aNbEEs; ++i) {
BOPDS_InterfEE& aEE=aEEs(i);
if (aEE.HasIndexNew()) {
@ -316,7 +316,7 @@ void BOPAlgo_PaveFiller::TreatVerticesEE()
aIt.Value(nV, nF);
//
BOPDS_FaceInfo& aFI=myDS->ChangeFaceInfo(nF);
const BOPCol_MapOfInteger& aMVOn=aFI.VerticesOn();
const TColStd_MapOfInteger& aMVOn=aFI.VerticesOn();
//
if (!aMVOn.Contains(nV)) {
const TopoDS_Vertex& aV=(*(TopoDS_Vertex *)(&myDS->Shape(nV)));
@ -324,14 +324,14 @@ void BOPAlgo_PaveFiller::TreatVerticesEE()
iFlag = myContext->ComputeVF(aV, aF, aT1, aT2, dummy, myFuzzyValue);
if (!iFlag) {
// 1
BOPDS_InterfVF& aVF=aVFs.Append1();
i=aVFs.Extent()-1;
BOPDS_InterfVF& aVF=aVFs.Appended();
i=aVFs.Length()-1;
aVF.SetIndices(nV, nF);
aVF.SetUV(aT1, aT2);
// 2
myDS->AddInterf(nV, nF);
//
BOPCol_MapOfInteger& aMVIn=aFI.ChangeVerticesIn();
TColStd_MapOfInteger& aMVIn=aFI.ChangeVerticesIn();
aMVIn.Add(nV);
}
}

62
src/BOPAlgo/BOPAlgo_PaveFiller_5.cxx
View File

@ -20,9 +20,6 @@
#include <BOPAlgo_PaveFiller.hxx>
#include <BOPAlgo_Alerts.hxx>
#include <BOPAlgo_Tools.hxx>
#include <BOPCol_MapOfInteger.hxx>
#include <BOPCol_NCVector.hxx>
#include <BOPCol_Parallel.hxx>
#include <BOPDS_CommonBlock.hxx>
#include <BOPDS_CoupleOfPaveBlocks.hxx>
#include <BOPDS_Curve.hxx>
@ -33,6 +30,7 @@
#include <BOPDS_Pave.hxx>
#include <BOPDS_PaveBlock.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_Parallel.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <BRepAdaptor_Curve.hxx>
@ -43,7 +41,9 @@
#include <IntTools_Range.hxx>
#include <IntTools_SequenceOfCommonPrts.hxx>
#include <IntTools_Tools.hxx>
#include <NCollection_Vector.hxx>
#include <Precision.hxx>
#include <TColStd_MapOfInteger.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
@ -123,15 +123,15 @@ class BOPAlgo_EdgeFace :
};
//
//=======================================================================
typedef BOPCol_NCVector<BOPAlgo_EdgeFace> BOPAlgo_VectorOfEdgeFace;
typedef NCollection_Vector<BOPAlgo_EdgeFace> BOPAlgo_VectorOfEdgeFace;
//
typedef BOPCol_ContextFunctor
typedef BOPTools_ContextFunctor
<BOPAlgo_EdgeFace,
BOPAlgo_VectorOfEdgeFace,
Handle(IntTools_Context),
IntTools_Context> BOPAlgo_EdgeFaceFunctor;
//
typedef BOPCol_ContextCnt
typedef BOPTools_ContextCnt
<BOPAlgo_EdgeFaceFunctor,
BOPAlgo_VectorOfEdgeFace,
Handle(IntTools_Context)> BOPAlgo_EdgeFaceCnt;
@ -178,7 +178,7 @@ void BOPAlgo_PaveFiller::PerformEF()
//
aAllocator=NCollection_BaseAllocator::CommonBaseAllocator();
//
BOPCol_MapOfInteger aMIEFC(100, aAllocator);
TColStd_MapOfInteger aMIEFC(100, aAllocator);
BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks aMVCPB(100, aAllocator);
BOPDS_IndexedDataMapOfPaveBlockListOfInteger aMPBLI(100, aAllocator);
BOPAlgo_DataMapOfPaveBlockBndBox aDMPBBox(100, aAllocator);
@ -204,8 +204,8 @@ void BOPAlgo_PaveFiller::PerformEF()
BOPDS_FaceInfo& aFI=myDS->ChangeFaceInfo(nF);
const BOPDS_IndexedMapOfPaveBlock& aMPBF=aFI.PaveBlocksOn();
//
const BOPCol_MapOfInteger& aMVIn=aFI.VerticesIn();
const BOPCol_MapOfInteger& aMVOn=aFI.VerticesOn();
const TColStd_MapOfInteger& aMVIn=aFI.VerticesIn();
const TColStd_MapOfInteger& aMVOn=aFI.VerticesOn();
//
aTolE=BRep_Tool::Tolerance(aE);
aTolF=BRep_Tool::Tolerance(aF);
@ -234,7 +234,7 @@ void BOPAlgo_PaveFiller::PerformEF()
bV2=aMVIn.Contains(nV2) || aMVOn.Contains(nV2);
bExpressCompute=bV1 && bV2;
//
BOPAlgo_EdgeFace& aEdgeFace=aVEdgeFace.Append1();
BOPAlgo_EdgeFace& aEdgeFace=aVEdgeFace.Appended();
//
aEdgeFace.SetIndices(nE, nF);
aEdgeFace.SetPaveBlock(aPB);
@ -260,7 +260,7 @@ void BOPAlgo_PaveFiller::PerformEF()
}//for (; aIt.More(); aIt.Next()) {
}//for (; myIterator->More(); myIterator->Next()) {
//
aNbEdgeFace=aVEdgeFace.Extent();
aNbEdgeFace=aVEdgeFace.Length();
//=================================================================
BOPAlgo_EdgeFaceCnt::Perform(myRunParallel, aVEdgeFace, myContext);
//=================================================================
@ -306,8 +306,8 @@ void BOPAlgo_PaveFiller::PerformEF()
IntTools_Range aR1(aT1, aTS1), aR2(aTS2, aT2);
//
BOPDS_FaceInfo& aFI=myDS->ChangeFaceInfo(nF);
const BOPCol_MapOfInteger& aMIFOn=aFI.VerticesOn();
const BOPCol_MapOfInteger& aMIFIn=aFI.VerticesIn();
const TColStd_MapOfInteger& aMIFOn=aFI.VerticesOn();
const TColStd_MapOfInteger& aMIFIn=aFI.VerticesIn();
//
Standard_Boolean bLinePlane = Standard_False;
if (aNbCPrts) {
@ -342,8 +342,8 @@ void BOPAlgo_PaveFiller::PerformEF()
if (bV[0] && bV[1]) {
IntTools_CommonPrt aCP = aCPart;
aCP.SetType(TopAbs_EDGE);
BOPDS_InterfEF& aEF=aEFs.Append1();
iX=aEFs.Extent()-1;
BOPDS_InterfEF& aEF=aEFs.Appended();
iX=aEFs.Length()-1;
aEF.SetIndices(nE, nF);
aEF.SetCommonPart(aCP);
myDS->AddInterf(nE, nF);
@ -411,8 +411,8 @@ void BOPAlgo_PaveFiller::PerformEF()
//
aMIEFC.Add(nF);
// 1
BOPDS_InterfEF& aEF=aEFs.Append1();
iX=aEFs.Extent()-1;
BOPDS_InterfEF& aEF=aEFs.Appended();
iX=aEFs.Length()-1;
aEF.SetIndices(nE, nF);
aEF.SetCommonPart(aCPart);
// 2
@ -431,8 +431,8 @@ void BOPAlgo_PaveFiller::PerformEF()
aMIEFC.Add(nF);
//
// 1
BOPDS_InterfEF& aEF=aEFs.Append1();
iX=aEFs.Extent()-1;
BOPDS_InterfEF& aEF=aEFs.Appended();
iX=aEFs.Length()-1;
aEF.SetIndices(nE, nF);
//
bV[0]=CheckFacePaves(nV[0], aMIFOn, aMIFIn);
@ -462,7 +462,7 @@ void BOPAlgo_PaveFiller::PerformEF()
PerformNewVertices(aMVCPB, aAllocator, Standard_False);
//
// Update FaceInfoIn for all faces having EF common parts
BOPCol_MapIteratorOfMapOfInteger aItMI;
TColStd_MapIteratorOfMapOfInteger aItMI;
aItMI.Initialize(aMIEFC);
for (; aItMI.More(); aItMI.Next()) {
nF=aItMI.Value();
@ -480,12 +480,12 @@ void BOPAlgo_PaveFiller::PerformEF()
//=======================================================================
Standard_Boolean BOPAlgo_PaveFiller::CheckFacePaves
(const Standard_Integer nVx,
const BOPCol_MapOfInteger& aMIFOn,
const BOPCol_MapOfInteger& aMIFIn)
const TColStd_MapOfInteger& aMIFOn,
const TColStd_MapOfInteger& aMIFIn)
{
Standard_Boolean bRet;
Standard_Integer nV;
BOPCol_MapIteratorOfMapOfInteger aIt;
TColStd_MapIteratorOfMapOfInteger aIt;
//
bRet=Standard_False;
//
@ -514,11 +514,11 @@ Standard_Boolean BOPAlgo_PaveFiller::CheckFacePaves
//=======================================================================
Standard_Boolean BOPAlgo_PaveFiller::CheckFacePaves
(const TopoDS_Vertex& aVnew,
const BOPCol_MapOfInteger& aMIF)
const TColStd_MapOfInteger& aMIF)
{
Standard_Boolean bRet;
Standard_Integer nV, iFlag;
BOPCol_MapIteratorOfMapOfInteger aIt;
TColStd_MapIteratorOfMapOfInteger aIt;
//
bRet=Standard_True;
//
@ -557,7 +557,7 @@ Standard_Boolean BOPAlgo_PaveFiller::ForceInterfVF
BOPDS_VectorOfInterfVF& aVFs=myDS->InterfVF();
aVFs.SetIncrement(10);
// 1
BOPDS_InterfVF& aVF=aVFs.Append1();
BOPDS_InterfVF& aVF=aVFs.Appended();
//
aVF.SetIndices(nV, nF);
aVF.SetUV(U, V);
@ -572,7 +572,7 @@ Standard_Boolean BOPAlgo_PaveFiller::ForceInterfVF
}
//
BOPDS_FaceInfo& aFI=myDS->ChangeFaceInfo(nF);
BOPCol_MapOfInteger& aMVIn=aFI.ChangeVerticesIn();
TColStd_MapOfInteger& aMVIn=aFI.ChangeVerticesIn();
aMVIn.Add(nVx);
//
// check for self-interference
@ -610,7 +610,7 @@ void BOPAlgo_PaveFiller::ReduceIntersectionRange(const Standard_Integer theV1,
}
//
BOPDS_VectorOfInterfEE& aEEs = myDS->InterfEE();
Standard_Integer aNbEEs = aEEs.Extent();
Standard_Integer aNbEEs = aEEs.Length();
if (!aNbEEs) {
return;
}
@ -619,9 +619,9 @@ void BOPAlgo_PaveFiller::ReduceIntersectionRange(const Standard_Integer theV1,
Standard_Real aTR1, aTR2;
//
// get face's edges to check that E/E contains the edge from the face
BOPCol_MapOfInteger aMFE;
const BOPCol_ListOfInteger& aLI = myDS->ShapeInfo(theF).SubShapes();
BOPCol_ListIteratorOfListOfInteger aItLI(aLI);
TColStd_MapOfInteger aMFE;
const TColStd_ListOfInteger& aLI = myDS->ShapeInfo(theF).SubShapes();
TColStd_ListIteratorOfListOfInteger aItLI(aLI);
for (; aItLI.More(); aItLI.Next()) {
nE1 = aItLI.Value();
if (myDS->ShapeInfo(nE1).ShapeType() == TopAbs_EDGE) {

285
src/BOPAlgo/BOPAlgo_PaveFiller_6.cxx
View File

@ -15,17 +15,11 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Bnd_Box.hxx>
#include <BOPAlgo_PaveFiller.hxx>
#include <Bnd_Box.hxx>
#include <BOPAlgo_Alerts.hxx>
#include <BOPAlgo_SectionAttribute.hxx>
#include <BOPAlgo_Tools.hxx>
#include <BOPAlgo_Alerts.hxx>
#include <BOPCol_DataMapOfShapeInteger.hxx>
#include <BOPCol_ListOfInteger.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_MapOfInteger.hxx>
#include <BOPCol_NCVector.hxx>
#include <BOPCol_Parallel.hxx>
#include <BOPDS_CommonBlock.hxx>
#include <BOPDS_CoupleOfPaveBlocks.hxx>
#include <BOPDS_Curve.hxx>
@ -42,20 +36,20 @@
#include <BOPDS_ShapeInfo.hxx>
#include <BOPDS_VectorOfCurve.hxx>
#include <BOPDS_VectorOfPoint.hxx>
#include <BOPTools.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_AlgoTools3D.hxx>
#include <BOPTools_Parallel.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <BRep_TEdge.hxx>
#include <BRepLib.hxx>
#include <BRep_Tool.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepBndLib.hxx>
#include <BRepBuilderAPI_MakeVertex.hxx>
#include <BRepLib.hxx>
#include <BRepTools.hxx>
#include <Geom2d_Curve.hxx>
#include <Geom_Curve.hxx>
#include <Geom2d_Curve.hxx>
#include <GeomAPI_ProjectPointOnCurve.hxx>
#include <GeomAPI_ProjectPointOnSurf.hxx>
#include <gp_Pnt.hxx>
@ -71,7 +65,10 @@
#include <IntTools_SequenceOfPntOn2Faces.hxx>
#include <IntTools_ShrunkRange.hxx>
#include <IntTools_Tools.hxx>
#include <NCollection_Vector.hxx>
#include <Precision.hxx>
#include <TColStd_ListOfInteger.hxx>
#include <TColStd_MapOfInteger.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
@ -79,6 +76,8 @@
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopTools_DataMapOfShapeInteger.hxx>
#include <TopTools_ListOfShape.hxx>
//
static Standard_Real ToleranceFF(const BRepAdaptor_Surface& aBAS1,
@ -166,14 +165,14 @@ class BOPAlgo_FaceFace :
};
//
//=======================================================================
typedef BOPCol_NCVector
typedef NCollection_Vector
<BOPAlgo_FaceFace> BOPAlgo_VectorOfFaceFace;
//
typedef BOPCol_Functor
typedef BOPTools_Functor
<BOPAlgo_FaceFace,
BOPAlgo_VectorOfFaceFace> BOPAlgo_FaceFaceFunctor;
//
typedef BOPCol_Cnt
typedef BOPTools_Cnt
<BOPAlgo_FaceFaceFunctor,
BOPAlgo_VectorOfFaceFace> BOPAlgo_FaceFaceCnt;
/////////////////////////////////////////////////////////////////////////
@ -201,7 +200,7 @@ void BOPAlgo_PaveFiller::PerformFF()
Standard_Boolean bSplitCurve = Standard_False;
//
// Fence map to store faces with updated FaceInfo structure
BOPCol_MapOfInteger aMIFence;
TColStd_MapOfInteger aMIFence;
// Prepare the pairs of faces for intersection
BOPAlgo_VectorOfFaceFace aVFaceFace;
Standard_Integer nF1, nF2;
@ -251,14 +250,14 @@ void BOPAlgo_PaveFiller::PerformFF()
// Check if the planes are really interfering
Standard_Boolean bToIntersect = CheckPlanes(nF1, nF2);
if (!bToIntersect) {
BOPDS_InterfFF& aFF = aFFs.Append1();
BOPDS_InterfFF& aFF = aFFs.Appended();
aFF.SetIndices(nF1, nF2);
aFF.Init(0, 0);
continue;
}
}
//
BOPAlgo_FaceFace& aFaceFace=aVFaceFace.Append1();
BOPAlgo_FaceFace& aFaceFace=aVFaceFace.Appended();
//
aFaceFace.SetIndices(nF1, nF2);
aFaceFace.SetFaces(aF1, aF2);
@ -279,7 +278,7 @@ void BOPAlgo_PaveFiller::PerformFF()
}
else {
// for the Glue mode just add all interferences of that type
BOPDS_InterfFF& aFF = aFFs.Append1();
BOPDS_InterfFF& aFF = aFFs.Appended();
aFF.SetIndices(nF1, nF2);
aFF.SetTangentFaces(Standard_False);
aFF.Init(0, 0);
@ -291,12 +290,12 @@ void BOPAlgo_PaveFiller::PerformFF()
BOPAlgo_FaceFaceCnt::Perform(myRunParallel, aVFaceFace);
//======================================================
// Treatment of the results
Standard_Integer k, aNbFaceFace = aVFaceFace.Extent();
Standard_Integer k, aNbFaceFace = aVFaceFace.Length();
for (k = 0; k < aNbFaceFace; ++k) {
BOPAlgo_FaceFace& aFaceFace = aVFaceFace(k);
aFaceFace.Indices(nF1, nF2);
if (!aFaceFace.IsDone() || aFaceFace.HasErrors()) {
BOPDS_InterfFF& aFF = aFFs.Append1();
BOPDS_InterfFF& aFF = aFFs.Appended();
aFF.SetIndices(nF1, nF2);
aFF.Init(0, 0);
// Warn about failed intersection of faces
@ -319,7 +318,7 @@ void BOPAlgo_PaveFiller::PerformFF()
myDS->AddInterf(nF1, nF2);
}
//
BOPDS_InterfFF& aFF = aFFs.Append1();
BOPDS_InterfFF& aFF = aFFs.Appended();
aFF.SetIndices(nF1, nF2);
aFF.SetTangentFaces(bTangentFaces);
aFF.Init(aNbCurves, aNbPoints);
@ -342,7 +341,7 @@ void BOPAlgo_PaveFiller::PerformFF()
const IntTools_Curve& aIC = aCvsX(i);
Standard_Boolean bIsValid = IntTools_Tools::CheckCurve(aIC, aBox);
if (bIsValid) {
BOPDS_Curve& aNC = aVNC.Append1();
BOPDS_Curve& aNC = aVNC.Appended();
aNC.SetCurve(aIC);
// make sure that the bounding box has the maximal gap
aBox.Enlarge(aBoxExpandValue);
@ -357,7 +356,7 @@ void BOPAlgo_PaveFiller::PerformFF()
const IntTools_PntOn2Faces& aPi = aPntsX(i);
const gp_Pnt& aP = aPi.P1().Pnt();
//
BOPDS_Point& aNP = aVNP.Append1();
BOPDS_Point& aNP = aVNP.Appended();
aNP.SetPnt(aP);
}
}
@ -373,7 +372,7 @@ void BOPAlgo_PaveFiller::MakeBlocks()
}
//
BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
Standard_Integer aNbFF = aFFs.Extent();
Standard_Integer aNbFF = aFFs.Length();
if (!aNbFF) {
return;
}
@ -391,23 +390,23 @@ void BOPAlgo_PaveFiller::MakeBlocks()
aAllocator=
NCollection_BaseAllocator::CommonBaseAllocator();
//
BOPCol_ListOfInteger aLSE(aAllocator), aLBV(aAllocator);
BOPCol_MapOfInteger aMVOnIn(100, aAllocator),
TColStd_ListOfInteger aLSE(aAllocator), aLBV(aAllocator);
TColStd_MapOfInteger aMVOnIn(100, aAllocator),
aMVStick(100,aAllocator), aMVEF(100, aAllocator),
aMI(100, aAllocator), aMVBounds(100, aAllocator);
BOPDS_IndexedMapOfPaveBlock aMPBOnIn(100, aAllocator);
BOPDS_MapOfPaveBlock aMPBAdd(100, aAllocator), aMPBCommon;
BOPDS_ListOfPaveBlock aLPB(aAllocator);
BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks aMSCPB(100, aAllocator);
BOPCol_DataMapOfShapeInteger aMVI(100, aAllocator);
TopTools_DataMapOfShapeInteger aMVI(100, aAllocator);
BOPDS_DataMapOfPaveBlockListOfPaveBlock aDMExEdges(100, aAllocator);
BOPCol_DataMapOfIntegerReal aMVTol(100, aAllocator);
BOPCol_DataMapOfIntegerInteger aDMNewSD(100, aAllocator);
BOPCol_DataMapOfIntegerListOfInteger aDMVLV;
BOPCol_DataMapOfIntegerListOfInteger aDMBV(100, aAllocator);
BOPCol_DataMapIteratorOfDataMapOfIntegerReal aItMV;
BOPCol_IndexedMapOfShape aMicroEdges(100, aAllocator);
BOPCol_IndexedMapOfShape aVertsOnRejectedPB;
TColStd_DataMapOfIntegerReal aMVTol(100, aAllocator);
TColStd_DataMapOfIntegerInteger aDMNewSD(100, aAllocator);
TColStd_DataMapOfIntegerListOfInteger aDMVLV;
TColStd_DataMapOfIntegerListOfInteger aDMBV(100, aAllocator);
TColStd_DataMapIteratorOfDataMapOfIntegerReal aItMV;
TopTools_IndexedMapOfShape aMicroEdges(100, aAllocator);
TopTools_IndexedMapOfShape aVertsOnRejectedPB;
//
for (i=0; i<aNbFF; ++i) {
//
@ -417,9 +416,9 @@ void BOPAlgo_PaveFiller::MakeBlocks()
aFF.Indices(nF1, nF2);
//
BOPDS_VectorOfPoint& aVP=aFF.ChangePoints();
aNbP=aVP.Extent();
aNbP=aVP.Length();
BOPDS_VectorOfCurve& aVC=aFF.ChangeCurves();
aNbC=aVC.Extent();
aNbC=aVC.Length();
if (!aNbP && !aNbC) {
continue;
}
@ -496,7 +495,7 @@ void BOPAlgo_PaveFiller::MakeBlocks()
//
if (!aLBV.IsEmpty()) {
aDMBV.Bind(j, aLBV);
BOPCol_ListIteratorOfListOfInteger aItI(aLBV);
TColStd_ListIteratorOfListOfInteger aItI(aLBV);
for (; aItI.More(); aItI.Next()) {
aMVBounds.Add(aItI.Value());
}
@ -717,18 +716,18 @@ void BOPAlgo_PaveFiller::MakeBlocks()
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::MakeSDVerticesFF
(const BOPCol_DataMapOfIntegerListOfInteger& theDMVLV,
BOPCol_DataMapOfIntegerInteger& theDMNewSD)
(const TColStd_DataMapOfIntegerListOfInteger& theDMVLV,
TColStd_DataMapOfIntegerInteger& theDMNewSD)
{
// Create a new SD vertex for each group of coinciding vertices
// and put new substitutions to theDMNewSD.
BOPCol_DataMapIteratorOfDataMapOfIntegerListOfInteger aItG(theDMVLV);
TColStd_DataMapIteratorOfDataMapOfIntegerListOfInteger aItG(theDMVLV);
for (; aItG.More(); aItG.Next()) {
const BOPCol_ListOfInteger& aList = aItG.Value();
const TColStd_ListOfInteger& aList = aItG.Value();
// make SD vertices w/o creation of interfs
Standard_Integer nSD = MakeSDVertices(aList, Standard_False);
// update theDMNewSD
BOPCol_ListIteratorOfListOfInteger aItL(aList);
TColStd_ListIteratorOfListOfInteger aItL(aList);
for (; aItL.More(); aItL.Next()) {
Standard_Integer nV = aItL.Value();
theDMNewSD.Bind(nV, nSD);
@ -743,9 +742,9 @@ void BOPAlgo_PaveFiller::MakeSDVerticesFF
void BOPAlgo_PaveFiller::PostTreatFF
(BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& theMSCPB,
BOPDS_DataMapOfPaveBlockListOfPaveBlock& aDMExEdges,
BOPCol_DataMapOfIntegerInteger& aDMNewSD,
const BOPCol_IndexedMapOfShape& theMicroEdges,
const BOPCol_IndexedMapOfShape& theVertsOnRejectedPB,
TColStd_DataMapOfIntegerInteger& aDMNewSD,
const TopTools_IndexedMapOfShape& theMicroEdges,
const TopTools_IndexedMapOfShape& theVertsOnRejectedPB,
const Handle(NCollection_BaseAllocator)& theAllocator)
{
Standard_Integer aNbS = theMSCPB.Extent();
@ -758,14 +757,14 @@ void BOPAlgo_PaveFiller::PostTreatFF
Standard_Integer aNbLPBx;
TopAbs_ShapeEnum aType;
TopoDS_Shape aV, aE;
BOPCol_ListIteratorOfListOfShape aItLS;
TopTools_ListIteratorOfListOfShape aItLS;
BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
BOPDS_PDS aPDS;
Handle(BOPDS_PaveBlock) aPB1;
BOPDS_Pave aPave[2];
BOPDS_ShapeInfo aSI;
//
BOPCol_ListOfShape aLS(theAllocator);
TopTools_ListOfShape aLS(theAllocator);
BOPAlgo_PaveFiller aPF(theAllocator);
aPF.SetIsPrimary(Standard_False);
aPF.SetNonDestructive(myNonDestructive);
@ -811,7 +810,7 @@ void BOPAlgo_PaveFiller::PostTreatFF
}
//
// 1 prepare arguments
BOPCol_MapOfShape anAddedSD;
TopTools_MapOfShape anAddedSD;
for (k=1; k<=aNbS; ++k) {
const TopoDS_Shape& aS=theMSCPB.FindKey(k);
aLS.Append(aS);
@ -1107,7 +1106,7 @@ void BOPAlgo_PaveFiller::PostTreatFF
}//for (; aItLS.More(); aItLS.Next()) {
// Update SD for vertices that did not participate in operation
BOPCol_DataMapOfIntegerInteger::Iterator itDM(aDMNewSD);
TColStd_DataMapOfIntegerInteger::Iterator itDM(aDMNewSD);
for (; itDM.More(); itDM.Next())
{
const Standard_Integer* pSD = aDMNewSD.Seek(itDM.Value());
@ -1126,15 +1125,15 @@ void BOPAlgo_PaveFiller::PostTreatFF
//=======================================================================
void BOPAlgo_PaveFiller::UpdateFaceInfo
(BOPDS_DataMapOfPaveBlockListOfPaveBlock& theDME,
const BOPCol_DataMapOfIntegerInteger& theDMV)
const TColStd_DataMapOfIntegerInteger& theDMV)
{
Standard_Integer i, j, nV1, nF1, nF2,
aNbFF, aNbC, aNbP;
BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
BOPCol_MapOfInteger aMF;
TColStd_MapOfInteger aMF;
//
BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
aNbFF=aFFs.Extent();
aNbFF=aFFs.Length();
//
//1. Sections (curves, points);
for (i=0; i<aNbFF; ++i) {
@ -1146,7 +1145,7 @@ void BOPAlgo_PaveFiller::UpdateFaceInfo
//
// 1.1. Section edges
BOPDS_VectorOfCurve& aVNC=aFF.ChangeCurves();
aNbC=aVNC.Extent();
aNbC=aVNC.Length();
for (j=0; j<aNbC; ++j) {
BOPDS_Curve& aNC=aVNC(j);
BOPDS_ListOfPaveBlock& aLPBC=aNC.ChangePaveBlocks();
@ -1172,7 +1171,7 @@ void BOPAlgo_PaveFiller::UpdateFaceInfo
//
// 1.2. Section vertices
const BOPDS_VectorOfPoint& aVNP=aFF.Points();
aNbP=aVNP.Extent();
aNbP=aVNP.Length();
for (j=0; j<aNbP; ++j) {
const BOPDS_Point& aNP=aVNP(j);
nV1=aNP.Index();
@ -1199,8 +1198,8 @@ void BOPAlgo_PaveFiller::UpdateFaceInfo
// 2. Update Face Info information with new vertices and new
// pave blocks created in PostTreatFF from existing ones
Standard_Integer nV2, aNbPB;
BOPCol_MapIteratorOfMapOfInteger aItMF;
BOPCol_DataMapIteratorOfDataMapOfIntegerInteger aItMV;
TColStd_MapIteratorOfMapOfInteger aItMF;
TColStd_DataMapIteratorOfDataMapOfIntegerInteger aItMV;
//
aItMF.Initialize(aMF);
for (; aItMF.More(); aItMF.Next()) {
@ -1210,8 +1209,8 @@ void BOPAlgo_PaveFiller::UpdateFaceInfo
//
// 2.1. Update information about vertices
if (bVerts) {
BOPCol_MapOfInteger& aMVOn = aFI.ChangeVerticesOn();
BOPCol_MapOfInteger& aMVIn = aFI.ChangeVerticesIn();
TColStd_MapOfInteger& aMVOn = aFI.ChangeVerticesOn();
TColStd_MapOfInteger& aMVIn = aFI.ChangeVerticesIn();
//
aItMV.Initialize(theDMV);
for (; aItMV.More(); aItMV.Next()) {
@ -1270,14 +1269,14 @@ void BOPAlgo_PaveFiller::UpdateFaceInfo
Standard_Boolean BOPAlgo_PaveFiller::IsExistingVertex
(const gp_Pnt& aP,
const Standard_Real theTolR3D,
const BOPCol_MapOfInteger& aMVOnIn)const
const TColStd_MapOfInteger& aMVOnIn)const
{
Standard_Boolean bRet;
Standard_Integer nV, iFlag;
Standard_Real aTolCheck;
gp_Pnt aPV;
Bnd_Box aBoxP;
BOPCol_MapIteratorOfMapOfInteger aIt;
TColStd_MapIteratorOfMapOfInteger aIt;
//
aTolCheck = theTolR3D + myFuzzyValue;
bRet=Standard_True;
@ -1308,7 +1307,7 @@ Standard_Boolean BOPAlgo_PaveFiller::IsExistingVertex
Standard_Boolean BOPAlgo_PaveFiller::IsExistingPaveBlock
(const Handle(BOPDS_PaveBlock)& thePB,
const BOPDS_Curve& theNC,
const BOPCol_ListOfInteger& theLSE)
const TColStd_ListOfInteger& theLSE)
{
Standard_Boolean bRet=Standard_True;
//
@ -1320,7 +1319,7 @@ Standard_Boolean BOPAlgo_PaveFiller::IsExistingPaveBlock
Standard_Integer nE, iFlag, nV1, nV2;
gp_Pnt aPm;
Bnd_Box aBoxPm;
BOPCol_ListIteratorOfListOfInteger aItLI;
TColStd_ListIteratorOfListOfInteger aItLI;
//
thePB->Range(aT1, aT2);
thePB->Indices(nV1, nV2);
@ -1471,7 +1470,7 @@ Standard_Boolean BOPAlgo_PaveFiller::IsExistingPaveBlock
void BOPAlgo_PaveFiller::PutBoundPaveOnCurve(const TopoDS_Face& aF1,
const TopoDS_Face& aF2,
BOPDS_Curve& aNC,
BOPCol_ListOfInteger& aLVB)
TColStd_ListOfInteger& aLVB)
{
Standard_Boolean bVF;
Standard_Integer nV, iFlag, nVn, j, aNbEP;
@ -1572,18 +1571,18 @@ void BOPAlgo_PaveFiller::PutBoundPaveOnCurve(const TopoDS_Face& aF1,
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::PutPavesOnCurve
(const BOPCol_MapOfInteger& aMVOnIn,
(const TColStd_MapOfInteger& aMVOnIn,
BOPDS_Curve& aNC,
const Standard_Integer nF1,
const Standard_Integer nF2,
const BOPCol_MapOfInteger& aMI,
const BOPCol_MapOfInteger& aMVEF,
BOPCol_DataMapOfIntegerReal& aMVTol,
BOPCol_DataMapOfIntegerListOfInteger& aDMVLV)
const TColStd_MapOfInteger& aMI,
const TColStd_MapOfInteger& aMVEF,
TColStd_DataMapOfIntegerReal& aMVTol,
TColStd_DataMapOfIntegerListOfInteger& aDMVLV)
{
Standard_Boolean bInBothFaces;
Standard_Integer nV;
BOPCol_MapIteratorOfMapOfInteger aIt;
TColStd_MapIteratorOfMapOfInteger aIt;
//
const Bnd_Box& aBoxC=aNC.Box();
Standard_Real aTolR3D = Max(aNC.Tolerance(), aNC.TangentialTolerance());
@ -1645,7 +1644,7 @@ void BOPAlgo_PaveFiller::FilterPavesOnCurves(const BOPDS_VectorOfCurve& theVNC)
NCollection_IndexedDataMap<Standard_Integer,NCollection_List<PaveBlockDist> > aIDMVertPBs;
Standard_Integer i;
const Standard_Real anEps = gp::Resolution();
for (i = 0; i < theVNC.Extent(); ++i)
for (i = 0; i < theVNC.Length(); ++i)
{
const BOPDS_Curve& aNC = theVNC(i);
const IntTools_Curve& aIC = aNC.Curve();
@ -1720,7 +1719,7 @@ void BOPAlgo_PaveFiller::FilterPavesOnCurves(const BOPDS_VectorOfCurve& theVNC)
//=======================================================================
Standard_Boolean BOPAlgo_PaveFiller::ExtendedTolerance
(const Standard_Integer nV,
const BOPCol_MapOfInteger& aMI,
const TColStd_MapOfInteger& aMI,
Standard_Real& aTolVExt,
const Standard_Integer aType)
{
@ -1749,7 +1748,7 @@ Standard_Boolean BOPAlgo_PaveFiller::ExtendedTolerance
BOPDS_VectorOfInterfEF& aEFs=myDS->InterfEF();
//
for (; k<aNbInt; ++k) {
aNbLines = !k ? aEEs.Extent() : aEFs.Extent();
aNbLines = !k ? aEEs.Length() : aEFs.Length();
for (i = 0; i < aNbLines; ++i) {
BOPDS_Interf *aInt = !k ? (BOPDS_Interf*) (&aEEs(i)) :
(BOPDS_Interf*) (&aEFs(i));
@ -1788,14 +1787,14 @@ void BOPAlgo_PaveFiller::GetEFPnts
{
Standard_Integer nE, nF, nFOpposite, aNbEFs, i;
Standard_Real U1, U2, V1, V2, f, l;
BOPCol_MapOfInteger aMI;
TColStd_MapOfInteger aMI;
//
//collect indexes of all shapes from nF1 and nF2.
GetFullShapeMap(nF1, aMI);
GetFullShapeMap(nF2, aMI);
//
BOPDS_VectorOfInterfEF& aEFs=myDS->InterfEF();
aNbEFs = aEFs.Extent();
aNbEFs = aEFs.Length();
//
for(i = 0; i < aNbEFs; ++i) {
const BOPDS_InterfEF& aEF = aEFs(i);
@ -1859,10 +1858,10 @@ void BOPAlgo_PaveFiller::GetEFPnts
//=======================================================================
void BOPAlgo_PaveFiller::PutEFPavesOnCurve
(BOPDS_Curve& aNC,
const BOPCol_MapOfInteger& aMI,
const BOPCol_MapOfInteger& aMVEF,
BOPCol_DataMapOfIntegerReal& aMVTol,
BOPCol_DataMapOfIntegerListOfInteger& aDMVLV)
const TColStd_MapOfInteger& aMI,
const TColStd_MapOfInteger& aMVEF,
TColStd_DataMapOfIntegerReal& aMVTol,
TColStd_DataMapOfIntegerListOfInteger& aDMVLV)
{
if (!aMVEF.Extent()) {
return;
@ -1876,7 +1875,7 @@ void BOPAlgo_PaveFiller::GetEFPnts
}
//
Standard_Integer nV;
BOPCol_MapOfInteger aMV;
TColStd_MapOfInteger aMV;
//
aMV.Assign(aMVEF);
RemoveUsedVertices(aNC, aMV);
@ -1890,7 +1889,7 @@ void BOPAlgo_PaveFiller::GetEFPnts
const Handle(Geom_Curve)& aC3D=aIC.Curve();
GeomAPI_ProjectPointOnCurve& aProjPT = myContext->ProjPT(aC3D);
//
BOPCol_MapIteratorOfMapOfInteger aItMI;
TColStd_MapIteratorOfMapOfInteger aItMI;
aItMI.Initialize(aMV);
for (; aItMI.More(); aItMI.Next()) {
nV = aItMI.Value();
@ -1912,13 +1911,13 @@ void BOPAlgo_PaveFiller::GetEFPnts
void BOPAlgo_PaveFiller::PutStickPavesOnCurve
(const TopoDS_Face& aF1,
const TopoDS_Face& aF2,
const BOPCol_MapOfInteger& aMI,
const TColStd_MapOfInteger& aMI,
BOPDS_Curve& aNC,
const BOPCol_MapOfInteger& aMVStick,
BOPCol_DataMapOfIntegerReal& aMVTol,
BOPCol_DataMapOfIntegerListOfInteger& aDMVLV)
const TColStd_MapOfInteger& aMVStick,
TColStd_DataMapOfIntegerReal& aMVTol,
TColStd_DataMapOfIntegerListOfInteger& aDMVLV)
{
BOPCol_MapOfInteger aMV;
TColStd_MapOfInteger aMV;
aMV.Assign(aMVStick);
RemoveUsedVertices(aNC, aMV);
//
@ -1941,7 +1940,7 @@ void BOPAlgo_PaveFiller::GetEFPnts
gp_Pnt aPC[2], aPV;
gp_Dir aDN[2];
gp_Pnt2d aP2D;
BOPCol_MapIteratorOfMapOfInteger aItMI, aItMI1;
TColStd_MapIteratorOfMapOfInteger aItMI, aItMI1;
//
aDT2=2e-7; // the rich criteria
aDScPr=5.e-9; // the creasing criteria
@ -1993,9 +1992,9 @@ void BOPAlgo_PaveFiller::GetEFPnts
//=======================================================================
void BOPAlgo_PaveFiller::GetStickVertices(const Standard_Integer nF1,
const Standard_Integer nF2,
BOPCol_MapOfInteger& aMVStick,
BOPCol_MapOfInteger& aMVEF,
BOPCol_MapOfInteger& aMI)
TColStd_MapOfInteger& aMVStick,
TColStd_MapOfInteger& aMVEF,
TColStd_MapOfInteger& aMI)
{
Standard_Integer nS1, nS2, nVNew, aTypeInt, i;
//
@ -2006,8 +2005,8 @@ void BOPAlgo_PaveFiller::GetStickVertices(const Standard_Integer nF1,
BOPDS_VectorOfInterfEF& aEFs=myDS->InterfEF();
//
Standard_Integer aNbLines[5] = {
aVVs.Extent(), aVEs.Extent(), aEEs.Extent(),
aVFs.Extent(), aEFs.Extent()
aVVs.Length(), aVEs.Length(), aEEs.Length(),
aVFs.Length(), aEFs.Length()
};
//collect indices of all shapes from nF1 and nF2.
aMI.Clear();
@ -2049,13 +2048,13 @@ void BOPAlgo_PaveFiller::GetStickVertices(const Standard_Integer nF1,
// purpose:
//=======================================================================
void BOPAlgo_PaveFiller::GetFullShapeMap(const Standard_Integer nF,
BOPCol_MapOfInteger& aMI)
TColStd_MapOfInteger& aMI)
{
BOPCol_ListIteratorOfListOfInteger aIt;
TColStd_ListIteratorOfListOfInteger aIt;
Standard_Integer nS;
//
const BOPDS_ShapeInfo& aSI = myDS->ShapeInfo(nF);
const BOPCol_ListOfInteger& aLI = aSI.SubShapes();
const TColStd_ListOfInteger& aLI = aSI.SubShapes();
//
aMI.Add(nF);
aIt.Initialize(aLI);
@ -2070,7 +2069,7 @@ void BOPAlgo_PaveFiller::GetFullShapeMap(const Standard_Integer nF,
// purpose:
//=======================================================================
void BOPAlgo_PaveFiller::RemoveUsedVertices(BOPDS_Curve& aNC,
BOPCol_MapOfInteger& aMV)
TColStd_MapOfInteger& aMV)
{
if (!aMV.Extent()) {
return;
@ -2097,9 +2096,9 @@ void BOPAlgo_PaveFiller::PutPaveOnCurve
(const Standard_Integer nV,
const Standard_Real aTolR3D,
const BOPDS_Curve& aNC,
const BOPCol_MapOfInteger& aMI,
BOPCol_DataMapOfIntegerReal& aMVTol,
BOPCol_DataMapOfIntegerListOfInteger& aDMVLV,
const TColStd_MapOfInteger& aMI,
TColStd_DataMapOfIntegerReal& aMVTol,
TColStd_DataMapOfIntegerListOfInteger& aDMVLV,
const Standard_Integer iCheckExtend)
{
Standard_Boolean bIsVertexOnLine;
@ -2131,9 +2130,9 @@ void BOPAlgo_PaveFiller::PutPaveOnCurve
bExist = aPB->ContainsParameter(aT, aPTol, nVUsed);
if (bExist) {
// use existing pave
BOPCol_ListOfInteger* pList = aDMVLV.ChangeSeek(nVUsed);
TColStd_ListOfInteger* pList = aDMVLV.ChangeSeek(nVUsed);
if (!pList) {
pList = aDMVLV.Bound(nVUsed, BOPCol_ListOfInteger());
pList = aDMVLV.Bound(nVUsed, TColStd_ListOfInteger());
pList->Append(nVUsed);
if (!aMVTol.IsBound(nVUsed)) {
const TopoDS_Vertex& aVUsed = (*(TopoDS_Vertex *)(&myDS->Shape(nVUsed)));
@ -2142,7 +2141,7 @@ void BOPAlgo_PaveFiller::PutPaveOnCurve
}
}
// avoid repeated elements in the list
BOPCol_ListIteratorOfListOfInteger aItLI(*pList);
TColStd_ListIteratorOfListOfInteger aItLI(*pList);
for (; aItLI.More(); aItLI.Next()) {
if (aItLI.Value() == nV) {
break;
@ -2191,9 +2190,9 @@ void BOPAlgo_PaveFiller::PutPaveOnCurve
void BOPAlgo_PaveFiller::ProcessExistingPaveBlocks
(const Standard_Integer theInt,
const BOPDS_IndexedMapOfPaveBlock& aMPBOnIn,
const BOPCol_DataMapOfIntegerListOfInteger& aDMBV,
const TColStd_DataMapOfIntegerListOfInteger& aDMBV,
BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& aMSCPB,
BOPCol_DataMapOfShapeInteger& aMVI,
TopTools_DataMapOfShapeInteger& aMVI,
BOPDS_MapOfPaveBlock& aMPB)
{
if (aDMBV.IsEmpty()) {
@ -2202,8 +2201,8 @@ void BOPAlgo_PaveFiller::ProcessExistingPaveBlocks
//
Standard_Real aT, dummy;
Standard_Integer i, nV, nE, iC, aNbPB, iFlag;
BOPCol_ListIteratorOfListOfInteger aItLI;
BOPCol_DataMapIteratorOfDataMapOfIntegerListOfInteger aItBV;
TColStd_ListIteratorOfListOfInteger aItLI;
TColStd_DataMapIteratorOfDataMapOfIntegerListOfInteger aItBV;
//
BOPDS_VectorOfInterfFF& aFFs = myDS->InterfFF();
BOPDS_InterfFF& aFF = aFFs(theInt);
@ -2214,7 +2213,7 @@ void BOPAlgo_PaveFiller::ProcessExistingPaveBlocks
aItBV.Initialize(aDMBV);
for (; aItBV.More(); aItBV.Next()) {
iC = aItBV.Key();
const BOPCol_ListOfInteger& aLBV = aItBV.Value();
const TColStd_ListOfInteger& aLBV = aItBV.Value();
//
BOPDS_Curve& aNC = aVC.ChangeValue(iC);
BOPDS_ListOfPaveBlock& aLPBC = aNC.ChangePaveBlocks();
@ -2319,7 +2318,7 @@ void BOPAlgo_PaveFiller::UpdateExistingPaveBlocks
if (bCB) {
// Create new common blocks
BOPDS_ListOfPaveBlock aLPBNew;
const BOPCol_ListOfInteger& aFaces = aCB1->Faces();
const TColStd_ListOfInteger& aFaces = aCB1->Faces();
aIt.Initialize(aLPB);
for (; aIt.More(); aIt.Next()) {
const Handle(BOPDS_PaveBlock)& aPBValue = aIt.Value();
@ -2542,7 +2541,7 @@ void BOPAlgo_PaveFiller::PreparePostTreatFF
const Standard_Integer aCur,
const Handle(BOPDS_PaveBlock)& aPB,
BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& aMSCPB,
BOPCol_DataMapOfShapeInteger& aMVI,
TopTools_DataMapOfShapeInteger& aMVI,
BOPDS_ListOfPaveBlock& aLPBC)
{
Standard_Integer nV1, nV2;
@ -2574,19 +2573,19 @@ Standard_Boolean BOPAlgo_PaveFiller::CheckPlanes
{
Standard_Boolean bToIntersect;
Standard_Integer i, nV2, iCnt;
BOPCol_MapIteratorOfMapOfInteger aIt;
TColStd_MapIteratorOfMapOfInteger aIt;
//
bToIntersect=Standard_False;
//
const BOPDS_FaceInfo& aFI1=myDS->ChangeFaceInfo(nF1);
const BOPDS_FaceInfo& aFI2=myDS->ChangeFaceInfo(nF2);
//
const BOPCol_MapOfInteger& aMVIn1=aFI1.VerticesIn();
const BOPCol_MapOfInteger& aMVOn1=aFI1.VerticesOn();
const TColStd_MapOfInteger& aMVIn1=aFI1.VerticesIn();
const TColStd_MapOfInteger& aMVOn1=aFI1.VerticesOn();
//
iCnt=0;
for (i=0; (i<2 && !bToIntersect); ++i) {
const BOPCol_MapOfInteger& aMV2=(!i) ? aFI2.VerticesIn()
const TColStd_MapOfInteger& aMV2=(!i) ? aFI2.VerticesIn()
: aFI2.VerticesOn();
//
aIt.Initialize(aMV2);
@ -2609,7 +2608,7 @@ Standard_Boolean BOPAlgo_PaveFiller::CheckPlanes
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::UpdatePaveBlocks
(const BOPCol_DataMapOfIntegerInteger& aDMNewSD)
(const TColStd_DataMapOfIntegerInteger& aDMNewSD)
{
if (aDMNewSD.IsEmpty()) {
return;
@ -2620,18 +2619,18 @@ void BOPAlgo_PaveFiller::UpdatePaveBlocks
Standard_Boolean bCB, bRebuild;
BOPDS_ListIteratorOfListOfPaveBlock aItPB;
BOPDS_MapOfPaveBlock aMPB;
BOPCol_MapOfInteger aMicroEdges;
TColStd_MapOfInteger aMicroEdges;
//
BOPDS_ListOfPaveBlock anAllPBs;
// Get pave blocks of section edges
BOPDS_VectorOfInterfFF& aFFs = myDS->InterfFF();
Standard_Integer aNbFF = aFFs.Extent();
Standard_Integer aNbFF = aFFs.Length();
for (i = 0; i < aNbFF; ++i)
{
const BOPDS_InterfFF& aFF = aFFs(i);
const BOPDS_VectorOfCurve& aVNC = aFF.Curves();
Standard_Integer aNbC = aVNC.Extent();
Standard_Integer aNbC = aVNC.Length();
for (j = 0; j < aNbC; ++j)
{
const BOPDS_Curve& aNC = aVNC(j);
@ -2644,7 +2643,7 @@ void BOPAlgo_PaveFiller::UpdatePaveBlocks
// Get pave blocks from the pool
BOPDS_VectorOfListOfPaveBlock& aPBP = myDS->ChangePaveBlocksPool();
aNbPBP = aPBP.Extent();
aNbPBP = aPBP.Length();
for (i = 0; i < aNbPBP; ++i) {
BOPDS_ListOfPaveBlock& aLPB = aPBP(i);
aItPB.Initialize(aLPB);
@ -2726,13 +2725,13 @@ void BOPAlgo_PaveFiller::UpdatePaveBlocks
//function : RemovePaveBlocks
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::RemovePaveBlocks(const BOPCol_MapOfInteger theEdges)
void BOPAlgo_PaveFiller::RemovePaveBlocks(const TColStd_MapOfInteger theEdges)
{
// Remove all pave blocks referring to input edges:
//
// 1. from the Pave Blocks Pool
BOPDS_VectorOfListOfPaveBlock& aPBP = myDS->ChangePaveBlocksPool();
Standard_Integer aNbPBP = aPBP.Extent(), i;
Standard_Integer aNbPBP = aPBP.Length(), i;
for (i = 0; i < aNbPBP; ++i) {
BOPDS_ListOfPaveBlock& aLPB = aPBP(i);
//
@ -2747,9 +2746,9 @@ void BOPAlgo_PaveFiller::RemovePaveBlocks(const BOPCol_MapOfInteger theEdges)
}
// 2. from Face Info and section curves
BOPCol_MapOfInteger aMPassed;
TColStd_MapOfInteger aMPassed;
BOPDS_VectorOfInterfFF& aFFs = myDS->InterfFF();
Standard_Integer aNbFF = aFFs.Extent(), j;
Standard_Integer aNbFF = aFFs.Length(), j;
for (i = 0; i < aNbFF; ++i) {
BOPDS_InterfFF& aFF = aFFs(i);
Standard_Integer nF1, nF2;
@ -2783,7 +2782,7 @@ void BOPAlgo_PaveFiller::RemovePaveBlocks(const BOPCol_MapOfInteger theEdges)
}
// remove from Section pave blocks
BOPDS_VectorOfCurve& aVNC = aFF.ChangeCurves();
Standard_Integer aNbC = aVNC.Extent();
Standard_Integer aNbC = aVNC.Length();
for (j = 0; j < aNbC; ++j) {
BOPDS_Curve& aNC = aVNC(j);
BOPDS_ListOfPaveBlock& aLPB = aNC.ChangePaveBlocks();
@ -2841,7 +2840,7 @@ void BOPAlgo_PaveFiller::UpdateBlocksWithSharedVertices()
Standard_Integer aNbFF;
//
BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
aNbFF=aFFs.Extent();
aNbFF=aFFs.Length();
if (!aNbFF) {
return;
}
@ -2849,13 +2848,13 @@ void BOPAlgo_PaveFiller::UpdateBlocksWithSharedVertices()
Standard_Boolean bOnCurve, bHasShapeSD;
Standard_Integer i, nF1, nF2, aNbC, j, nV, nVSD;
Standard_Real aTolV;
BOPCol_MapOfInteger aMF;
TColStd_MapOfInteger aMF;
//
for (i=0; i<aNbFF; ++i) {
BOPDS_InterfFF& aFF=aFFs(i);
//
BOPDS_VectorOfCurve& aVC=aFF.ChangeCurves();
aNbC=aVC.Extent();
aNbC=aVC.Length();
if (!aNbC) {
continue;
}
@ -2870,19 +2869,19 @@ void BOPAlgo_PaveFiller::UpdateBlocksWithSharedVertices()
}
//
// Collect old vertices that are shared for nF1, nF2 ->aMI;
BOPCol_MapOfInteger aMI;
BOPCol_MapIteratorOfMapOfInteger aItMI;
TColStd_MapOfInteger aMI;
TColStd_MapIteratorOfMapOfInteger aItMI;
//
BOPDS_FaceInfo& aFI1=myDS->ChangeFaceInfo(nF1);
BOPDS_FaceInfo& aFI2=myDS->ChangeFaceInfo(nF2);
//
const BOPCol_MapOfInteger& aMVOn1=aFI1.VerticesOn();
const BOPCol_MapOfInteger& aMVIn1=aFI1.VerticesIn();
const BOPCol_MapOfInteger& aMVOn2=aFI2.VerticesOn();
const BOPCol_MapOfInteger& aMVIn2=aFI2.VerticesIn();
const TColStd_MapOfInteger& aMVOn1=aFI1.VerticesOn();
const TColStd_MapOfInteger& aMVIn1=aFI1.VerticesIn();
const TColStd_MapOfInteger& aMVOn2=aFI2.VerticesOn();
const TColStd_MapOfInteger& aMVIn2=aFI2.VerticesIn();
//
for (j=0; j<2; ++j) {
const BOPCol_MapOfInteger& aMV1=(!j) ? aMVOn1 : aMVIn1;
const TColStd_MapOfInteger& aMV1=(!j) ? aMVOn1 : aMVIn1;
aItMI.Initialize(aMV1);
for (; aItMI.More(); aItMI.Next()) {
nV=aItMI.Value();
@ -2951,17 +2950,17 @@ void BOPAlgo_PaveFiller::CorrectToleranceOfSE()
{
BOPDS_VectorOfInterfFF& aFFs = myDS->InterfFF();
NCollection_IndexedDataMap<Standard_Integer,BOPDS_ListOfPaveBlock> aMVIPBs;
BOPCol_MapOfInteger aMVIToReduce;
TColStd_MapOfInteger aMVIToReduce;
// Fence map to avoid repeated checking of the same edge
BOPDS_MapOfPaveBlock aMPB;
//
// 1. iterate on all sections F-F
Standard_Integer aNb = aFFs.Extent(), i;
Standard_Integer aNb = aFFs.Length(), i;
for (i = 0; i < aNb; ++i) {
BOPDS_InterfFF& aFF = aFFs(i);
//
BOPDS_VectorOfCurve& aVNC = aFF.ChangeCurves();
Standard_Integer aNbC = aVNC.Extent(), k;
Standard_Integer aNbC = aVNC.Length(), k;
for (k = 0; k < aNbC; ++k) {
BOPDS_Curve& aNC = aVNC(k);
BOPDS_ListOfPaveBlock& aLPB = aNC.ChangePaveBlocks();
@ -3029,9 +3028,9 @@ void BOPAlgo_PaveFiller::CorrectToleranceOfSE()
// reducing the tolerance to the value less than the tolerances of edges,
// i.e. minimal tolerance for the vertex is the max tolerance of the
// edges containing this vertex
BOPCol_DataMapOfIntegerReal aMVITol;
TColStd_DataMapOfIntegerReal aMVITol;
BOPDS_VectorOfListOfPaveBlock& aPBP = myDS->ChangePaveBlocksPool();
aNb = aPBP.Extent();
aNb = aPBP.Length();
for (i = 0; i < aNb; ++i) {
const BOPDS_ListOfPaveBlock& aLPB = aPBP(i);
BOPDS_ListIteratorOfListOfPaveBlock aItLPB(aLPB);
@ -3130,11 +3129,11 @@ void BOPAlgo_PaveFiller::PutSEInOtherFaces()
BOPDS_IndexedMapOfPaveBlock aMPBScAll;
//
BOPDS_VectorOfInterfFF& aFFs = myDS->InterfFF();
Standard_Integer i, j, aNbFF = aFFs.Extent();
Standard_Integer i, j, aNbFF = aFFs.Length();
//
for (i = 0; i < aNbFF; ++i) {
const BOPDS_VectorOfCurve& aVNC = aFFs(i).Curves();
Standard_Integer aNbC = aVNC.Extent();
Standard_Integer aNbC = aVNC.Length();
for (j = 0; j < aNbC; ++j) {
const BOPDS_ListOfPaveBlock& aLPBC = aVNC(j).PaveBlocks();
BOPDS_ListIteratorOfListOfPaveBlock aItPB(aLPBC);
@ -3164,7 +3163,7 @@ void BOPAlgo_PaveFiller::PutSEInOtherFaces()
//
// Get vertices of the face to check that vertices of the
// processed section edge belong to the face
BOPCol_MapOfInteger aMFVerts;
TColStd_MapOfInteger aMFVerts;
// Get vertices from ON, IN and Sc pave blocks of the face
for (j = 0; j < 3; ++j) {
const BOPDS_IndexedMapOfPaveBlock& aMPB =
@ -3178,9 +3177,9 @@ void BOPAlgo_PaveFiller::PutSEInOtherFaces()
}
// Add ON, IN and Sc vertices of the face
for (j = 0; j < 3; ++j) {
const BOPCol_MapOfInteger& aMFV = !j ? aFI.VerticesOn() :
const TColStd_MapOfInteger& aMFV = !j ? aFI.VerticesOn() :
(j == 1 ? aFI.VerticesIn() : aFI.VerticesSc());
BOPCol_MapIteratorOfMapOfInteger aItMI(aMFV);
TColStd_MapIteratorOfMapOfInteger aItMI(aMFV);
for (; aItMI.More(); aItMI.Next()) {
aMFVerts.Add(aItMI.Value());
}

52
src/BOPAlgo/BOPAlgo_PaveFiller_7.cxx
View File

@ -19,9 +19,6 @@
#include <BOPAlgo_Alerts.hxx>
#include <BOPAlgo_SectionAttribute.hxx>
#include <BOPAlgo_Tools.hxx>
#include <BOPCol_IndexedMapOfShape.hxx>
#include <BOPCol_NCVector.hxx>
#include <BOPCol_Parallel.hxx>
#include <BOPDS_CommonBlock.hxx>
#include <BOPDS_Curve.hxx>
#include <BOPDS_DS.hxx>
@ -40,6 +37,7 @@
#include <BOPDS_VectorOfListOfPaveBlock.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_AlgoTools2D.hxx>
#include <BOPTools_Parallel.hxx>
#include <BRepLib.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
@ -54,12 +52,14 @@
#include <gp_Pnt.hxx>
#include <IntTools_Context.hxx>
#include <IntTools_Tools.hxx>
#include <NCollection_Vector.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
static
@ -168,16 +168,16 @@ class BOPAlgo_SplitEdge : public BOPAlgo_Algo {
};
//
//=======================================================================
typedef BOPCol_NCVector
typedef NCollection_Vector
<BOPAlgo_SplitEdge> BOPAlgo_VectorOfSplitEdge;
//
typedef BOPCol_ContextFunctor
typedef BOPTools_ContextFunctor
<BOPAlgo_SplitEdge,
BOPAlgo_VectorOfSplitEdge,
Handle(IntTools_Context),
IntTools_Context> BOPAlgo_SplitEdgeFunctor;
//
typedef BOPCol_ContextCnt
typedef BOPTools_ContextCnt
<BOPAlgo_SplitEdgeFunctor,
BOPAlgo_VectorOfSplitEdge,
Handle(IntTools_Context)> BOPAlgo_SplitEdgeCnt;
@ -332,16 +332,16 @@ class BOPAlgo_MPC : public BOPAlgo_Algo {
};
//
//=======================================================================
typedef BOPCol_NCVector
typedef NCollection_Vector
<BOPAlgo_MPC> BOPAlgo_VectorOfMPC;
//
typedef BOPCol_ContextFunctor
typedef BOPTools_ContextFunctor
<BOPAlgo_MPC,
BOPAlgo_VectorOfMPC,
Handle(IntTools_Context),
IntTools_Context> BOPAlgo_MPCFunctor;
//
typedef BOPCol_ContextCnt
typedef BOPTools_ContextCnt
<BOPAlgo_MPCFunctor,
BOPAlgo_VectorOfMPC,
Handle(IntTools_Context)> BOPAlgo_MPCCnt;
@ -390,14 +390,14 @@ class BOPAlgo_BPC {
Standard_Boolean myToUpdate;
};
//=======================================================================
typedef BOPCol_NCVector
typedef NCollection_Vector
<BOPAlgo_BPC> BOPAlgo_VectorOfBPC;
//
typedef BOPCol_Functor
typedef BOPTools_Functor
<BOPAlgo_BPC,
BOPAlgo_VectorOfBPC> BOPAlgo_BPCFunctor;
//
typedef BOPCol_Cnt
typedef BOPTools_Cnt
<BOPAlgo_BPCFunctor,
BOPAlgo_VectorOfBPC> BOPAlgo_BPCCnt;
//
@ -409,7 +409,7 @@ typedef BOPCol_Cnt
void BOPAlgo_PaveFiller::MakeSplitEdges()
{
BOPDS_VectorOfListOfPaveBlock& aPBP=myDS->ChangePaveBlocksPool();
Standard_Integer aNbPBP = aPBP.Extent();
Standard_Integer aNbPBP = aPBP.Length();
if(!aNbPBP) {
return;
}
@ -427,7 +427,7 @@ void BOPAlgo_PaveFiller::MakeSplitEdges()
//
UpdateCommonBlocksWithSDVertices();
//
aNbPBP=aPBP.Extent();
aNbPBP=aPBP.Length();
//
for (i=0; i<aNbPBP; ++i) {
BOPDS_ListOfPaveBlock& aLPB=aPBP(i);
@ -490,7 +490,7 @@ void BOPAlgo_PaveFiller::MakeSplitEdges()
aV2=(*(TopoDS_Vertex *)(&myDS->Shape(nV2)));
aV2.Orientation(TopAbs_REVERSED);
//
BOPAlgo_SplitEdge& aBSE=aVBSE.Append1();
BOPAlgo_SplitEdge& aBSE=aVBSE.Appended();
//
aBSE.SetData(aE, aV1, aT1, aV2, aT2);
aBSE.SetPaveBlock(aPB);
@ -503,7 +503,7 @@ void BOPAlgo_PaveFiller::MakeSplitEdges()
} // for (; aItPB.More(); aItPB.Next()) {
} // for (i=0; i<aNbPBP; ++i) {
//
aNbVBSE=aVBSE.Extent();
aNbVBSE=aVBSE.Length();
//======================================================
BOPAlgo_SplitEdgeCnt::Perform(myRunParallel, aVBSE, myContext);
//======================================================
@ -592,7 +592,7 @@ void BOPAlgo_PaveFiller::MakePCurves()
// 1. Process Common Blocks
const BOPDS_VectorOfFaceInfo& aFIP=myDS->FaceInfoPool();
//
aNbFI=aFIP.Extent();
aNbFI=aFIP.Length();
for (i=0; i<aNbFI; ++i) {
const BOPDS_FaceInfo& aFI=aFIP(i);
nF1=aFI.Index();
@ -607,7 +607,7 @@ void BOPAlgo_PaveFiller::MakePCurves()
nE=aPB->Edge();
const TopoDS_Edge& aE=(*(TopoDS_Edge *)(&myDS->Shape(nE)));
//
BOPAlgo_MPC& aMPC=aVMPC.Append1();
BOPAlgo_MPC& aMPC=aVMPC.Appended();
aMPC.SetEdge(aE);
aMPC.SetFace(aF1F);
aMPC.SetProgressIndicator(myProgressIndicator);
@ -635,7 +635,7 @@ void BOPAlgo_PaveFiller::MakePCurves()
continue;
}
//
BOPAlgo_MPC& aMPC=aVMPC.Append1();
BOPAlgo_MPC& aMPC=aVMPC.Appended();
//
aItLPB.Initialize(aLPB);
for(; aItLPB.More(); aItLPB.Next()) {
@ -689,11 +689,11 @@ void BOPAlgo_PaveFiller::MakePCurves()
// container to remember already added edge-face pairs
BOPDS_MapOfPair anEFPairs;
BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
aNbFF=aFFs.Extent();
aNbFF=aFFs.Length();
for (i=0; i<aNbFF; ++i) {
const BOPDS_InterfFF& aFF=aFFs(i);
const BOPDS_VectorOfCurve& aVNC = aFF.Curves();
aNbC = aVNC.Extent();
aNbC = aVNC.Length();
if (aNbC == 0)
continue;
Standard_Integer nF[2];
@ -721,7 +721,7 @@ void BOPAlgo_PaveFiller::MakePCurves()
{
if (bPCurveOnS[m] && anEFPairs.Add(BOPDS_Pair(nE, nF[m])))
{
BOPAlgo_MPC& aMPC = aVMPC.Append1();
BOPAlgo_MPC& aMPC = aVMPC.Appended();
aMPC.SetEdge(aE);
aMPC.SetFace(aFf[m]);
aMPC.SetFlag(Standard_True);
@ -738,7 +738,7 @@ void BOPAlgo_PaveFiller::MakePCurves()
//======================================================
// Add warnings of the failed projections and update edges with new pcurves
Standard_Integer aNb = aVMPC.Extent();
Standard_Integer aNb = aVMPC.Length();
for (i = 0; i < aNb; ++i)
{
const BOPAlgo_MPC& aMPC = aVMPC(i);
@ -821,7 +821,7 @@ void BOPAlgo_PaveFiller::Prepare()
Standard_Boolean bIsBasedOnPlane;
Standard_Integer i, aNb, n1, nF, aNbF;
TopExp_Explorer aExp;
BOPCol_IndexedMapOfShape aMF;
TopTools_IndexedMapOfShape aMF;
//
aNb=3;
for(i=0; i<aNb; ++i) {
@ -850,7 +850,7 @@ void BOPAlgo_PaveFiller::Prepare()
aExp.Init(aF, aType[1]);
for (; aExp.More(); aExp.Next()) {
const TopoDS_Edge& aE=*((TopoDS_Edge *)&aExp.Current());
BOPAlgo_BPC& aBPC=aVBPC.Append1();
BOPAlgo_BPC& aBPC=aVBPC.Appended();
aBPC.SetEdge(aE);
aBPC.SetFace(aF);
}
@ -863,7 +863,7 @@ void BOPAlgo_PaveFiller::Prepare()
// pcurves are built, and now update edges
BRep_Builder aBB;
TopoDS_Edge E;
for (i = 0; i < aVBPC.Extent(); i++) {
for (i = 0; i < aVBPC.Length(); i++) {
const BOPAlgo_BPC& aBPC=aVBPC(i);
if (aBPC.IsToUpdate()) {
Standard_Real aTolE = BRep_Tool::Tolerance(aBPC.GetEdge());

4
src/BOPAlgo/BOPAlgo_PaveFiller_8.cxx
View File

@ -17,7 +17,6 @@
#include <BOPAlgo_PaveFiller.hxx>
#include <BOPAlgo_SectionAttribute.hxx>
#include <BOPCol_ListOfInteger.hxx>
#include <BOPDS_Curve.hxx>
#include <BOPDS_DS.hxx>
#include <BOPDS_FaceInfo.hxx>
@ -40,6 +39,7 @@
#include <IntRes2d_IntersectionPoint.hxx>
#include <IntTools_Context.hxx>
#include <Precision.hxx>
#include <TColStd_ListOfInteger.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Vertex.hxx>
@ -67,7 +67,7 @@ void BOPAlgo_PaveFiller::ProcessDE()
Standard_Integer nF, aNb, nE, nV, nVSD, aNbPB;
Handle(NCollection_BaseAllocator) aAllocator;
Handle(BOPDS_PaveBlock) aPBD;
BOPCol_ListIteratorOfListOfInteger aItLI;
TColStd_ListIteratorOfListOfInteger aItLI;
//
// 1. Find degnerated edges
//-----------------------------------------------------scope f

18
src/BOPAlgo/BOPAlgo_PaveFiller_9.cxx
View File

@ -16,18 +16,18 @@
#include <Bnd_Box.hxx>
#include <BOPAlgo_PaveFiller.hxx>
#include <BOPAlgo_SectionAttribute.hxx>
#include <BOPCol_MapOfInteger.hxx>
#include <BOPCol_NCVector.hxx>
#include <BOPCol_Parallel.hxx>
#include <BOPDS_Curve.hxx>
#include <BOPDS_DS.hxx>
#include <BOPDS_Iterator.hxx>
#include <BOPDS_ListOfPaveBlock.hxx>
#include <BOPDS_PaveBlock.hxx>
#include <BOPDS_ShapeInfo.hxx>
#include <BOPTools_Parallel.hxx>
#include <gp_Pnt.hxx>
#include <IntTools_Context.hxx>
#include <IntTools_ShrunkRange.hxx>
#include <NCollection_Vector.hxx>
#include <TColStd_MapOfInteger.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Vertex.hxx>
@ -63,16 +63,16 @@ class BOPAlgo_ShrunkRange : public IntTools_ShrunkRange {
};
//
//=======================================================================
typedef BOPCol_NCVector
typedef NCollection_Vector
<BOPAlgo_ShrunkRange> BOPAlgo_VectorOfShrunkRange;
//
typedef BOPCol_ContextFunctor
typedef BOPTools_ContextFunctor
<BOPAlgo_ShrunkRange,
BOPAlgo_VectorOfShrunkRange,
Handle(IntTools_Context),
IntTools_Context> BOPAlgo_ShrunkRangeFunctor;
//
typedef BOPCol_ContextCnt
typedef BOPTools_ContextCnt
<BOPAlgo_ShrunkRangeFunctor,
BOPAlgo_VectorOfShrunkRange,
Handle(IntTools_Context)> BOPAlgo_ShrunkRangeCnt;
@ -93,7 +93,7 @@ void BOPAlgo_PaveFiller::FillShrunkData(const TopAbs_ShapeEnum aType1,
Standard_Integer i, nS[2], nE, nV1, nV2, aNbVSD, k;
Standard_Real aT1, aT2;
BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
BOPCol_MapOfInteger aMI;
TColStd_MapOfInteger aMI;
BOPAlgo_VectorOfShrunkRange aVSD;
TopAbs_ShapeEnum aType[2] = { aType1, aType2 };
//
@ -131,7 +131,7 @@ void BOPAlgo_PaveFiller::FillShrunkData(const TopAbs_ShapeEnum aType1,
const TopoDS_Vertex& aV2=
(*(TopoDS_Vertex *)(&myDS->Shape(nV2)));
//
BOPAlgo_ShrunkRange& aSD=aVSD.Append1();
BOPAlgo_ShrunkRange& aSD=aVSD.Appended();
//
aSD.SetPaveBlock(aPB);
aSD.SetData(aE, aT1, aT2, aV1, aV2);
@ -139,7 +139,7 @@ void BOPAlgo_PaveFiller::FillShrunkData(const TopAbs_ShapeEnum aType1,
}
}
//
aNbVSD=aVSD.Extent();
aNbVSD=aVSD.Length();
//=============================================================
BOPAlgo_ShrunkRangeCnt::Perform(myRunParallel, aVSD, myContext);
//=============================================================

56
src/BOPAlgo/BOPAlgo_Section.cxx
View File

@ -13,15 +13,10 @@
// commercial license or contractual agreement.
#include <BOPAlgo_BuilderSolid.hxx>
#include <BOPAlgo_PaveFiller.hxx>
#include <BOPAlgo_Section.hxx>
#include <BOPAlgo_Alerts.hxx>
#include <BOPCol_DataMapOfShapeShape.hxx>
#include <BOPCol_IndexedDataMapOfShapeListOfShape.hxx>
#include <BOPCol_IndexedMapOfShape.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <BOPAlgo_BuilderSolid.hxx>
#include <BOPAlgo_PaveFiller.hxx>
#include <BOPDS_CommonBlock.hxx>
#include <BOPDS_DS.hxx>
#include <BOPDS_FaceInfo.hxx>
@ -30,20 +25,23 @@
#include <BOPDS_PaveBlock.hxx>
#include <BOPDS_VectorOfFaceInfo.hxx>
#include <BOPDS_VectorOfListOfPaveBlock.hxx>
#include <BOPTools.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_AlgoTools3D.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS_Compound.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Iterator.hxx>
#include <TopoDS_Shape.hxx>
#include <TopTools_DataMapOfShapeShape.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
//
//
//=======================================================================
//function :
//purpose :
@ -158,12 +156,14 @@ void BOPAlgo_Section::BuildSection()
TopoDS_Shape aRC, aRC1;
BRep_Builder aBB;
TopExp_Explorer aExp;
BOPCol_ListOfShape aLSA, aLS;
BOPCol_ListIteratorOfListOfShape aIt, aItIm, aItLS;
BOPCol_IndexedDataMapOfShapeInteger aMSI(100, myAllocator);
BOPCol_IndexedMapOfShape aMS(100, myAllocator);
BOPCol_MapOfShape aMFence(100, myAllocator);
BOPCol_MapIteratorOfMapOfInteger aItMI;
TopTools_ListOfShape aLSA, aLS;
TopTools_ListIteratorOfListOfShape aIt, aItIm, aItLS;
NCollection_IndexedDataMap<TopoDS_Shape,
Standard_Integer,
TopTools_ShapeMapHasher> aMSI(100, myAllocator);
TopTools_IndexedMapOfShape aMS(100, myAllocator);
TopTools_MapOfShape aMFence(100, myAllocator);
TColStd_MapIteratorOfMapOfInteger aItMI;
BOPDS_ListIteratorOfListOfPaveBlock aItPB;
//
GetReport()->Clear();
@ -181,7 +181,7 @@ void BOPAlgo_Section::BuildSection()
const BOPDS_FaceInfo& aFI=myDS->FaceInfo(i);
//
// 1.1 Vertices that are section vertices
const BOPCol_MapOfInteger& aMVSc=aFI.VerticesSc();
const TColStd_MapOfInteger& aMVSc=aFI.VerticesSc();
aItMI.Initialize(aMVSc);
for(; aItMI.More(); aItMI.Next()) {
nV=aItMI.Key();
@ -190,7 +190,7 @@ void BOPAlgo_Section::BuildSection()
}
//
// 1.2 Vertices that are in a face
const BOPCol_MapOfInteger& aMI=aFI.VerticesIn();
const TColStd_MapOfInteger& aMI=aFI.VerticesIn();
aItMI.Initialize(aMI);
for(; aItMI.More(); aItMI.Next()) {
nV=aItMI.Key();
@ -226,7 +226,7 @@ void BOPAlgo_Section::BuildSection()
const Handle(BOPDS_PaveBlock)& aPB=aItPB.Value();
Handle(BOPDS_CommonBlock) aCB=myDS->CommonBlock(aPB);
if (!aCB.IsNull()) {
const BOPCol_ListOfInteger& aLF=aCB->Faces();
const TColStd_ListOfInteger& aLF=aCB->Faces();
aNbF=aLF.Extent();
if (aNbF) {
const Handle(BOPDS_PaveBlock)& aPBR=aCB->PaveBlock1();
@ -280,17 +280,17 @@ void BOPAlgo_Section::BuildSection()
const TopoDS_Shape& aS=aItLS.Value();
//
if (myImages.IsBound(aS)){
const BOPCol_ListOfShape& aLSIm=myImages.Find(aS);
const TopTools_ListOfShape& aLSIm=myImages.Find(aS);
aItIm.Initialize(aLSIm);
for (; aItIm.More(); aItIm.Next()) {
const TopoDS_Shape& aSIm=aItIm.Value();
BOPTools::MapShapes(aSIm, TopAbs_VERTEX, aMS);
BOPTools::MapShapes(aSIm, TopAbs_EDGE , aMS);
TopExp::MapShapes(aSIm, TopAbs_VERTEX, aMS);
TopExp::MapShapes(aSIm, TopAbs_EDGE , aMS);
}
}// if (myImages.IsBound(aF)){
else {
BOPTools::MapShapes(aS, TopAbs_VERTEX, aMS);
BOPTools::MapShapes(aS, TopAbs_EDGE , aMS);
TopExp::MapShapes(aS, TopAbs_VERTEX, aMS);
TopExp::MapShapes(aS, TopAbs_EDGE , aMS);
}
}//for (; aItLS.More(); aItLS.Next()) {
//
@ -311,9 +311,9 @@ void BOPAlgo_Section::BuildSection()
aMFence.Clear();
//
// 4. Build the result
BOPCol_IndexedDataMapOfShapeListOfShape aMVE(100, myAllocator);
TopTools_IndexedDataMapOfShapeListOfShape aMVE(100, myAllocator);
//
BOPTools::MapShapesAndAncestors(aRC1,
TopExp::MapShapesAndAncestors(aRC1,
TopAbs_VERTEX,
TopAbs_EDGE,
aMVE);
@ -323,7 +323,7 @@ void BOPAlgo_Section::BuildSection()
const TopoDS_Shape& aV=aMSI.FindKey(i);
const Standard_Integer& iCnt=aMSI.FindFromIndex(i);
if (iCnt>1) {
BOPTools::MapShapesAndAncestors(aV,
TopExp::MapShapesAndAncestors(aV,
TopAbs_VERTEX,
TopAbs_EDGE,
aMVE);
@ -335,7 +335,7 @@ void BOPAlgo_Section::BuildSection()
aNbMS=aMVE.Extent();
for (i=1; i<=aNbMS; ++i) {
const TopoDS_Shape& aV=aMVE.FindKey(i);
const BOPCol_ListOfShape& aLE=aMVE.FindFromIndex(i);
const TopTools_ListOfShape& aLE=aMVE.FindFromIndex(i);
aNbLE=aLE.Extent();
if (!aNbLE) {
// alone vertices

4
src/BOPAlgo/BOPAlgo_Section.hxx
View File

@ -20,7 +20,7 @@
#include <Standard_Handle.hxx>
#include <BOPAlgo_Builder.hxx>
#include <BOPCol_BaseAllocator.hxx>
#include <NCollection_BaseAllocator.hxx>
#include <TopTools_ListOfShape.hxx>
class BOPAlgo_PaveFiller;
class TopoDS_Shape;
@ -47,7 +47,7 @@ public:
//! Empty constructor
//!
//! protected methods
Standard_EXPORT BOPAlgo_Section(const BOPCol_BaseAllocator& theAllocator);
Standard_EXPORT BOPAlgo_Section(const Handle(NCollection_BaseAllocator)& theAllocator);
Standard_EXPORT virtual void BuildSection();

104
src/BOPAlgo/BOPAlgo_ShellSplitter.cxx
View File

@ -16,32 +16,32 @@
// Created: Thu Jan 16 08:33:50 2014
#include <BOPAlgo_ShellSplitter.hxx>
#include <BOPCol_IndexedDataMapOfShapeListOfShape.hxx>
#include <BOPCol_IndexedMapOfShape.hxx>
#include <BOPCol_MapOfOrientedShape.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <BOPCol_NCVector.hxx>
#include <BOPCol_Parallel.hxx>
#include <BOPTools.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_CoupleOfShape.hxx>
#include <BOPTools_Parallel.hxx>
#include <BRep_Builder.hxx>
#include <IntTools_Context.hxx>
#include <NCollection_Vector.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Shell.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopTools_MapOfOrientedShape.hxx>
#include <TopTools_MapOfShape.hxx>
//
static
void MakeShell(const BOPCol_ListOfShape& ,
void MakeShell(const TopTools_ListOfShape& ,
TopoDS_Shell& );
//
static
void RefineShell(TopoDS_Shell& theShell,
const BOPCol_IndexedDataMapOfShapeListOfShape& theMEF,
BOPCol_ListOfShape& aLShX);
const TopTools_IndexedDataMapOfShapeListOfShape& theMEF,
TopTools_ListOfShape& aLShX);
//=======================================================================
//class : BOPAlgo_CBK
@ -71,14 +71,14 @@ class BOPAlgo_CBK {
BOPTools_ConnexityBlock *myPCB;
};
//=======================================================================
typedef BOPCol_NCVector
typedef NCollection_Vector
<BOPAlgo_CBK> BOPAlgo_VectorOfCBK;
//
typedef BOPCol_Functor
typedef BOPTools_Functor
<BOPAlgo_CBK,
BOPAlgo_VectorOfCBK> BOPAlgo_CBKFunctor;
//
typedef BOPCol_Cnt
typedef BOPTools_Cnt
<BOPAlgo_CBKFunctor,
BOPAlgo_VectorOfCBK> BOPAlgo_CBKCnt;
//
@ -126,7 +126,7 @@ void BOPAlgo_ShellSplitter::AddStartElement(const TopoDS_Shape& aE)
//function : StartElements
//purpose :
//=======================================================================
const BOPCol_ListOfShape& BOPAlgo_ShellSplitter::StartElements()const
const TopTools_ListOfShape& BOPAlgo_ShellSplitter::StartElements()const
{
return myStartShapes;
}
@ -134,7 +134,7 @@ const BOPCol_ListOfShape& BOPAlgo_ShellSplitter::StartElements()const
//function : Loops
//purpose :
//=======================================================================
const BOPCol_ListOfShape& BOPAlgo_ShellSplitter::Shells()const
const TopTools_ListOfShape& BOPAlgo_ShellSplitter::Shells()const
{
return myShells;
}
@ -165,21 +165,21 @@ void BOPAlgo_ShellSplitter::SplitBlock(BOPTools_ConnexityBlock& aCB)
BRep_Builder aBB;
TopoDS_Iterator aItS;
TopExp_Explorer aExp;
BOPCol_ListIteratorOfListOfShape aItF;
TopTools_ListIteratorOfListOfShape aItF;
BOPTools_CoupleOfShape aCSOff;
BOPCol_MapOfOrientedShape AddedFacesMap;
BOPCol_IndexedDataMapOfShapeListOfShape aEFMap, aMEFP;
TopTools_MapOfOrientedShape AddedFacesMap;
TopTools_IndexedDataMapOfShapeListOfShape aEFMap, aMEFP;
Handle (IntTools_Context) aContext;
//
aContext=new IntTools_Context;
//
const BOPCol_ListOfShape& myShapes=aCB.Shapes();
const TopTools_ListOfShape& myShapes=aCB.Shapes();
//
BOPCol_ListOfShape& myLoops=aCB.ChangeLoops();
TopTools_ListOfShape& myLoops=aCB.ChangeLoops();
myLoops.Clear();
//
// Copy faces into the map, for recursive search of free bounds
BOPCol_MapOfOrientedShape aMFaces;
TopTools_MapOfOrientedShape aMFaces;
aItF.Initialize (myShapes);
for (; aItF.More(); aItF.Next()) {
aMFaces.Add(aItF.Value());
@ -193,7 +193,7 @@ void BOPAlgo_ShellSplitter::SplitBlock(BOPTools_ConnexityBlock& aCB)
for (; aItF.More(); aItF.Next()) {
const TopoDS_Shape& aF = aItF.Value();
if (aMFaces.Contains(aF)) {
BOPTools::MapShapesAndAncestors (aF, TopAbs_EDGE, TopAbs_FACE, aEFMap);
TopExp::MapShapesAndAncestors (aF, TopAbs_EDGE, TopAbs_FACE, aEFMap);
}
}
//
@ -203,7 +203,7 @@ void BOPAlgo_ShellSplitter::SplitBlock(BOPTools_ConnexityBlock& aCB)
for (i = 1; i <= aNbE; ++i) {
const TopoDS_Edge& aE = TopoDS::Edge(aEFMap.FindKey(i));
if (!(BRep_Tool::Degenerated(aE) || aE.Orientation() == TopAbs_INTERNAL)) {
const BOPCol_ListOfShape& aLF = aEFMap(i);
const TopTools_ListOfShape& aLF = aEFMap(i);
if (aLF.Extent() == 1) {
// remove the face
aMFaces.Remove(aLF.First());
@ -223,7 +223,7 @@ void BOPAlgo_ShellSplitter::SplitBlock(BOPTools_ConnexityBlock& aCB)
}
//
// use only connected faces
BOPCol_ListOfShape aLFConnected;
TopTools_ListOfShape aLFConnected;
aItF.Initialize (myShapes);
for (; aItF.More(); aItF.Next()) {
const TopoDS_Shape& aF = aItF.Value();
@ -248,15 +248,15 @@ void BOPAlgo_ShellSplitter::SplitBlock(BOPTools_ConnexityBlock& aCB)
aBB.MakeShell(aShellStart);
aBB.Add(aShellStart, aFF);
//
BOPCol_ListOfShape aLShells;
TopTools_ListOfShape aLShells;
aLShells.Append(aShellStart);
//
BOPCol_ListIteratorOfListOfShape aItLShells(aLShells);
TopTools_ListIteratorOfListOfShape aItLShells(aLShells);
for (; aItLShells.More(); aItLShells.Next()) {
TopoDS_Shell& aShell = TopoDS::Shell(aItLShells.ChangeValue());
//
aMEFP.Clear();
BOPTools::MapShapesAndAncestors(aShell, TopAbs_EDGE, TopAbs_FACE, aMEFP);
TopExp::MapShapesAndAncestors(aShell, TopAbs_EDGE, TopAbs_FACE, aMEFP);
//
// loop on faces added to Shell;
// add their neighbor faces to Shell and so on
@ -271,7 +271,7 @@ void BOPAlgo_ShellSplitter::SplitBlock(BOPTools_ConnexityBlock& aCB)
//
// proceed only free edges in this shell
if (aMEFP.Contains(aE)) {
const BOPCol_ListOfShape& aLFP = aMEFP.FindFromKey(aE);
const TopTools_ListOfShape& aLFP = aMEFP.FindFromKey(aE);
aNbFP = aLFP.Extent();
if (aNbFP > 1) {
continue;
@ -288,7 +288,7 @@ void BOPAlgo_ShellSplitter::SplitBlock(BOPTools_ConnexityBlock& aCB)
}
//
// candidate faces list
const BOPCol_ListOfShape& aLF = aEFMap.FindFromKey(aE);
const TopTools_ListOfShape& aLF = aEFMap.FindFromKey(aE);
aNbLF = aLF.Extent();
if (!aNbLF) {
continue;
@ -298,7 +298,7 @@ void BOPAlgo_ShellSplitter::SplitBlock(BOPTools_ConnexityBlock& aCB)
// take only not-processed faces as a candidates
BOPTools_ListOfCoupleOfShape aLCSOff;
//
BOPCol_ListIteratorOfListOfShape aItLF(aLF);
TopTools_ListIteratorOfListOfShape aItLF(aLF);
for (; aItLF.More(); aItLF.Next()) {
const TopoDS_Face& aFL = (*(TopoDS_Face*)(&aItLF.Value()));
if (aF.IsSame(aFL) || AddedFacesMap.Contains(aFL)) {
@ -332,19 +332,19 @@ void BOPAlgo_ShellSplitter::SplitBlock(BOPTools_ConnexityBlock& aCB)
//
if (!aSelF.IsNull() && AddedFacesMap.Add(aSelF)) {
aBB.Add(aShell, aSelF);
BOPTools::MapShapesAndAncestors(aSelF, TopAbs_EDGE, TopAbs_FACE, aMEFP);
TopExp::MapShapesAndAncestors(aSelF, TopAbs_EDGE, TopAbs_FACE, aMEFP);
}
} // for (; aExp.More(); aExp.Next()) {
} // for (; aItS.More(); aItS.Next()) {
//
// split the shell on multi-connected edges
BOPCol_ListOfShape aLShSp;
TopTools_ListOfShape aLShSp;
RefineShell(aShell, aMEFP, aLShSp);
//
// collect the not closed shells for further processing
BOPCol_ListOfShape aLShNC;
TopTools_ListOfShape aLShNC;
//
BOPCol_ListIteratorOfListOfShape aItLShSp(aLShSp);
TopTools_ListIteratorOfListOfShape aItLShSp(aLShSp);
for (; aItLShSp.More(); aItLShSp.Next()) {
TopoDS_Shell& aShSp = *((TopoDS_Shell*)&aItLShSp.Value());
//
@ -377,7 +377,7 @@ void BOPAlgo_ShellSplitter::SplitBlock(BOPTools_ConnexityBlock& aCB)
// remove th faces of not closed shells from the map of processed faces
// and try to rebuild the shells using all not processed faces,
// because faces of one shell might be needed for building the other
BOPCol_ListIteratorOfListOfShape aItLShNC(aLShNC);
TopTools_ListIteratorOfListOfShape aItLShNC(aLShNC);
for (; aItLShNC.More(); aItLShNC.Next()) {
TopoDS_Iterator aItNC(aItLShNC.Value());
for (; aItNC.More(); aItNC.Next()) {
@ -393,8 +393,8 @@ void BOPAlgo_ShellSplitter::SplitBlock(BOPTools_ConnexityBlock& aCB)
//purpose :
//=======================================================================
void RefineShell(TopoDS_Shell& theShell,
const BOPCol_IndexedDataMapOfShapeListOfShape& theMEF,
BOPCol_ListOfShape& theLShSp)
const TopTools_IndexedDataMapOfShapeListOfShape& theMEF,
TopTools_ListOfShape& theLShSp)
{
TopoDS_Iterator aIt(theShell);
if(!aIt.More()) {
@ -403,12 +403,12 @@ void RefineShell(TopoDS_Shell& theShell,
//
// Find edges with more than 2 adjacent faces - branch edges -
// edges on which the input shell should be split
BOPCol_MapOfShape aMEStop;
TopTools_MapOfShape aMEStop;
//
Standard_Integer i, aNbMEF = theMEF.Extent();
for (i = 1; i <= aNbMEF; ++i) {
const TopoDS_Edge& aE = TopoDS::Edge(theMEF.FindKey(i));
const BOPCol_ListOfShape& aLF = theMEF(i);
const TopTools_ListOfShape& aLF = theMEF(i);
if (aLF.Extent() > 2) {
aMEStop.Add(aE);
continue;
@ -417,7 +417,7 @@ void RefineShell(TopoDS_Shell& theShell,
// check for internal edges - count faces, in which the edge
// is internal, twice
Standard_Integer aNbF = 0;
BOPCol_ListIteratorOfListOfShape aItLF(aLF);
TopTools_ListIteratorOfListOfShape aItLF(aLF);
for (; aItLF.More() && aNbF <= 2; aItLF.Next()) {
const TopoDS_Face& aF = TopoDS::Face(aItLF.Value());
++aNbF;
@ -445,10 +445,10 @@ void RefineShell(TopoDS_Shell& theShell,
//
TopoDS_Builder aBB;
TopExp_Explorer aExp;
BOPCol_IndexedMapOfShape aMFB;
BOPCol_MapOfOrientedShape aMFProcessed;
BOPCol_ListOfShape aLFP, aLFP1;
BOPCol_ListIteratorOfListOfShape aItLF, aItLFP;
TopTools_IndexedMapOfShape aMFB;
TopTools_MapOfOrientedShape aMFProcessed;
TopTools_ListOfShape aLFP, aLFP1;
TopTools_ListIteratorOfListOfShape aItLF, aItLFP;
//
// The first Face
for (; aIt.More(); aIt.Next()) {
@ -484,7 +484,7 @@ void RefineShell(TopoDS_Shell& theShell,
continue;
}
//
const BOPCol_ListOfShape& aLF = theMEF.FindFromKey(aE);
const TopTools_ListOfShape& aLF = theMEF.FindFromKey(aE);
//
aItLF.Initialize(aLF);
for (; aItLF.More(); aItLF.Next()) {
@ -535,7 +535,7 @@ void BOPAlgo_ShellSplitter::MakeShells()
Standard_Boolean bIsRegular;
Standard_Integer aNbVCBK, k;
BOPTools_ListIteratorOfListOfConnexityBlock aItCB;
BOPCol_ListIteratorOfListOfShape aIt;
TopTools_ListIteratorOfListOfShape aIt;
BOPAlgo_VectorOfCBK aVCBK;
//
myShells.Clear();
@ -547,25 +547,25 @@ void BOPAlgo_ShellSplitter::MakeShells()
if (bIsRegular) {
TopoDS_Shell aShell;
//
const BOPCol_ListOfShape& aLF=aCB.Shapes();
const TopTools_ListOfShape& aLF=aCB.Shapes();
MakeShell(aLF, aShell);
aShell.Closed(Standard_True);
myShells.Append(aShell);
}
else {
BOPAlgo_CBK& aCBK=aVCBK.Append1();
BOPAlgo_CBK& aCBK=aVCBK.Appended();
aCBK.SetConnexityBlock(aCB);
}
}
//
aNbVCBK=aVCBK.Extent();
aNbVCBK=aVCBK.Length();
//===================================================
BOPAlgo_CBKCnt::Perform(myRunParallel, aVCBK);
//===================================================
for (k=0; k<aNbVCBK; ++k) {
BOPAlgo_CBK& aCBK=aVCBK(k);
const BOPTools_ConnexityBlock& aCB=aCBK.ConnexityBlock();
const BOPCol_ListOfShape& aLS=aCB.Loops();
const TopTools_ListOfShape& aLS=aCB.Loops();
aIt.Initialize(aLS);
for (; aIt.More(); aIt.Next()) {
TopoDS_Shape& aShell=aIt.ChangeValue();
@ -578,11 +578,11 @@ void BOPAlgo_ShellSplitter::MakeShells()
//function : MakeShell
//purpose :
//=======================================================================
void MakeShell(const BOPCol_ListOfShape& aLS,
void MakeShell(const TopTools_ListOfShape& aLS,
TopoDS_Shell& aShell)
{
BRep_Builder aBB;
BOPCol_ListIteratorOfListOfShape aIt;
TopTools_ListIteratorOfListOfShape aIt;
//
aBB.MakeShell(aShell);
//

14
src/BOPAlgo/BOPAlgo_ShellSplitter.hxx
View File

@ -19,11 +19,11 @@
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPTools_ListOfConnexityBlock.hxx>
#include <BOPAlgo_Algo.hxx>
#include <BOPCol_BaseAllocator.hxx>
#include <BOPTools_ConnexityBlock.hxx>
#include <NCollection_BaseAllocator.hxx>
#include <TopTools_ListOfShape.hxx>
class TopoDS_Shape;
@ -42,19 +42,19 @@ public:
Standard_EXPORT virtual ~BOPAlgo_ShellSplitter();
//! constructor
Standard_EXPORT BOPAlgo_ShellSplitter(const BOPCol_BaseAllocator& theAllocator);
Standard_EXPORT BOPAlgo_ShellSplitter(const Handle(NCollection_BaseAllocator)& theAllocator);
//! adds a face <theS> to process
Standard_EXPORT void AddStartElement (const TopoDS_Shape& theS);
//! return the faces to process
Standard_EXPORT const BOPCol_ListOfShape& StartElements() const;
Standard_EXPORT const TopTools_ListOfShape& StartElements() const;
//! performs the algorithm
Standard_EXPORT virtual void Perform() Standard_OVERRIDE;
//! returns the loops
Standard_EXPORT const BOPCol_ListOfShape& Shells() const;
Standard_EXPORT const TopTools_ListOfShape& Shells() const;
Standard_EXPORT static void SplitBlock (BOPTools_ConnexityBlock& theCB);
@ -64,8 +64,8 @@ protected:
Standard_EXPORT void MakeShells();
BOPCol_ListOfShape myStartShapes;
BOPCol_ListOfShape myShells;
TopTools_ListOfShape myStartShapes;
TopTools_ListOfShape myShells;
BOPTools_ListOfConnexityBlock myLCB;
private:

4
src/BOPAlgo/BOPAlgo_Splitter.cxx
View File

@ -72,9 +72,9 @@ void BOPAlgo_Splitter::Perform()
}
//
// prepare shapes for intersection
BOPCol_ListOfShape aLS;
TopTools_ListOfShape aLS;
//
BOPCol_ListIteratorOfListOfShape aItLS(myArguments);
TopTools_ListIteratorOfListOfShape aItLS(myArguments);
for (; aItLS.More(); aItLS.Next()) {
aLS.Append(aItLS.Value());
}

2
src/BOPAlgo/BOPAlgo_Splitter.hxx
View File

@ -57,7 +57,7 @@ public:
Standard_EXPORT BOPAlgo_Splitter();
Standard_EXPORT virtual ~BOPAlgo_Splitter();
Standard_EXPORT BOPAlgo_Splitter(const BOPCol_BaseAllocator& theAllocator);
Standard_EXPORT BOPAlgo_Splitter(const Handle(NCollection_BaseAllocator)& theAllocator);
//! Performs the operation
Standard_EXPORT virtual void Perform() Standard_OVERRIDE;

330
src/BOPAlgo/BOPAlgo_Tools.cxx
View File

@ -15,62 +15,48 @@
#include <BOPAlgo_Tools.hxx>
#include <gp_Pnt.hxx>
#include <gp_Vec.hxx>
#include <gp_Dir.hxx>
#include <gp_Pln.hxx>
#include <gp_Circ.hxx>
#include <gp_Elips.hxx>
#include <gp_Hypr.hxx>
#include <gp_Parab.hxx>
#include <Standard_ErrorHandler.hxx>
#include <Standard_Failure.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <BOPCol_BoxBndTree.hxx>
#include <BOPCol_IndexedMapOfShape.hxx>
#include <BOPCol_IndexedMapOfInteger.hxx>
#include <BOPCol_IndexedDataMapOfShapeListOfShape.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <BOPCol_NCVector.hxx>
#include <BOPCol_Parallel.hxx>
#include <TopExp_Explorer.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepBuilderAPI_MakeFace.hxx>
#include <BRepLib.hxx>
#include <BRep_Tool.hxx>
#include <BRep_Builder.hxx>
#include <BRepBndLib.hxx>
#include <GeomAPI_ProjectPointOnCurve.hxx>
#include <GeomAPI_ProjectPointOnSurf.hxx>
#include <BOPAlgo_Builder.hxx>
#include <BOPAlgo_BuilderFace.hxx>
#include <BOPDS_CommonBlock.hxx>
#include <BOPDS_DataMapOfPaveBlockListOfPaveBlock.hxx>
#include <BOPDS_DS.hxx>
#include <BOPDS_IndexedMapOfPaveBlock.hxx>
#include <BOPDS_MapOfPaveBlock.hxx>
#include <BOPDS_PaveBlock.hxx>
#include <BOPTools.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_AlgoTools2D.hxx>
#include <NCollection_UBTreeFiller.hxx>
#include <NCollection_IncAllocator.hxx>
#include <BOPTools_BoxBndTree.hxx>
#include <BOPTools_Parallel.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepBndLib.hxx>
#include <BRepBuilderAPI_MakeFace.hxx>
#include <BRepLib.hxx>
#include <GeomAPI_ProjectPointOnCurve.hxx>
#include <GeomAPI_ProjectPointOnSurf.hxx>
#include <gp_Circ.hxx>
#include <gp_Dir.hxx>
#include <gp_Elips.hxx>
#include <gp_Hypr.hxx>
#include <gp_Parab.hxx>
#include <gp_Pln.hxx>
#include <gp_Pnt.hxx>
#include <gp_Vec.hxx>
#include <IntTools_Context.hxx>
#include <NCollection_IncAllocator.hxx>
#include <NCollection_UBTreeFiller.hxx>
#include <NCollection_Vector.hxx>
#include <Standard_ErrorHandler.hxx>
#include <Standard_Failure.hxx>
#include <TColStd_IndexedMapOfInteger.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
#include <algorithm>
@ -80,11 +66,11 @@ typedef NCollection_IndexedDataMap
<TopoDS_Shape, gp_Pln, TopTools_ShapeMapHasher> BOPAlgo_IndexedDataMapOfShapePln;
static
void MakeWires(const BOPCol_IndexedMapOfShape& theEdges,
void MakeWires(const TopTools_IndexedMapOfShape& theEdges,
TopoDS_Compound& theWires,
const Standard_Boolean theCheckUniquePlane,
BOPAlgo_IndexedDataMapOfShapeDir& theDMEdgeTgt,
BOPCol_MapOfShape& theMEdgesNoUniquePlane);
TopTools_MapOfShape& theMEdgesNoUniquePlane);
static
Standard_Boolean FindPlane(const BRepAdaptor_Curve& theCurve,
@ -94,7 +80,7 @@ static
Standard_Boolean FindPlane(const TopoDS_Shape& theWire,
gp_Pln& thePlane,
BOPAlgo_IndexedDataMapOfShapeDir& theDMEdgeTgt,
BOPCol_MapOfShape& theMEdgesNoUniquePlane);
TopTools_MapOfShape& theMEdgesNoUniquePlane);
static
Standard_Boolean FindEdgeTangent(const TopoDS_Edge& theEdge,
@ -114,9 +100,9 @@ void BOPAlgo_Tools::FillMap(const Handle(BOPDS_PaveBlock)& aPB,
BOPDS_IndexedDataMapOfPaveBlockListOfInteger& aMPBLI,
const Handle(NCollection_BaseAllocator)& aAllocator)
{
BOPCol_ListOfInteger *pLI = aMPBLI.ChangeSeek(aPB);
TColStd_ListOfInteger *pLI = aMPBLI.ChangeSeek(aPB);
if (!pLI) {
pLI = &aMPBLI(aMPBLI.Add(aPB, BOPCol_ListOfInteger(aAllocator)));
pLI = &aMPBLI(aMPBLI.Add(aPB, TColStd_ListOfInteger(aAllocator)));
}
pLI->Append(nF);
}
@ -153,9 +139,9 @@ void BOPAlgo_Tools::PerformCommonBlocks(BOPDS_IndexedDataMapOfPaveBlockListOfPav
// New common block
Handle(BOPDS_CommonBlock) aCB;
// Faces of the common block
BOPCol_ListOfInteger aLFaces;
TColStd_ListOfInteger aLFaces;
// Fence map to avoid duplicates in the list of faces of the common block
BOPCol_MapOfInteger aMFaces(1, anAllocTmp);
TColStd_MapOfInteger aMFaces(1, anAllocTmp);
BOPDS_ListIteratorOfListOfPaveBlock aItLPB(aLPB);
for (; aItLPB.More(); aItLPB.Next())
@ -165,7 +151,7 @@ void BOPAlgo_Tools::PerformCommonBlocks(BOPDS_IndexedDataMapOfPaveBlockListOfPav
{
const Handle(BOPDS_CommonBlock)& aCBx = pDS->CommonBlock(aPB);
// Move all faces to the new common block
BOPCol_ListIteratorOfListOfInteger aItLF(aCBx->Faces());
TColStd_ListIteratorOfListOfInteger aItLF(aCBx->Faces());
for (; aItLF.More(); aItLF.Next())
{
const Standard_Integer nF = aItLF.Value();
@ -196,7 +182,7 @@ void BOPAlgo_Tools::PerformCommonBlocks(const BOPDS_IndexedDataMapOfPaveBlockLis
BOPDS_PDS& pDS)
{
Standard_Integer nF, i, aNb;
BOPCol_ListIteratorOfListOfInteger aItLI;
TColStd_ListIteratorOfListOfInteger aItLI;
Handle(BOPDS_PaveBlock) aPB;
Handle(BOPDS_CommonBlock) aCB;
//
@ -211,15 +197,15 @@ void BOPAlgo_Tools::PerformCommonBlocks(const BOPDS_IndexedDataMapOfPaveBlockLis
aCB->AddPaveBlock(aPB);
}
//
const BOPCol_ListOfInteger& aLI=aMPBLI.FindFromKey(aPB);
BOPCol_ListOfInteger aNewFaces;
const BOPCol_ListOfInteger& anOldFaces = aCB->Faces();
const TColStd_ListOfInteger& aLI=aMPBLI.FindFromKey(aPB);
TColStd_ListOfInteger aNewFaces;
const TColStd_ListOfInteger& anOldFaces = aCB->Faces();
aItLI.Initialize(aLI);
for (; aItLI.More(); aItLI.Next()) {
nF=aItLI.Value();
// the both lists aLI and anOldFaces are expected to be short,
// so we can allow to run nested loop here
BOPCol_ListIteratorOfListOfInteger it(anOldFaces);
TColStd_ListIteratorOfListOfInteger it(anOldFaces);
for (; it.More(); it.Next()) {
if (it.Value() == nF)
break;
@ -252,7 +238,7 @@ Standard_Real BOPAlgo_Tools::ComputeToleranceOfCB
aTolMax = BRep_Tool::Tolerance(aEOr);
//
const BOPDS_ListOfPaveBlock& aLPB = theCB->PaveBlocks();
const BOPCol_ListOfInteger& aLFI = theCB->Faces();
const TColStd_ListOfInteger& aLFI = theCB->Faces();
//
if ((aLPB.Extent() < 2) && aLFI.IsEmpty()) {
return aTolMax;
@ -305,7 +291,7 @@ Standard_Real BOPAlgo_Tools::ComputeToleranceOfCB
if (aLFI.Extent()) {
Standard_Integer nF;
GeomAPI_ProjectPointOnSurf aProjPS;
BOPCol_ListIteratorOfListOfInteger aItLI;
TColStd_ListIteratorOfListOfInteger aItLI;
//
aItLI.Initialize(aLFI);
for (; aItLI.More(); aItLI.Next()) {
@ -347,7 +333,7 @@ Standard_Integer BOPAlgo_Tools::EdgesToWires(const TopoDS_Shape& theEdges,
// 1. Check the input edges
//
// List of edges to process
BOPCol_ListOfShape aLE;
TopTools_ListOfShape aLE;
//
TopExp_Explorer aExp(theEdges, TopAbs_EDGE);
for (; aExp.More(); aExp.Next()) {
@ -394,7 +380,7 @@ Standard_Integer BOPAlgo_Tools::EdgesToWires(const TopoDS_Shape& theEdges,
}
else {
aBB.MakeCompound(TopoDS::Compound(aSEdges));
BOPCol_ListIteratorOfListOfShape aItLE(aLE);
TopTools_ListIteratorOfListOfShape aItLE(aLE);
for (; aItLE.More(); aItLE.Next()) {
aBB.Add(aSEdges, aItLE.Value());
}
@ -410,7 +396,7 @@ Standard_Integer BOPAlgo_Tools::EdgesToWires(const TopoDS_Shape& theEdges,
BOPAlgo_IndexedDataMapOfShapeDir aDMEdgeTgt;
//
// edges for which the plane is not found
BOPCol_MapOfShape aMEdgesNoUniquePlane;
TopTools_MapOfShape aMEdgesNoUniquePlane;
//
// edges for which the plane cannot be found on a single edge
TopoDS_Compound aLEdges;
@ -442,7 +428,7 @@ Standard_Integer BOPAlgo_Tools::EdgesToWires(const TopoDS_Shape& theEdges,
BOPAlgo_ListOfDir aLPFence;
//
// used edges
BOPCol_MapOfShape aMEFence;
TopTools_MapOfShape aMEFence;
//
// look for a planes on the single edges
Standard_Integer i, j, aNbPlanes = aDMEdgePln.Extent(), aNbEdges = aDMEdgeTgt.Extent();
@ -457,11 +443,11 @@ Standard_Integer BOPAlgo_Tools::EdgesToWires(const TopoDS_Shape& theEdges,
//
aLPFence.Append(aDI);
//
BOPCol_IndexedMapOfShape aMEPln;
TopTools_IndexedMapOfShape aMEPln;
aMEPln.Add(aEI);
//
BOPCol_IndexedMapOfShape aMV;
BOPTools::MapShapes(aEI, TopAbs_VERTEX, aMV);
TopTools_IndexedMapOfShape aMV;
TopExp::MapShapes(aEI, TopAbs_VERTEX, aMV);
//
// look for other edges with the plane parallel to current one
for (j = i + 1; j <= aNbPlanes; ++j) {
@ -470,7 +456,7 @@ Standard_Integer BOPAlgo_Tools::EdgesToWires(const TopoDS_Shape& theEdges,
const TopoDS_Shape& aEJ = aDMEdgePln.FindKey(j);
aMEPln.Add(aEJ);
aMEFence.Add(aEJ);
BOPTools::MapShapes(aEJ, TopAbs_VERTEX, aMV);
TopExp::MapShapes(aEJ, TopAbs_VERTEX, aMV);
}
}
//
@ -487,11 +473,11 @@ Standard_Integer BOPAlgo_Tools::EdgesToWires(const TopoDS_Shape& theEdges,
//
// make blocks of these edges and check blocks to be connected
// to any of the already added edges or forming a wire themselves
BOPCol_ListOfShape aLCBE;
TopTools_ListOfShape aLCBE;
BOPTools_AlgoTools::MakeConnexityBlocks(aCEPln, TopAbs_VERTEX, TopAbs_EDGE, aLCBE);
//
// make wire from each block
BOPCol_ListIteratorOfListOfShape aItLCB(aLCBE);
TopTools_ListIteratorOfListOfShape aItLCB(aLCBE);
for (; aItLCB.More(); aItLCB.Next()) {
const TopoDS_Shape& aCBE = aItLCB.Value();
//
@ -522,23 +508,23 @@ Standard_Integer BOPAlgo_Tools::EdgesToWires(const TopoDS_Shape& theEdges,
}
//
// make connection map from vertices to edges to find the connected pairs
BOPCol_IndexedDataMapOfShapeListOfShape aDMVE;
BOPTools::MapShapesAndAncestors(aLEdges, TopAbs_VERTEX, TopAbs_EDGE, aDMVE);
TopTools_IndexedDataMapOfShapeListOfShape aDMVE;
TopExp::MapShapesAndAncestors(aLEdges, TopAbs_VERTEX, TopAbs_EDGE, aDMVE);
//
// find planes for connected edges
Standard_Integer aNbV = aDMVE.Extent();
for (i = 1; i <= aNbV; ++i) {
const BOPCol_ListOfShape& aLEI = aDMVE(i);
const TopTools_ListOfShape& aLEI = aDMVE(i);
if (aLEI.Extent() < 2) {
continue;
}
//
BOPCol_ListIteratorOfListOfShape aItLEI1(aLEI);
TopTools_ListIteratorOfListOfShape aItLEI1(aLEI);
for (; aItLEI1.More(); aItLEI1.Next()) {
const TopoDS_Shape& aEI1 = aItLEI1.Value();
const gp_Dir& aDI1 = aDMEdgeTgt.FindFromKey(aEI1);
//
BOPCol_ListIteratorOfListOfShape aItLEI2(aLEI);
TopTools_ListIteratorOfListOfShape aItLEI2(aLEI);
for (; aItLEI2.More(); aItLEI2.Next()) {
const TopoDS_Shape& aEI2 = aItLEI2.Value();
if (aEI2.IsSame(aEI1)) {
@ -567,7 +553,7 @@ Standard_Integer BOPAlgo_Tools::EdgesToWires(const TopoDS_Shape& theEdges,
aLPFence.Append(aDNI);
//
// find all other edges in the plane parallel to current one
BOPCol_IndexedMapOfShape aMEPln;
TopTools_IndexedMapOfShape aMEPln;
aMEPln.Add(aEI1);
aMEPln.Add(aEI2);
//
@ -585,8 +571,8 @@ Standard_Integer BOPAlgo_Tools::EdgesToWires(const TopoDS_Shape& theEdges,
} // for (i = 1; i < aNb; ++i) {
//
// 4. Find unused edges and make wires from them
BOPCol_IndexedMapOfShape aMEAlone, aMEUsed;
BOPTools::MapShapes(aRWires, TopAbs_EDGE, aMEUsed);
TopTools_IndexedMapOfShape aMEAlone, aMEUsed;
TopExp::MapShapes(aRWires, TopAbs_EDGE, aMEUsed);
//
for (i = 1; i <= aNbEdges; ++i) {
const TopoDS_Shape& aE = aDMEdgeTgt.FindKey(i);
@ -611,7 +597,7 @@ Standard_Boolean BOPAlgo_Tools::WiresToFaces(const TopoDS_Shape& theWires,
const Standard_Real theAngTol)
{
BRep_Builder aBB;
BOPCol_MapOfShape aMFence;
TopTools_MapOfShape aMFence;
TopoDS_Compound aRFaces;
aBB.MakeCompound(aRFaces);
//
@ -624,7 +610,7 @@ Standard_Boolean BOPAlgo_Tools::WiresToFaces(const TopoDS_Shape& theWires,
// map to store the tolerance for the wire
NCollection_DataMap<TopoDS_Shape, Standard_Real, TopTools_ShapeMapHasher> aDMWireTol;
// edges for which the plane is not found
BOPCol_MapOfShape aMEdgesNoUniquePlane;
TopTools_MapOfShape aMEdgesNoUniquePlane;
//
// Find planes for the wires
TopExp_Explorer aExpW(theWires, TopAbs_WIRE);
@ -647,7 +633,7 @@ Standard_Boolean BOPAlgo_Tools::WiresToFaces(const TopoDS_Shape& theWires,
//
const gp_Pln& aPlnI = aDMWirePln(i);
//
BOPCol_ListOfShape aLW;
TopTools_ListOfShape aLW;
aLW.Append(aWireI);
aMFence.Add(aWireI);
//
@ -678,8 +664,8 @@ Standard_Boolean BOPAlgo_Tools::WiresToFaces(const TopoDS_Shape& theWires,
}
//
// Take the edges to build the face
BOPCol_ListOfShape aLE;
BOPCol_ListIteratorOfListOfShape aItLW(aLW);
TopTools_ListOfShape aLE;
TopTools_ListIteratorOfListOfShape aItLW(aLW);
for (; aItLW.More(); aItLW.Next()) {
TopoDS_Iterator aItE(aItLW.Value());
for (; aItE.More(); aItE.Next()) {
@ -708,8 +694,8 @@ Standard_Boolean BOPAlgo_Tools::WiresToFaces(const TopoDS_Shape& theWires,
continue;
}
//
const BOPCol_ListOfShape& aLFSp = aBF.Areas();
BOPCol_ListIteratorOfListOfShape aItLF(aLFSp);
const TopTools_ListOfShape& aLFSp = aBF.Areas();
TopTools_ListIteratorOfListOfShape aItLF(aLFSp);
for (; aItLF.More(); aItLF.Next()) {
const TopoDS_Shape& aFSp = aItLF.ChangeValue();
aBB.Add(aRFaces, aFSp);
@ -721,7 +707,7 @@ Standard_Boolean BOPAlgo_Tools::WiresToFaces(const TopoDS_Shape& theWires,
}
//
// fix tolerances of the resulting faces
BOPCol_IndexedMapOfShape aMEmpty;
TopTools_IndexedMapOfShape aMEmpty;
BOPTools_AlgoTools::CorrectTolerances(aRFaces, aMEmpty, 0.05, Standard_False);
BOPTools_AlgoTools::CorrectShapeTolerances(aRFaces, aMEmpty, Standard_False);
//
@ -734,11 +720,11 @@ Standard_Boolean BOPAlgo_Tools::WiresToFaces(const TopoDS_Shape& theWires,
//function : MakeWires
//purpose : Makes wires from the separate blocks of the given edges
//=======================================================================
void MakeWires(const BOPCol_IndexedMapOfShape& theEdges,
void MakeWires(const TopTools_IndexedMapOfShape& theEdges,
TopoDS_Compound& theWires,
const Standard_Boolean theCheckUniquePlane,
BOPAlgo_IndexedDataMapOfShapeDir& theDMEdgeTgt,
BOPCol_MapOfShape& theMEdgesNoUniquePlane)
TopTools_MapOfShape& theMEdgesNoUniquePlane)
{
TopoDS_Compound aCE;
BRep_Builder().MakeCompound(aCE);
@ -747,11 +733,11 @@ void MakeWires(const BOPCol_IndexedMapOfShape& theEdges,
BRep_Builder().Add(aCE, theEdges(i));
}
//
BOPCol_ListOfShape aLCBE;
TopTools_ListOfShape aLCBE;
BOPTools_AlgoTools::MakeConnexityBlocks(aCE, TopAbs_VERTEX, TopAbs_EDGE, aLCBE);
//
// make wire from each block
BOPCol_ListIteratorOfListOfShape aItLCB(aLCBE);
TopTools_ListIteratorOfListOfShape aItLCB(aLCBE);
for (; aItLCB.More(); aItLCB.Next()) {
const TopoDS_Shape& aCBE = aItLCB.Value();
//
@ -894,7 +880,7 @@ Standard_Boolean FindPlane(const BRepAdaptor_Curve& theCurve,
Standard_Boolean FindPlane(const TopoDS_Shape& theWire,
gp_Pln& thePlane,
BOPAlgo_IndexedDataMapOfShapeDir& theDMEdgeTgt,
BOPCol_MapOfShape& theMEdgesNoUniquePlane)
TopTools_MapOfShape& theMEdgesNoUniquePlane)
{
TopExp_Explorer aExpE1(theWire, TopAbs_EDGE);
if (!aExpE1.More()) {
@ -960,21 +946,21 @@ Standard_Boolean FindPlane(const TopoDS_Shape& theWire,
//purpose :
//=======================================================================
class BOPAlgo_TNV;
typedef BOPCol_NCVector
typedef NCollection_Vector
<BOPAlgo_TNV> BOPAlgo_VectorOfTNV;
//
typedef BOPCol_Functor
typedef BOPTools_Functor
<BOPAlgo_TNV,
BOPAlgo_VectorOfTNV> BOPAlgo_TNVFunctor;
//
typedef BOPCol_Cnt
typedef BOPTools_Cnt
<BOPAlgo_TNVFunctor,
BOPAlgo_VectorOfTNV> BOPAlgo_TNVCnt;
//=======================================================================
class BOPAlgo_TNV : public BOPCol_BoxBndTreeSelector{
class BOPAlgo_TNV : public BOPTools_BoxBndTreeSelector{
public:
BOPAlgo_TNV()
: BOPCol_BoxBndTreeSelector(),
: BOPTools_BoxBndTreeSelector(),
myTol (0.), myFuzzyValue(0.), myTree(NULL), myVecTNV(NULL) {
};
//
@ -990,7 +976,7 @@ class BOPAlgo_TNV : public BOPCol_BoxBndTreeSelector{
return myV;
}
//
void SetTree(BOPCol_BoxBndTree& aTree) {
void SetTree(BOPTools_BoxBndTree& aTree) {
myTree=&aTree;
}
//
@ -1021,7 +1007,7 @@ class BOPAlgo_TNV : public BOPCol_BoxBndTreeSelector{
aTolSum2 *= aTolSum2;
Standard_Real aD2 = myPnt.SquareDistance(aTNV.Pnt());
if (aD2 < aTolSum2)
return BOPCol_BoxBndTreeSelector::Accept(theIndex);
return BOPTools_BoxBndTreeSelector::Accept(theIndex);
return Standard_False;
}
//
@ -1034,7 +1020,7 @@ class BOPAlgo_TNV : public BOPCol_BoxBndTreeSelector{
Standard_Real myFuzzyValue;
gp_Pnt myPnt;
TopoDS_Vertex myV;
BOPCol_BoxBndTree *myTree;
BOPTools_BoxBndTree *myTree;
const BOPAlgo_VectorOfTNV *myVecTNV;
};
//
@ -1044,21 +1030,21 @@ class BOPAlgo_TNV : public BOPCol_BoxBndTreeSelector{
//function : IntersectVertices
//purpose : Builds the chains of intersecting vertices
//=======================================================================
void BOPAlgo_Tools::IntersectVertices(const BOPCol_IndexedDataMapOfShapeReal& theVertices,
void BOPAlgo_Tools::IntersectVertices(const TopTools_IndexedDataMapOfShapeReal& theVertices,
const Standard_Boolean theRunParallel,
const Standard_Real theFuzzyValue,
BOPCol_ListOfListOfShape& theChains)
TopTools_ListOfListOfShape& theChains)
{
Standard_Integer i, j, aNbV = theVertices.Extent();
if (aNbV <= 1) {
if (aNbV == 1) {
theChains.Append(BOPCol_ListOfShape()).Append(theVertices.FindKey(1));
theChains.Append(TopTools_ListOfShape()).Append(theVertices.FindKey(1));
}
return;
}
//
// Use unbalanced binary tree of bounding boxes for sorting of the vertices.
BOPCol_BoxBndTree aBBTree;
BOPTools_BoxBndTree aBBTree;
NCollection_UBTreeFiller <Standard_Integer,
Bnd_Box> aTreeFiller(aBBTree);
// Perform intersection of the vertices
@ -1080,7 +1066,7 @@ void BOPAlgo_Tools::IntersectVertices(const BOPCol_IndexedDataMapOfShapeReal& th
//
aTreeFiller.Add(i, aBox);
//
BOPAlgo_TNV& aTNV=aVTNV.Append1();
BOPAlgo_TNV& aTNV=aVTNV.Appended();
aTNV.SetTree(aBBTree);
aTNV.SetBox(aBox);
aTNV.SetVertex(aV);
@ -1095,21 +1081,21 @@ void BOPAlgo_Tools::IntersectVertices(const BOPCol_IndexedDataMapOfShapeReal& th
BOPAlgo_TNVCnt::Perform(theRunParallel, aVTNV);
//
// Fence map
BOPCol_MapOfInteger aMFence;
TColStd_MapOfInteger aMFence;
// Build chains of intersecting vertices
for (i = 1; i <= aNbV; ++i) {
if (!aMFence.Add(i)) {
continue;
}
// Start the chain
BOPCol_IndexedMapOfInteger aMChain;
TColStd_IndexedMapOfInteger aMChain;
aMChain.Add(i);
//
for (j = 1; j <= aMChain.Extent(); ++j) {
BOPAlgo_TNV& aTNV = aVTNV(aMChain(j) - 1);
const BOPCol_ListOfInteger& aLI = aTNV.Indices();
const TColStd_ListOfInteger& aLI = aTNV.Indices();
// Add these vertices into the chain
for (BOPCol_ListIteratorOfListOfInteger aItLI(aLI); aItLI.More(); aItLI.Next()) {
for (TColStd_ListIteratorOfListOfInteger aItLI(aLI); aItLI.More(); aItLI.Next()) {
if (aMFence.Add(aItLI.Value())) {
aMChain.Add(aItLI.Value());
}
@ -1117,7 +1103,7 @@ void BOPAlgo_Tools::IntersectVertices(const BOPCol_IndexedDataMapOfShapeReal& th
}
//
// Put vertices of the chain into the list
BOPCol_ListOfShape& aChain = theChains.Append(BOPCol_ListOfShape());
TopTools_ListOfShape& aChain = theChains.Append(TopTools_ListOfShape());
//
Standard_Integer aNbVChain = aMChain.Extent();
for (j = 1; j <= aNbVChain; ++j) {
@ -1132,8 +1118,8 @@ void BOPAlgo_Tools::IntersectVertices(const BOPCol_IndexedDataMapOfShapeReal& th
//purpose :
//=======================================================================
void BOPAlgo_Tools::TreatCompound(const TopoDS_Shape& theS,
BOPCol_MapOfShape& aMFence,
BOPCol_ListOfShape& theLS)
TopTools_MapOfShape& aMFence,
TopTools_ListOfShape& theLS)
{
TopAbs_ShapeEnum aType = theS.ShapeType();
if (aType != TopAbs_COMPOUND)
@ -1188,7 +1174,7 @@ private:
Bnd_Box myBox;
};
// Vector of ShapeBox
typedef BOPCol_NCVector<BOPAlgo_ShapeBox> BOPAlgo_VectorOfShapeBox;
typedef NCollection_Vector<BOPAlgo_ShapeBox> BOPAlgo_VectorOfShapeBox;
//=======================================================================
//class : BOPAlgo_FillIn3DParts
@ -1234,21 +1220,21 @@ public:
};
//! Sets own INTERNAL faces of the solid
void SetOwnIF(const BOPCol_ListOfShape& theLIF)
void SetOwnIF(const TopTools_ListOfShape& theLIF)
{
myOwnIF = theLIF;
};
//! Returns own INTERNAL faces of the solid
const BOPCol_ListOfShape& OwnIF() const
const TopTools_ListOfShape& OwnIF() const
{
return myOwnIF;
};
//! Sets the Bounding Box tree
void SetBBTree(const BOPCol_BoxBndTree& theBBTree)
void SetBBTree(const BOPTools_BoxBndTree& theBBTree)
{
myBBTree = (BOPCol_BoxBndTree*)&theBBTree;
myBBTree = (BOPTools_BoxBndTree*)&theBBTree;
};
//! Sets the ShapeBox structure
@ -1273,7 +1259,7 @@ public:
virtual void Perform();
//! Returns the faces classified as IN for solid
const BOPCol_ListOfShape& InFaces() const
const TopTools_ListOfShape& InFaces() const
{
return myInFaces;
};
@ -1282,23 +1268,23 @@ private:
//! Prepares Edge-Face connection map of the given shape
void MapEdgesAndFaces(const TopoDS_Shape& theF,
BOPCol_IndexedDataMapOfShapeListOfShape& theEFMap,
TopTools_IndexedDataMapOfShapeListOfShape& theEFMap,
const Handle(NCollection_BaseAllocator)& theAlloc);
//! Makes the connexity block of faces using the connection map
void MakeConnexityBlock(const TopoDS_Face& theF,
const BOPCol_IndexedMapOfShape& theMEToAvoid,
const BOPCol_IndexedDataMapOfShapeListOfShape& theEFMap,
BOPCol_MapOfShape& theMFDone,
BOPCol_ListOfShape& theLCB,
const TopTools_IndexedMapOfShape& theMEToAvoid,
const TopTools_IndexedDataMapOfShapeListOfShape& theEFMap,
TopTools_MapOfShape& theMFDone,
TopTools_ListOfShape& theLCB,
TopoDS_Face& theFaceToClassify);
TopoDS_Solid mySolid; //! Solid
Bnd_Box myBoxS; // Bounding box of the solid
BOPCol_ListOfShape myOwnIF; //! Own INTERNAL faces of the solid
BOPCol_ListOfShape myInFaces; //! Faces classified as IN
TopTools_ListOfShape myOwnIF; //! Own INTERNAL faces of the solid
TopTools_ListOfShape myInFaces; //! Faces classified as IN
BOPCol_BoxBndTree* myBBTree; //! UB tree of bounding boxes
BOPTools_BoxBndTree* myBBTree; //! UB tree of bounding boxes
BOPAlgo_VectorOfShapeBox* myVShapeBox; //! ShapeBoxMap
TopoDS_Iterator myItF; //! Iterators
@ -1318,13 +1304,13 @@ void BOPAlgo_FillIn3DParts::Perform()
myInFaces.Clear();
// 1. Select boxes of faces that are not out of aBoxS
BOPCol_BoxBndTreeSelector aSelector;
BOPTools_BoxBndTreeSelector aSelector;
aSelector.SetBox(myBoxS);
//
if (!myBBTree->Select(aSelector))
return;
const BOPCol_ListOfInteger& aLIFP = aSelector.Indices();
const TColStd_ListOfInteger& aLIFP = aSelector.Indices();
// 2. Fill maps of edges and faces of the solid
@ -1332,34 +1318,34 @@ void BOPAlgo_FillIn3DParts::Perform()
BOPAlgo_VectorOfShapeBox& aVShapeBox = *myVShapeBox;
BOPCol_IndexedMapOfShape aMSE(1, anAlloc), aMSF(1, anAlloc);
BOPTools::MapShapes(mySolid, TopAbs_EDGE, aMSE);
BOPTools::MapShapes(mySolid, TopAbs_FACE, aMSF);
TopTools_IndexedMapOfShape aMSE(1, anAlloc), aMSF(1, anAlloc);
TopExp::MapShapes(mySolid, TopAbs_EDGE, aMSE);
TopExp::MapShapes(mySolid, TopAbs_FACE, aMSF);
// Check if the Solid contains any faces
Standard_Boolean bIsEmpty = aMSF.IsEmpty();
// Add own internal faces of the solid into aMSF
BOPCol_ListIteratorOfListOfShape aItLS(myOwnIF);
TopTools_ListIteratorOfListOfShape aItLS(myOwnIF);
for (; aItLS.More(); aItLS.Next())
aMSF.Add(aItLS.Value());
// 3. aIVec - faces to process.
// Filter the selected faces with faces of the solid.
BOPCol_NCVector<Standard_Integer> aIVec(256, anAlloc);
NCollection_Vector<Standard_Integer> aIVec(256, anAlloc);
BOPCol_ListIteratorOfListOfInteger aItLI(aLIFP);
TColStd_ListIteratorOfListOfInteger aItLI(aLIFP);
for (; aItLI.More(); aItLI.Next()) {
Standard_Integer nFP = aItLI.Value();
const TopoDS_Shape& aFP = aVShapeBox(nFP).Shape();
if (!aMSF.Contains(aFP))
aIVec.Append1() = nFP;
aIVec.Appended() = nFP;
}
// 4. Classify faces relatively solid.
// Store faces that are IN mySolid into <myInFaces>
Standard_Integer k, aNbFP = aIVec.Extent();
Standard_Integer k, aNbFP = aIVec.Length();
// Sort indices if necessary
if (aNbFP > 1)
std::sort(aIVec.begin(), aIVec.end());
@ -1377,7 +1363,7 @@ void BOPAlgo_FillIn3DParts::Perform()
}
// Prepare EF map of faces to process for building connexity blocks
BOPCol_IndexedDataMapOfShapeListOfShape aMEFP(1, anAlloc);
TopTools_IndexedDataMapOfShapeListOfShape aMEFP(1, anAlloc);
if (aNbFP > 1)
{
for (k = 0; k < aNbFP; ++k)
@ -1386,10 +1372,10 @@ void BOPAlgo_FillIn3DParts::Perform()
// Map of Edge-Face connection, necessary for solid classification.
// It will be filled when first classification is performed.
BOPCol_IndexedDataMapOfShapeListOfShape aMEFDS(1, anAlloc);
TopTools_IndexedDataMapOfShapeListOfShape aMEFDS(1, anAlloc);
// Fence map to avoid processing of the same faces twice
BOPCol_MapOfShape aMFDone(1, anAlloc);
TopTools_MapOfShape aMFDone(1, anAlloc);
for (k = 0; k < aNbFP; ++k)
{
@ -1401,7 +1387,7 @@ void BOPAlgo_FillIn3DParts::Perform()
// Make connexity blocks of faces, avoiding passing through the
// borders of the solid. It helps to reduce significantly the
// number of classified faces.
BOPCol_ListOfShape aLCBF(anAlloc);
TopTools_ListOfShape aLCBF(anAlloc);
// The most appropriate face for classification
TopoDS_Face aFaceToClassify;
MakeConnexityBlock(aFP, aMSE, aMEFP, aMFDone, aLCBF, aFaceToClassify);
@ -1435,7 +1421,7 @@ void BOPAlgo_FillIn3DParts::Perform()
if (aMEFDS.IsEmpty())
// Fill EF map for Solid
BOPTools::MapShapesAndAncestors(mySolid, TopAbs_EDGE, TopAbs_FACE, aMEFDS);
TopExp::MapShapesAndAncestors(mySolid, TopAbs_EDGE, TopAbs_FACE, aMEFDS);
// All vertices are interfere with the solids box, run classification.
Standard_Boolean bIsIN = BOPTools_AlgoTools::IsInternalFace
@ -1453,7 +1439,7 @@ void BOPAlgo_FillIn3DParts::Perform()
// purpose:
//=======================================================================
void BOPAlgo_FillIn3DParts::MapEdgesAndFaces(const TopoDS_Shape& theF,
BOPCol_IndexedDataMapOfShapeListOfShape& theEFMap,
TopTools_IndexedDataMapOfShapeListOfShape& theEFMap,
const Handle(NCollection_BaseAllocator)& theAllocator)
{
myItF.Initialize(theF);
@ -1468,9 +1454,9 @@ void BOPAlgo_FillIn3DParts::MapEdgesAndFaces(const TopoDS_Shape& theF,
{
const TopoDS_Shape& aE = myItW.Value();
BOPCol_ListOfShape* pLF = theEFMap.ChangeSeek(aE);
TopTools_ListOfShape* pLF = theEFMap.ChangeSeek(aE);
if (!pLF)
pLF = &theEFMap(theEFMap.Add(aE, BOPCol_ListOfShape(theAllocator)));
pLF = &theEFMap(theEFMap.Add(aE, TopTools_ListOfShape(theAllocator)));
pLF->Append(theF);
}
}
@ -1480,10 +1466,10 @@ void BOPAlgo_FillIn3DParts::MapEdgesAndFaces(const TopoDS_Shape& theF,
// purpose:
//=======================================================================
void BOPAlgo_FillIn3DParts::MakeConnexityBlock(const TopoDS_Face& theFStart,
const BOPCol_IndexedMapOfShape& theMEAvoid,
const BOPCol_IndexedDataMapOfShapeListOfShape& theEFMap,
BOPCol_MapOfShape& theMFDone,
BOPCol_ListOfShape& theLCB,
const TopTools_IndexedMapOfShape& theMEAvoid,
const TopTools_IndexedDataMapOfShapeListOfShape& theEFMap,
TopTools_MapOfShape& theMFDone,
TopTools_ListOfShape& theLCB,
TopoDS_Face& theFaceToClassify)
{
// Add start element
@ -1491,7 +1477,7 @@ void BOPAlgo_FillIn3DParts::MakeConnexityBlock(const TopoDS_Face& theFStart,
if (theEFMap.IsEmpty())
return;
BOPCol_ListIteratorOfListOfShape aItCB(theLCB);
TopTools_ListIteratorOfListOfShape aItCB(theLCB);
for (; aItCB.More(); aItCB.Next())
{
const TopoDS_Shape& aF = aItCB.Value();
@ -1513,10 +1499,10 @@ void BOPAlgo_FillIn3DParts::MakeConnexityBlock(const TopoDS_Face& theFStart,
continue;
}
const BOPCol_ListOfShape* pLF = theEFMap.Seek(aE);
const TopTools_ListOfShape* pLF = theEFMap.Seek(aE);
if (!pLF)
continue;
BOPCol_ListIteratorOfListOfShape aItLF(*pLF);
TopTools_ListIteratorOfListOfShape aItLF(*pLF);
for (; aItLF.More(); aItLF.Next())
{
const TopoDS_Shape& aFToAdd = aItLF.Value();
@ -1529,41 +1515,41 @@ void BOPAlgo_FillIn3DParts::MakeConnexityBlock(const TopoDS_Face& theFStart,
}
// Vector of solid classifiers
typedef BOPCol_NCVector<BOPAlgo_FillIn3DParts> BOPAlgo_VectorOfFillIn3DParts;
typedef NCollection_Vector<BOPAlgo_FillIn3DParts> BOPAlgo_VectorOfFillIn3DParts;
// Functors to perform classification
typedef BOPCol_ContextFunctor<BOPAlgo_FillIn3DParts,
BOPAlgo_VectorOfFillIn3DParts,
Handle(IntTools_Context),
IntTools_Context> BOPCol_FillIn3DPartsFunctor;
typedef BOPTools_ContextFunctor<BOPAlgo_FillIn3DParts,
BOPAlgo_VectorOfFillIn3DParts,
Handle(IntTools_Context),
IntTools_Context> BOPAlgo_FillIn3DPartsFunctor;
typedef BOPCol_ContextCnt<BOPCol_FillIn3DPartsFunctor,
BOPAlgo_VectorOfFillIn3DParts,
Handle(IntTools_Context)> BOPAlgo_FillIn3DPartsCnt;
typedef BOPTools_ContextCnt<BOPAlgo_FillIn3DPartsFunctor,
BOPAlgo_VectorOfFillIn3DParts,
Handle(IntTools_Context)> BOPAlgo_FillIn3DPartsCnt;
//=======================================================================
//function : ClassifyFaces
//purpose :
//=======================================================================
void BOPAlgo_Tools::ClassifyFaces(const BOPCol_ListOfShape& theFaces,
const BOPCol_ListOfShape& theSolids,
void BOPAlgo_Tools::ClassifyFaces(const TopTools_ListOfShape& theFaces,
const TopTools_ListOfShape& theSolids,
const Standard_Boolean theRunParallel,
Handle(IntTools_Context)& theContext,
BOPCol_IndexedDataMapOfShapeListOfShape& theInParts,
const BOPCol_DataMapOfShapeBox& theShapeBoxMap,
const BOPCol_DataMapOfShapeListOfShape& theSolidsIF)
TopTools_IndexedDataMapOfShapeListOfShape& theInParts,
const TopTools_DataMapOfShapeBox& theShapeBoxMap,
const TopTools_DataMapOfShapeListOfShape& theSolidsIF)
{
Handle(NCollection_BaseAllocator) anAlloc = new NCollection_IncAllocator;
// Fill the vector of shape box with faces and its bounding boxes
BOPAlgo_VectorOfShapeBox aVSB(256, anAlloc);
BOPCol_ListIteratorOfListOfShape aItLF(theFaces);
TopTools_ListIteratorOfListOfShape aItLF(theFaces);
for (; aItLF.More(); aItLF.Next())
{
const TopoDS_Shape& aF = aItLF.Value();
// Append face to the vector of shape box
BOPAlgo_ShapeBox& aSB = aVSB.Append1();
BOPAlgo_ShapeBox& aSB = aVSB.Appended();
aSB.SetShape(aF);
// Get bounding box for the face
@ -1581,10 +1567,10 @@ void BOPAlgo_Tools::ClassifyFaces(const BOPCol_ListOfShape& theFaces,
// Prepare UB tree of bounding boxes of the faces to classify
// taking the bounding boxes from the just prepared vector
BOPCol_BoxBndTree aBBTree;
BOPTools_BoxBndTree aBBTree;
NCollection_UBTreeFiller <Standard_Integer, Bnd_Box> aTreeFiller(aBBTree);
Standard_Integer aNbF = aVSB.Extent();
Standard_Integer aNbF = aVSB.Length();
for (Standard_Integer i = 0; i < aNbF; ++i)
{
aTreeFiller.Add(i, aVSB(i).Box());
@ -1596,12 +1582,12 @@ void BOPAlgo_Tools::ClassifyFaces(const BOPCol_ListOfShape& theFaces,
// Prepare vector of solids to classify
BOPAlgo_VectorOfFillIn3DParts aVFIP;
BOPCol_ListIteratorOfListOfShape aItLS(theSolids);
TopTools_ListIteratorOfListOfShape aItLS(theSolids);
for (; aItLS.More(); aItLS.Next())
{
const TopoDS_Solid& aSolid = TopoDS::Solid(aItLS.Value());
// Append solid to the vector
BOPAlgo_FillIn3DParts& aFIP = aVFIP.Append1();
BOPAlgo_FillIn3DParts& aFIP = aVFIP.Appended();
aFIP.SetSolid(aSolid);
// Get bounding box for the solid
@ -1621,7 +1607,7 @@ void BOPAlgo_Tools::ClassifyFaces(const BOPCol_ListOfShape& theFaces,
aFIP.SetBoxS(aBox);
}
const BOPCol_ListOfShape* pLIF = theSolidsIF.Seek(aSolid);
const TopTools_ListOfShape* pLIF = theSolidsIF.Seek(aSolid);
if (pLIF)
aFIP.SetOwnIF(*pLIF);
@ -1636,12 +1622,12 @@ void BOPAlgo_Tools::ClassifyFaces(const BOPCol_ListOfShape& theFaces,
// Analyze the results and fill the resulting map
Standard_Integer aNbS = aVFIP.Extent();
Standard_Integer aNbS = aVFIP.Length();
for (Standard_Integer i = 0; i < aNbS; ++i)
{
BOPAlgo_FillIn3DParts& aFIP = aVFIP(i);
const TopoDS_Shape& aS = aFIP.Solid();
const BOPCol_ListOfShape& aLFIn = aFIP.InFaces();
const TopTools_ListOfShape& aLFIn = aFIP.InFaces();
theInParts.Add(aS, aLFIn);
}
}

47
src/BOPAlgo/BOPAlgo_Tools.hxx
View File

@ -19,19 +19,17 @@
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <BOPCol_BaseAllocator.hxx>
#include <BOPCol_DataMapOfShapeBox.hxx>
#include <BOPCol_DataMapOfShapeListOfShape.hxx>
#include <BOPCol_IndexedDataMapOfShapeListOfShape.hxx>
#include <BOPCol_IndexedDataMapOfShapeReal.hxx>
#include <BOPCol_ListOfListOfShape.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPDS_IndexedDataMapOfPaveBlockListOfInteger.hxx>
#include <BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock.hxx>
#include <BOPDS_PDS.hxx>
#include <NCollection_BaseAllocator.hxx>
#include <TopTools_DataMapOfShapeBox.hxx>
#include <TopTools_DataMapOfShapeListOfShape.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_IndexedDataMapOfShapeReal.hxx>
#include <TopTools_ListOfListOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
#include <Standard_Integer.hxx>
class BOPDS_PaveBlock;
@ -39,6 +37,7 @@ class BOPDS_CommonBlock;
class IntTools_Context;
class TopoDS_Shape;
//! Provides tools used in the intersection part of Boolean operations
class BOPAlgo_Tools
{
public:
@ -47,7 +46,7 @@ public:
template <class theType, class theTypeHasher>
static void MakeBlocks(const NCollection_IndexedDataMap<theType, NCollection_List<theType>, theTypeHasher>& theMILI,
NCollection_List<NCollection_List<theType>>& theMBlocks,
const BOPCol_BaseAllocator& theAllocator)
const Handle(NCollection_BaseAllocator)& theAllocator)
{
NCollection_Map<theType, theTypeHasher> aMFence;
Standard_Integer i, aNb = theMILI.Extent();
@ -81,7 +80,7 @@ public:
static void FillMap(const theType& n1,
const theType& n2,
NCollection_IndexedDataMap<theType, NCollection_List<theType>, theTypeHasher>& theMILI,
const BOPCol_BaseAllocator& theAllocator)
const Handle(NCollection_BaseAllocator)& theAllocator)
{
NCollection_List<theType> *pList1 = theMILI.ChangeSeek(n1);
if (!pList1) {
@ -99,14 +98,14 @@ public:
Standard_EXPORT static void FillMap(const Handle(BOPDS_PaveBlock)& thePB1,
const Standard_Integer theF,
BOPDS_IndexedDataMapOfPaveBlockListOfInteger& theMILI,
const BOPCol_BaseAllocator& theAllocator);
const Handle(NCollection_BaseAllocator)& theAllocator);
Standard_EXPORT static void PerformCommonBlocks(BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock& theMBlocks,
const BOPCol_BaseAllocator& theAllocator,
const Handle(NCollection_BaseAllocator)& theAllocator,
BOPDS_PDS& theDS);
Standard_EXPORT static void PerformCommonBlocks(const BOPDS_IndexedDataMapOfPaveBlockListOfInteger& theMBlocks,
const BOPCol_BaseAllocator& theAllocator,
const Handle(NCollection_BaseAllocator)& theAllocator,
BOPDS_PDS& pDS);
Standard_EXPORT static Standard_Real ComputeToleranceOfCB
@ -157,17 +156,17 @@ public:
const Standard_Real theAngTol = 1.e-8);
//! Finds chains of intersecting vertices
Standard_EXPORT static void IntersectVertices(const BOPCol_IndexedDataMapOfShapeReal& theVertices,
Standard_EXPORT static void IntersectVertices(const TopTools_IndexedDataMapOfShapeReal& theVertices,
const Standard_Boolean theRunParallel,
const Standard_Real theFuzzyValue,
BOPCol_ListOfListOfShape& theChains);
TopTools_ListOfListOfShape& theChains);
//! Collect in the output list recursively all non-compound subshapes of the first level
//! of the given shape theS. If a shape presents in the map theMFence it is skipped.
//! All shapes put in the output are also added into theMFence.
Standard_EXPORT static void TreatCompound(const TopoDS_Shape& theS,
BOPCol_MapOfShape& theMFence,
BOPCol_ListOfShape& theLS);
TopTools_MapOfShape& theMFence,
TopTools_ListOfShape& theLS);
//! Classifies the faces <theFaces> relatively solids <theSolids>.
//! The IN faces for solids are stored into output data map <theInParts>.
@ -182,13 +181,13 @@ public:
//! It is assumed that all faces and solids are already intersected and
//! do not have any geometrically coinciding parts without topological
//! sharing of these parts
Standard_EXPORT static void ClassifyFaces(const BOPCol_ListOfShape& theFaces,
const BOPCol_ListOfShape& theSolids,
Standard_EXPORT static void ClassifyFaces(const TopTools_ListOfShape& theFaces,
const TopTools_ListOfShape& theSolids,
const Standard_Boolean theRunParallel,
Handle(IntTools_Context)& theContext,
BOPCol_IndexedDataMapOfShapeListOfShape& theInParts,
const BOPCol_DataMapOfShapeBox& theShapeBoxMap = BOPCol_DataMapOfShapeBox(),
const BOPCol_DataMapOfShapeListOfShape& theSolidsIF = BOPCol_DataMapOfShapeListOfShape());
TopTools_IndexedDataMapOfShapeListOfShape& theInParts,
const TopTools_DataMapOfShapeBox& theShapeBoxMap = TopTools_DataMapOfShapeBox(),
const TopTools_DataMapOfShapeListOfShape& theSolidsIF = TopTools_DataMapOfShapeListOfShape());
};

4
src/BOPAlgo/BOPAlgo_ToolsProvider.cxx
View File

@ -67,10 +67,10 @@ void BOPAlgo_ToolsProvider::AddTool(const TopoDS_Shape& theShape)
//function : SetTools
//purpose :
//=======================================================================
void BOPAlgo_ToolsProvider::SetTools(const BOPCol_ListOfShape& theShapes)
void BOPAlgo_ToolsProvider::SetTools(const TopTools_ListOfShape& theShapes)
{
myTools.Clear();
BOPCol_ListIteratorOfListOfShape aIt(theShapes);
TopTools_ListIteratorOfListOfShape aIt(theShapes);
for (; aIt.More(); aIt.Next())
AddTool(aIt.Value());
}

10
src/BOPAlgo/BOPAlgo_ToolsProvider.hxx
View File

@ -31,7 +31,7 @@ public:
//! Empty constructor
Standard_EXPORT BOPAlgo_ToolsProvider();
Standard_EXPORT BOPAlgo_ToolsProvider(const BOPCol_BaseAllocator& theAllocator);
Standard_EXPORT BOPAlgo_ToolsProvider(const Handle(NCollection_BaseAllocator)& theAllocator);
//! Clears internal fields and arguments
Standard_EXPORT virtual void Clear() Standard_OVERRIDE;
@ -40,18 +40,18 @@ public:
Standard_EXPORT virtual void AddTool(const TopoDS_Shape& theShape);
//! Adds the Tool arguments of the operation
Standard_EXPORT virtual void SetTools(const BOPCol_ListOfShape& theShapes);
Standard_EXPORT virtual void SetTools(const TopTools_ListOfShape& theShapes);
//! Returns the Tool arguments of the operation
const BOPCol_ListOfShape& Tools() const
const TopTools_ListOfShape& Tools() const
{
return myTools;
}
protected:
BOPCol_ListOfShape myTools;
BOPCol_MapOfShape myMapTools;
TopTools_ListOfShape myTools;
TopTools_MapOfShape myMapTools;
};
#endif // _BOPAlgo_ToolsProvider_HeaderFile

14
src/BOPAlgo/BOPAlgo_WireEdgeSet.hxx
View File

@ -22,9 +22,9 @@
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <NCollection_BaseAllocator.hxx>
#include <TopoDS_Face.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_BaseAllocator.hxx>
#include <TopTools_ListOfShape.hxx>
class TopoDS_Face;
class TopoDS_Shape;
@ -40,7 +40,7 @@ public:
BOPAlgo_WireEdgeSet();
virtual ~BOPAlgo_WireEdgeSet();
BOPAlgo_WireEdgeSet(const BOPCol_BaseAllocator& theAllocator);
BOPAlgo_WireEdgeSet(const Handle(NCollection_BaseAllocator)& theAllocator);
void Clear();
@ -50,11 +50,11 @@ public:
void AddStartElement (const TopoDS_Shape& sS);
const BOPCol_ListOfShape& StartElements() const;
const TopTools_ListOfShape& StartElements() const;
void AddShape (const TopoDS_Shape& sS);
const BOPCol_ListOfShape& Shapes() const;
const TopTools_ListOfShape& Shapes() const;
@ -64,8 +64,8 @@ protected:
TopoDS_Face myFace;
BOPCol_ListOfShape myStartShapes;
BOPCol_ListOfShape myShapes;
TopTools_ListOfShape myStartShapes;
TopTools_ListOfShape myShapes;
private:

4
src/BOPAlgo/BOPAlgo_WireEdgeSet.lxx
View File

@ -76,7 +76,7 @@
//function : StartElements
//purpose :
//=======================================================================
inline const BOPCol_ListOfShape& BOPAlgo_WireEdgeSet::StartElements()const
inline const TopTools_ListOfShape& BOPAlgo_WireEdgeSet::StartElements()const
{
return myStartShapes;
}
@ -92,7 +92,7 @@
//function : Shapes
//purpose :
//=======================================================================
inline const BOPCol_ListOfShape& BOPAlgo_WireEdgeSet::Shapes()const
inline const TopTools_ListOfShape& BOPAlgo_WireEdgeSet::Shapes()const
{
return myShapes;
}

29
src/BOPAlgo/BOPAlgo_WireSplitter.cxx
View File

@ -17,22 +17,21 @@
#include <BOPAlgo_WireEdgeSet.hxx>
#include <BOPAlgo_WireSplitter.hxx>
#include <BOPAlgo_Alerts.hxx>
#include <BOPCol_IndexedDataMapOfShapeListOfShape.hxx>
#include <BOPCol_IndexedMapOfShape.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <BOPCol_NCVector.hxx>
#include <BOPCol_Parallel.hxx>
#include <BOPTools.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_Parallel.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <NCollection_Vector.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Iterator.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Wire.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
//=======================================================================
//function :
@ -171,16 +170,16 @@ protected:
Handle(IntTools_Context) myContext;
};
typedef BOPCol_NCVector<BOPAlgo_WS_ConnexityBlock> \
typedef NCollection_Vector<BOPAlgo_WS_ConnexityBlock> \
BOPAlgo_VectorOfConnexityBlock;
//
typedef BOPCol_ContextFunctor
typedef BOPTools_ContextFunctor
<BOPAlgo_WS_ConnexityBlock,
BOPAlgo_VectorOfConnexityBlock,
Handle(IntTools_Context),
IntTools_Context> BOPAlgo_SplitBlockFunctor;
//
typedef BOPCol_ContextCnt
typedef BOPTools_ContextCnt
<BOPAlgo_SplitBlockFunctor,
BOPAlgo_VectorOfConnexityBlock,
Handle(IntTools_Context)> BOPAlgo_SplitBlockCnt;
@ -195,7 +194,7 @@ void BOPAlgo_WireSplitter::MakeWires()
Standard_Integer aNbVCB, k;
TopoDS_Wire aW;
BOPTools_ListIteratorOfListOfConnexityBlock aItCB;
BOPCol_ListIteratorOfListOfShape aIt;
TopTools_ListIteratorOfListOfShape aIt;
BOPAlgo_VectorOfConnexityBlock aVCB;
//
const TopoDS_Face& aF=myWES->Face();
@ -205,12 +204,12 @@ void BOPAlgo_WireSplitter::MakeWires()
BOPTools_ConnexityBlock& aCB=aItCB.ChangeValue();
bIsRegular=aCB.IsRegular();
if (bIsRegular) {
BOPCol_ListOfShape& aLE=aCB.ChangeShapes();
TopTools_ListOfShape& aLE=aCB.ChangeShapes();
BOPAlgo_WireSplitter::MakeWire(aLE, aW);
myWES->AddShape(aW);
}
else {
BOPAlgo_WS_ConnexityBlock& aWSCB = aVCB.Append1();
BOPAlgo_WS_ConnexityBlock& aWSCB = aVCB.Appended();
aWSCB.SetFace(aF);
aWSCB.SetConnexityBlock(aCB);
}
@ -218,10 +217,10 @@ void BOPAlgo_WireSplitter::MakeWires()
//===================================================
BOPAlgo_SplitBlockCnt::Perform(myRunParallel, aVCB, myContext);
//===================================================
aNbVCB=aVCB.Extent();
aNbVCB=aVCB.Length();
for (k=0; k<aNbVCB; ++k) {
const BOPAlgo_WS_ConnexityBlock& aCB=aVCB(k);
const BOPCol_ListOfShape& aLW=aCB.ConnexityBlock().Loops();
const TopTools_ListOfShape& aLW=aCB.ConnexityBlock().Loops();
aIt.Initialize(aLW);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aWx=aIt.Value();

8
src/BOPAlgo/BOPAlgo_WireSplitter.hxx
View File

@ -22,10 +22,10 @@
#include <BOPAlgo_PWireEdgeSet.hxx>
#include <BOPTools_ListOfConnexityBlock.hxx>
#include <BOPAlgo_Algo.hxx>
#include <BOPCol_BaseAllocator.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPTools_ConnexityBlock.hxx>
#include <IntTools_Context.hxx>
#include <NCollection_BaseAllocator.hxx>
#include <TopTools_ListOfShape.hxx>
class BOPAlgo_WireEdgeSet;
class TopoDS_Wire;
class TopoDS_Face;
@ -46,7 +46,7 @@ public:
Standard_EXPORT BOPAlgo_WireSplitter();
Standard_EXPORT virtual ~BOPAlgo_WireSplitter();
Standard_EXPORT BOPAlgo_WireSplitter(const BOPCol_BaseAllocator& theAllocator);
Standard_EXPORT BOPAlgo_WireSplitter(const Handle(NCollection_BaseAllocator)& theAllocator);
Standard_EXPORT void SetWES (const BOPAlgo_WireEdgeSet& theWES);
@ -60,7 +60,7 @@ public:
Standard_EXPORT virtual void Perform() Standard_OVERRIDE;
static void MakeWire(BOPCol_ListOfShape& theLE, TopoDS_Wire& theW);
static void MakeWire(TopTools_ListOfShape& theLE, TopoDS_Wire& theW);
Standard_EXPORT static void SplitBlock (const TopoDS_Face& theF,
BOPTools_ConnexityBlock& theCB,

4
src/BOPAlgo/BOPAlgo_WireSplitter.lxx
View File

@ -85,13 +85,13 @@ typedef NCollection_IndexedDataMap<TopoDS_Shape, \
//function : MakeWire
//purpose :
//=======================================================================
inline void BOPAlgo_WireSplitter::MakeWire(BOPCol_ListOfShape& aLE,
inline void BOPAlgo_WireSplitter::MakeWire(TopTools_ListOfShape& aLE,
TopoDS_Wire& aWire)
{
BRep_Builder aBB;
aBB.MakeWire(aWire);
//
BOPCol_ListIteratorOfListOfShape aIt(aLE);
TopTools_ListIteratorOfListOfShape aIt(aLE);
for (; aIt.More(); aIt.Next()){
aBB.Add(aWire, aIt.Value());
}

85
src/BOPAlgo/BOPAlgo_WireSplitter_1.cxx
View File

@ -14,13 +14,6 @@
#include <BOPAlgo_WireEdgeSet.hxx>
#include <BOPAlgo_WireSplitter.hxx>
#include <BOPCol_IndexedDataMapOfShapeInteger.hxx>
#include <BOPCol_IndexedDataMapOfShapeListOfShape.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <BOPCol_SequenceOfPnt2d.hxx>
#include <BOPCol_SequenceOfReal.hxx>
#include <BOPCol_SequenceOfShape.hxx>
#include <BOPTools_AlgoTools2D.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
@ -50,9 +43,16 @@
#include <TopoDS_Wire.hxx>
#include <TopTools_ShapeMapHasher.hxx>
#include <Geom2dLProp_CLProps2d.hxx>
#include <TColgp_SequenceOfPnt2d.hxx>
#include <TColStd_SequenceOfReal.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopTools_SequenceOfShape.hxx>
typedef NCollection_DataMap \
<TopoDS_Shape, Standard_Boolean, TopTools_ShapeMapHasher> \
BOPCol_DataMapOfShapeBoolean;
MyDataMapOfShapeBoolean;
//
static
@ -97,12 +97,12 @@ static
const TopoDS_Vertex& aVa,
const TopoDS_Edge& aEOuta,
BOPAlgo_EdgeInfo& anEdgeInfo,
BOPCol_SequenceOfShape& aLS,
BOPCol_SequenceOfShape& aVertVa,
BOPCol_SequenceOfPnt2d& aCoordVa,
TopTools_SequenceOfShape& aLS,
TopTools_SequenceOfShape& aVertVa,
TColgp_SequenceOfPnt2d& aCoordVa,
BOPTools_ConnexityBlock& aCB,
BOPAlgo_IndexedDataMapOfShapeListOfEdgeInfo& mySmartMap,
BOPCol_DataMapOfShapeBoolean aVertMap);
MyDataMapOfShapeBoolean aVertMap);
static
Standard_Real Angle (const gp_Dir2d& aDir2D);
@ -122,7 +122,7 @@ static
static
void RefineAngles(const TopoDS_Face& myFace,
const BOPCol_ListOfShape&,
const TopTools_ListOfShape&,
BOPAlgo_IndexedDataMapOfShapeListOfEdgeInfo&,
const Handle(IntTools_Context)&);
@ -130,7 +130,7 @@ static
static
void RefineAngles(const TopoDS_Vertex& ,
const TopoDS_Face& ,
const BOPCol_MapOfShape& ,
const TopTools_MapOfShape& ,
BOPAlgo_ListOfEdgeInfo&,
const Handle(IntTools_Context)&);
@ -159,13 +159,13 @@ void BOPAlgo_WireSplitter::SplitBlock(const TopoDS_Face& myFace,
TopoDS_Iterator aItS;
TopoDS_Vertex aVV;
TopoDS_Shape aV1;
BOPCol_ListIteratorOfListOfShape aIt;
TopTools_ListIteratorOfListOfShape aIt;
BOPAlgo_ListIteratorOfListOfEdgeInfo aItLEI;
//
BOPAlgo_IndexedDataMapOfShapeListOfEdgeInfo mySmartMap(100);
BOPCol_DataMapOfShapeBoolean aVertMap;
MyDataMapOfShapeBoolean aVertMap;
//
const BOPCol_ListOfShape& myEdges=aCB.Shapes();
const TopTools_ListOfShape& myEdges=aCB.Shapes();
//
// 1.Filling mySmartMap
aIt.Initialize(myEdges);
@ -242,19 +242,19 @@ void BOPAlgo_WireSplitter::SplitBlock(const TopoDS_Face& myFace,
Standard_Integer aNbE, aNbMapEE;
Standard_Boolean bFlag;
//
BOPCol_IndexedDataMapOfShapeListOfShape aMapEE(100);
TopTools_IndexedDataMapOfShapeListOfShape aMapEE(100);
aNbE=myEdges.Extent();
//
aIt.Initialize(myEdges);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aE = aIt.Value();
if (!aMapEE.Contains(aE)) {
BOPCol_ListOfShape aLEx;
TopTools_ListOfShape aLEx;
aLEx.Append(aE);
aMapEE.Add(aE, aLEx);
}
else {
BOPCol_ListOfShape& aLEx=aMapEE.ChangeFromKey(aE);
TopTools_ListOfShape& aLEx=aMapEE.ChangeFromKey(aE);
aLEx.Append(aE);
}
}
@ -262,7 +262,7 @@ void BOPAlgo_WireSplitter::SplitBlock(const TopoDS_Face& myFace,
bFlag=Standard_True;
aNbMapEE=aMapEE.Extent();
for (i=1; i<=aNbMapEE; ++i) {
const BOPCol_ListOfShape& aLEx=aMapEE(i);
const TopTools_ListOfShape& aLEx=aMapEE(i);
aNbE=aLEx.Extent();
if (aNbE==1) {// usual case
continue;
@ -285,9 +285,9 @@ void BOPAlgo_WireSplitter::SplitBlock(const TopoDS_Face& myFace,
if (bNothingToDo) {
TopoDS_Wire aW;
//
BOPCol_ListOfShape& aLECB=aCB.ChangeShapes();
TopTools_ListOfShape& aLECB=aCB.ChangeShapes();
BOPAlgo_WireSplitter::MakeWire(aLECB, aW);
BOPCol_ListOfShape& aLoops=aCB.ChangeLoops();
TopTools_ListOfShape& aLoops=aCB.ChangeLoops();
aLoops.Append(aW);
//
return;
@ -322,8 +322,8 @@ void BOPAlgo_WireSplitter::SplitBlock(const TopoDS_Face& myFace,
// 4. Do
//
Standard_Boolean bIsOut, bIsNotPassed;
BOPCol_SequenceOfShape aLS, aVertVa;
BOPCol_SequenceOfPnt2d aCoordVa;
TopTools_SequenceOfShape aLS, aVertVa;
TColgp_SequenceOfPnt2d aCoordVa;
//
for (i=1; i<=aNb; ++i) {
const TopoDS_Vertex& aVa=(*(TopoDS_Vertex *)(&mySmartMap.FindKey(i)));
@ -356,13 +356,12 @@ void Path (const GeomAdaptor_Surface& aGAS,
const TopoDS_Vertex& aVFirst,
const TopoDS_Edge& aEFirst,
BOPAlgo_EdgeInfo& aEIFirst,
BOPCol_SequenceOfShape& aLS,
BOPCol_SequenceOfShape& aVertVa,
BOPCol_SequenceOfPnt2d& aCoordVa,
TopTools_SequenceOfShape& aLS,
TopTools_SequenceOfShape& aVertVa,
TColgp_SequenceOfPnt2d& aCoordVa,
BOPTools_ConnexityBlock& aCB,
BOPAlgo_IndexedDataMapOfShapeListOfEdgeInfo& mySmartMap,
BOPCol_DataMapOfShapeBoolean aVertMap)
MyDataMapOfShapeBoolean aVertMap)
{
Standard_Integer i, j, aNb, aNbj;
Standard_Real anAngleIn, anAngleOut, anAngle, aMinAngle;
@ -412,7 +411,7 @@ void Path (const GeomAdaptor_Surface& aGAS,
//
bIsClosed = aVertMap.Find(aVb);
{
BOPCol_ListOfShape aBuf;
TopTools_ListOfShape aBuf;
Standard_Boolean bHasEdge = Standard_False;
//
aNb = aLS.Length();
@ -473,8 +472,8 @@ void Path (const GeomAdaptor_Surface& aGAS,
return;
}
//
BOPCol_SequenceOfShape aLSt, aVertVat;
BOPCol_SequenceOfPnt2d aCoordVat;
TopTools_SequenceOfShape aLSt, aVertVat;
TColgp_SequenceOfPnt2d aCoordVat;
//
aVb=(*(TopoDS_Vertex *)(&aVertVa(i)));
//
@ -861,14 +860,16 @@ Standard_Real VTolerance2D (const TopoDS_Vertex& aV,
//purpose :
//=======================================================================
void RefineAngles(const TopoDS_Face& myFace,
const BOPCol_ListOfShape& myEdges,
const TopTools_ListOfShape& myEdges,
BOPAlgo_IndexedDataMapOfShapeListOfEdgeInfo& mySmartMap,
const Handle(IntTools_Context)& theContext)
{
Standard_Integer aNb, i;
BOPCol_IndexedDataMapOfShapeInteger aMSI;
BOPCol_MapOfShape aMBE;
BOPCol_ListIteratorOfListOfShape aIt;
NCollection_IndexedDataMap<TopoDS_Shape,
Standard_Integer,
TopTools_ShapeMapHasher> aMSI;
TopTools_MapOfShape aMBE;
TopTools_ListIteratorOfListOfShape aIt;
//
// 1. Boundary Edges
aIt.Initialize(myEdges);
@ -906,9 +907,9 @@ void RefineAngles(const TopoDS_Face& myFace,
//=======================================================================
typedef NCollection_DataMap \
<TopoDS_Shape, Standard_Real, TopTools_ShapeMapHasher> \
BOPCol_DataMapOfShapeReal;
typedef BOPCol_DataMapOfShapeReal::Iterator \
BOPCol_DataMapIteratorOfDataMapOfShapeReal;
TopTools_DataMapOfShapeReal;
typedef TopTools_DataMapOfShapeReal::Iterator \
TopTools_DataMapIteratorOfDataMapOfShapeReal;
//
//=======================================================================
//function : RefineAngles
@ -916,14 +917,14 @@ typedef BOPCol_DataMapOfShapeReal::Iterator \
//=======================================================================
void RefineAngles(const TopoDS_Vertex& aV,
const TopoDS_Face& myFace,
const BOPCol_MapOfShape& aMBE,
const TopTools_MapOfShape& aMBE,
BOPAlgo_ListOfEdgeInfo& aLEI,
const Handle(IntTools_Context)& theContext)
{
Standard_Boolean bIsIn, bIsBoundary, bRefined;
Standard_Integer iCntBnd, iCntInt;
Standard_Real aA, aA1, aA2;
BOPCol_DataMapOfShapeReal aDMSR;
TopTools_DataMapOfShapeReal aDMSR;
BOPAlgo_ListIteratorOfListOfEdgeInfo aItLEI;
//
aA1=0.; // angle of outgoing edge

22
src/BOPCol/BOPCol_BaseAllocator.hxx
View File

@ -1,22 +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.
#ifndef BOPCol_BaseAllocator_HeaderFile
#define BOPCol_BaseAllocator_HeaderFile
#include <NCollection_BaseAllocator.hxx>
typedef Handle(NCollection_BaseAllocator) BOPCol_BaseAllocator;
#endif

81
src/BOPCol/BOPCol_Box2DBndTree.cxx
View File

@ -1,81 +0,0 @@
// Created by: Peter KURNEV
// Copyright (c) 2010-2012 OPEN CASCADE SAS
// Copyright (c) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
// Copyright (c) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, CEDRAT,
// EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
//
// 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 <BOPCol_Box2DBndTree.hxx>
//=======================================================================
//function :
//purpose :
//=======================================================================
BOPCol_Box2DBndTreeSelector::BOPCol_Box2DBndTreeSelector()
{
}
//=======================================================================
//function : ~
//purpose :
//=======================================================================
BOPCol_Box2DBndTreeSelector::~BOPCol_Box2DBndTreeSelector()
{
}
//=======================================================================
//function : Reject
//purpose :
//=======================================================================
Standard_Boolean BOPCol_Box2DBndTreeSelector::Reject
(const Bnd_Box2d& aBox2D) const
{
return myBox2D.IsOut(aBox2D);
}
//=======================================================================
//function : Accept
//purpose :
//=======================================================================
Standard_Boolean BOPCol_Box2DBndTreeSelector::Accept
(const Standard_Integer& aIndex)
{
Standard_Boolean bRet=Standard_False;
//
myIndices.Append(aIndex);
bRet=!bRet;
//}
return bRet;
}
//=======================================================================
//function : SetBox
//purpose :
//=======================================================================
void BOPCol_Box2DBndTreeSelector::SetBox(const Bnd_Box2d& aBox2D)
{
myBox2D=aBox2D;
}
//=======================================================================
//function : Clear
//purpose :
//=======================================================================
void BOPCol_Box2DBndTreeSelector::Clear()
{
myIndices.Clear();
}
//=======================================================================
//function : Indices
//purpose :
//=======================================================================
const BOPCol_ListOfInteger& BOPCol_Box2DBndTreeSelector::Indices() const
{
return myIndices;
}

48
src/BOPCol/BOPCol_Box2DBndTree.hxx
View File

@ -1,48 +0,0 @@
// Created by: Peter KURNEV
// Copyright (c) 2010-2012 OPEN CASCADE SAS
// Copyright (c) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
// Copyright (c) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, CEDRAT,
// EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef BOPCol_Box2DBndTree_HeaderFile
#define BOPCol_Box2DBndTree_HeaderFile
#include <NCollection_UBTree.hxx>
#include <Bnd_Box2d.hxx>
#include <BOPCol_ListOfInteger.hxx>
/**
* The instantiation of the algorithm of unbalanced binary tree
* of overlapped bounding boxes 2D.
*
*/
typedef NCollection_UBTree <Standard_Integer , Bnd_Box2d> BOPCol_Box2DBndTree;
class BOPCol_Box2DBndTreeSelector : public BOPCol_Box2DBndTree::Selector {
public:
Standard_EXPORT BOPCol_Box2DBndTreeSelector();
Standard_EXPORT virtual Standard_Boolean Reject(const Bnd_Box2d&) const;
Standard_EXPORT virtual Standard_Boolean Accept(const Standard_Integer &);
Standard_EXPORT virtual ~BOPCol_Box2DBndTreeSelector();
Standard_EXPORT void Clear();
Standard_EXPORT void SetBox(const Bnd_Box2d&);
Standard_EXPORT const BOPCol_ListOfInteger& Indices() const;
protected:
Bnd_Box2d myBox2D;
BOPCol_ListOfInteger myIndices;
};
#endif

77
src/BOPCol/BOPCol_BoxBndTree.cxx
View File

@ -1,77 +0,0 @@
// Created by: Peter KURNEV
// Copyright (c) 2010-2014 OPEN CASCADE SAS
// Copyright (c) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
// Copyright (c) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, CEDRAT,
// EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// 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 <BOPCol_BoxBndTree.hxx>
//=======================================================================
//function :
//purpose :
//=======================================================================
BOPCol_BoxBndTreeSelector::BOPCol_BoxBndTreeSelector()
{
}
//=======================================================================
//function : ~
//purpose :
//=======================================================================
BOPCol_BoxBndTreeSelector::~BOPCol_BoxBndTreeSelector()
{
}
//=======================================================================
//function : Reject
//purpose :
//=======================================================================
Standard_Boolean BOPCol_BoxBndTreeSelector::Reject (const Bnd_Box& aBox) const
{
return myBox.IsOut(aBox);
}
//=======================================================================
//function : Accept
//purpose :
//=======================================================================
Standard_Boolean BOPCol_BoxBndTreeSelector::Accept (const Standard_Integer& aIndex)
{
Standard_Boolean bRet=Standard_False;
//
myIndices.Append(aIndex);
bRet=!bRet;
return bRet;
}
//=======================================================================
//function : SetBox
//purpose :
//=======================================================================
void BOPCol_BoxBndTreeSelector::SetBox(const Bnd_Box& aBox)
{
myBox=aBox;
}
//=======================================================================
//function : Clear
//purpose :
//=======================================================================
void BOPCol_BoxBndTreeSelector::Clear()
{
myIndices.Clear();
}
//=======================================================================
//function : Indices
//purpose :
//=======================================================================
const BOPCol_ListOfInteger& BOPCol_BoxBndTreeSelector::Indices() const
{
return myIndices;
}

48
src/BOPCol/BOPCol_BoxBndTree.hxx
View File

@ -1,48 +0,0 @@
// Created by: Peter KURNEV
// Copyright (c) 2010-2014 OPEN CASCADE SAS
// Copyright (c) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
// Copyright (c) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, CEDRAT,
// EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef NMTDS_BoxBndTree_HeaderFile
#define NMTDS_BoxBndTree_HeaderFile
#include <NCollection_UBTree.hxx>
#include <Bnd_Box.hxx>
#include <BOPCol_ListOfInteger.hxx>
/**
* The instantiation of the algorithm of unbalanced binary tree
* of overlapped bounding boxes.
*
*/
typedef NCollection_UBTree <Standard_Integer , Bnd_Box> BOPCol_BoxBndTree;
class BOPCol_BoxBndTreeSelector : public BOPCol_BoxBndTree::Selector {
public:
Standard_EXPORT BOPCol_BoxBndTreeSelector();
Standard_EXPORT virtual Standard_Boolean Reject(const Bnd_Box&) const;
Standard_EXPORT virtual Standard_Boolean Accept(const Standard_Integer &);
Standard_EXPORT virtual ~BOPCol_BoxBndTreeSelector();
Standard_EXPORT void Clear();
Standard_EXPORT void SetBox(const Bnd_Box&);
Standard_EXPORT const BOPCol_ListOfInteger& Indices() const;
protected:
Bnd_Box myBox;
BOPCol_ListOfInteger myIndices;
};
#endif

25
src/BOPCol/BOPCol_DataMapOfIntegerInteger.hxx
View File

@ -1,25 +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.
#ifndef BOPCol_DataMapOfIntegerInteger_HeaderFile
#define BOPCol_DataMapOfIntegerInteger_HeaderFile
#include <NCollection_DataMap.hxx>
#include <TColStd_MapIntegerHasher.hxx>
typedef NCollection_DataMap<Standard_Integer, Standard_Integer, TColStd_MapIntegerHasher> BOPCol_DataMapOfIntegerInteger;
typedef BOPCol_DataMapOfIntegerInteger::Iterator BOPCol_DataMapIteratorOfDataMapOfIntegerInteger;
#endif

27
src/BOPCol/BOPCol_DataMapOfIntegerListOfInteger.hxx
View File

@ -1,27 +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.
#ifndef BOPCol_DataMapOfIntegerListOfInteger_HeaderFile
#define BOPCol_DataMapOfIntegerListOfInteger_HeaderFile
#include <NCollection_DataMap.hxx>
#include <TColStd_MapIntegerHasher.hxx>
#include <BOPCol_ListOfInteger.hxx>
typedef NCollection_DataMap<Standard_Integer, BOPCol_ListOfInteger, TColStd_MapIntegerHasher> BOPCol_DataMapOfIntegerListOfInteger;
typedef BOPCol_DataMapOfIntegerListOfInteger::Iterator BOPCol_DataMapIteratorOfDataMapOfIntegerListOfInteger;
#endif

26
src/BOPCol/BOPCol_DataMapOfIntegerListOfShape.hxx
View File

@ -1,26 +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.
#ifndef BOPCol_DataMapOfIntegerListOfShape_HeaderFile
#define BOPCol_DataMapOfIntegerListOfShape_HeaderFile
#include <NCollection_DataMap.hxx>
#include <TColStd_MapIntegerHasher.hxx>
#include <BOPCol_ListOfShape.hxx>
typedef NCollection_DataMap<Standard_Integer, BOPCol_ListOfShape, TColStd_MapIntegerHasher> BOPCol_DataMapOfIntegerListOfShape;
typedef BOPCol_DataMapOfIntegerListOfShape::Iterator BOPCol_DataMapIteratorOfDataMapOfIntegerListOfShape;
#endif

27
src/BOPCol/BOPCol_DataMapOfIntegerMapOfInteger.hxx
View File

@ -1,27 +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.
#ifndef BOPCol_DataMapOfIntegerMapOfInteger_HeaderFile
#define BOPCol_DataMapOfIntegerMapOfInteger_HeaderFile
#include <NCollection_DataMap.hxx>
#include <TColStd_MapIntegerHasher.hxx>
#include <BOPCol_MapOfInteger.hxx>
typedef NCollection_DataMap<Standard_Integer, BOPCol_MapOfInteger, TColStd_MapIntegerHasher> BOPCol_DataMapOfIntegerMapOfInteger;
typedef BOPCol_DataMapOfIntegerMapOfInteger::Iterator BOPCol_DataMapIteratorOfDataMapOfIntegerMapOfInteger;
#endif

25
src/BOPCol/BOPCol_DataMapOfIntegerReal.hxx
View File

@ -1,25 +0,0 @@
// Created by: Eugeny MALTCHIKOV
// 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.
#ifndef BOPCol_DataMapOfIntegerReal_HeaderFile
#define BOPCol_DataMapOfIntegerReal_HeaderFile
#include <NCollection_DataMap.hxx>
#include <TColStd_MapIntegerHasher.hxx>
typedef NCollection_DataMap<Standard_Integer, Standard_Real, TColStd_MapIntegerHasher> BOPCol_DataMapOfIntegerReal;
typedef BOPCol_DataMapOfIntegerReal::Iterator BOPCol_DataMapIteratorOfDataMapOfIntegerReal;
#endif

26
src/BOPCol/BOPCol_DataMapOfIntegerShape.hxx
View File

@ -1,26 +0,0 @@
// Created by: Eugeny MALTCHIKOV
// 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.
#ifndef BOPCol_DataMapOfIntegerShape_HeaderFile
#define BOPCol_DataMapOfIntegerShape_HeaderFile
#include <TopoDS_Shape.hxx>
#include <TColStd_MapIntegerHasher.hxx>
#include <NCollection_DataMap.hxx>
typedef NCollection_DataMap<Standard_Integer, TopoDS_Shape, TColStd_MapIntegerHasher> BOPCol_DataMapOfIntegerShape;
typedef BOPCol_DataMapOfIntegerShape::Iterator BOPCol_DataMapIteratorOfDataMapOfIntegerShape;
#endif

26
src/BOPCol/BOPCol_DataMapOfShapeAddress.hxx
View File

@ -1,26 +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.
#ifndef BOPCol_DataMapOfShapeAddress_HeaderFile
#define BOPCol_DataMapOfShapeAddress_HeaderFile
#include <TopoDS_Shape.hxx>
#include <TopTools_ShapeMapHasher.hxx>
#include <NCollection_DataMap.hxx>
typedef NCollection_DataMap<TopoDS_Shape, Standard_Address, TopTools_ShapeMapHasher> BOPCol_DataMapOfShapeAddress;
typedef BOPCol_DataMapOfShapeAddress::Iterator BOPCol_DataMapIteratorOfDataMapOfShapeAddress;
#endif

26
src/BOPCol/BOPCol_DataMapOfShapeInteger.hxx
View File

@ -1,26 +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.
#ifndef BOPCol_DataMapOfShapeInteger_HeaderFile
#define BOPCol_DataMapOfShapeInteger_HeaderFile
#include <TopoDS_Shape.hxx>
#include <TopTools_ShapeMapHasher.hxx>
#include <NCollection_DataMap.hxx>
typedef NCollection_DataMap<TopoDS_Shape, Standard_Integer, TopTools_ShapeMapHasher> BOPCol_DataMapOfShapeInteger;
typedef BOPCol_DataMapOfShapeInteger::Iterator BOPCol_DataMapIteratorOfDataMapOfShapeInteger;
#endif

27
src/BOPCol/BOPCol_DataMapOfShapeListOfShape.hxx
View File

@ -1,27 +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.
#ifndef BOPCol_DataMapOfShapeListOfShape_HeaderFile
#define BOPCol_DataMapOfShapeListOfShape_HeaderFile
#include <TopoDS_Shape.hxx>
#include <TopTools_ShapeMapHasher.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <NCollection_DataMap.hxx>
typedef NCollection_DataMap<TopoDS_Shape, BOPCol_ListOfShape, TopTools_ShapeMapHasher> BOPCol_DataMapOfShapeListOfShape;
typedef BOPCol_DataMapOfShapeListOfShape::Iterator BOPCol_DataMapIteratorOfDataMapOfShapeListOfShape;
#endif

26
src/BOPCol/BOPCol_DataMapOfShapeReal.hxx
View File

@ -1,26 +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.
#ifndef BOPCol_DataMapOfShapeReal_HeaderFile
#define BOPCol_DataMapOfShapeReal_HeaderFile
#include <TopoDS_Shape.hxx>
#include <TopTools_ShapeMapHasher.hxx>
#include <NCollection_DataMap.hxx>
typedef NCollection_DataMap<TopoDS_Shape, Standard_Real, TopTools_ShapeMapHasher> BOPCol_DataMapOfShapeReal;
typedef BOPCol_DataMapOfShapeReal::Iterator BOPCol_DataMapIteratorOfDataMapOfShapeReal;
#endif

26
src/BOPCol/BOPCol_DataMapOfShapeShape.hxx
View File

@ -1,26 +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.
#ifndef BOPCol_DataMapOfShapeShape_HeaderFile
#define BOPCol_DataMapOfShapeShape_HeaderFile
#include <TopoDS_Shape.hxx>
#include <TopTools_ShapeMapHasher.hxx>
#include <NCollection_DataMap.hxx>
typedef NCollection_DataMap<TopoDS_Shape, TopoDS_Shape, TopTools_ShapeMapHasher> BOPCol_DataMapOfShapeShape;
typedef BOPCol_DataMapOfShapeShape::Iterator BOPCol_DataMapIteratorOfDataMapOfShapeShape;
#endif

24
src/BOPCol/BOPCol_DataMapOfTransientAddress.hxx
View File

@ -1,24 +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.
#ifndef BOPCol_DataMapOfTransientAddress_HeaderFile
#define BOPCol_DataMapOfTransientAddress_HeaderFile
#include <NCollection_DataMap.hxx>
#include <TColStd_MapTransientHasher.hxx>
typedef NCollection_DataMap<Handle(Standard_Transient), Standard_Address, TColStd_MapTransientHasher> BOPCol_DataMapOfTransientAddress;
typedef BOPCol_DataMapOfTransientAddress::Iterator BOPCol_DataMapIteratorOfDataMapOfTransientAddress;
#endif

26
src/BOPCol/BOPCol_IndexedDataMapOfIntegerListOfInteger.hxx
View File

@ -1,26 +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.
#ifndef BOPCol_IndexedDataMapOfIntegerListOfInteger_HeaderFile
#define BOPCol_IndexedDataMapOfIntegerListOfInteger_HeaderFile
#include <NCollection_IndexedDataMap.hxx>
#include <TColStd_MapIntegerHasher.hxx>
#include <BOPCol_ListOfInteger.hxx>
typedef NCollection_IndexedDataMap<Standard_Integer, BOPCol_ListOfInteger, TColStd_MapIntegerHasher> BOPCol_IndexedDataMapOfIntegerListOfInteger;
#endif

26
src/BOPCol/BOPCol_IndexedDataMapOfShapeBox.hxx
View File

@ -1,26 +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.
#ifndef BOPCol_IndexedDataMapOfShapeBox_HeaderFile
#define BOPCol_IndexedDataMapOfShapeBox_HeaderFile
#include <TopoDS_Shape.hxx>
#include <TopTools_ShapeMapHasher.hxx>
#include <Bnd_Box.hxx>
#include <NCollection_IndexedDataMap.hxx>
typedef NCollection_IndexedDataMap<TopoDS_Shape, Bnd_Box, TopTools_ShapeMapHasher> BOPCol_IndexedDataMapOfShapeBox;
#endif

25
src/BOPCol/BOPCol_IndexedDataMapOfShapeInteger.hxx
View File

@ -1,25 +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.
#ifndef BOPCol_IndexedDataMapOfShapeInteger_HeaderFile
#define BOPCol_IndexedDataMapOfShapeInteger_HeaderFile
#include <TopoDS_Shape.hxx>
#include <TopTools_ShapeMapHasher.hxx>
#include <NCollection_IndexedDataMap.hxx>
typedef NCollection_IndexedDataMap<TopoDS_Shape, Standard_Integer, TopTools_ShapeMapHasher> BOPCol_IndexedDataMapOfShapeInteger;
#endif

27
src/BOPCol/BOPCol_IndexedDataMapOfShapeListOfShape.hxx
View File

@ -1,27 +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.
#ifndef BOPCol_IndexedDataMapOfShapeListOfShape_HeaderFile
#define BOPCol_IndexedDataMapOfShapeListOfShape_HeaderFile
#include <TopoDS_Shape.hxx>
#include <TopTools_ShapeMapHasher.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <NCollection_IndexedDataMap.hxx>
typedef NCollection_IndexedDataMap<TopoDS_Shape, BOPCol_ListOfShape, TopTools_ShapeMapHasher> BOPCol_IndexedDataMapOfShapeListOfShape;
#endif

23
src/BOPCol/BOPCol_IndexedMapOfInteger.hxx
View File

@ -1,23 +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.
#ifndef BOPCol_IndexedMapOfInteger_HeaderFile
#define BOPCol_IndexedMapOfInteger_HeaderFile
#include <NCollection_IndexedMap.hxx>
#include <TColStd_MapIntegerHasher.hxx>
typedef NCollection_IndexedMap<Standard_Integer, TColStd_MapIntegerHasher> BOPCol_IndexedMapOfInteger;
#endif

24
src/BOPCol/BOPCol_IndexedMapOfShape.hxx
View File

@ -1,24 +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.
#ifndef BOPCol_IndexedMapOfShape_HeaderFile
#define BOPCol_IndexedMapOfShape_HeaderFile
#include <TopoDS_Shape.hxx>
#include <TopTools_ShapeMapHasher.hxx>
#include <NCollection_IndexedMap.hxx>
typedef NCollection_IndexedMap<TopoDS_Shape, TopTools_ShapeMapHasher> BOPCol_IndexedMapOfShape;
#endif

24
src/BOPCol/BOPCol_ListOfInteger.hxx
View File

@ -1,24 +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.
#ifndef BOPCol_ListOfInteger_HeaderFile
#define BOPCol_ListOfInteger_HeaderFile
#include <NCollection_List.hxx>
typedef NCollection_List<Standard_Integer> BOPCol_ListOfInteger;
typedef BOPCol_ListOfInteger::Iterator BOPCol_ListIteratorOfListOfInteger;
typedef BOPCol_ListOfInteger* BOPCol_PListOfInteger;
#endif

26
src/BOPCol/BOPCol_ListOfListOfShape.hxx
View File

@ -1,26 +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.
#ifndef BOPCol_ListOfListOfShape_HeaderFile
#define BOPCol_ListOfListOfShape_HeaderFile
#include <NCollection_List.hxx>
#include <BOPCol_ListOfShape.hxx>
typedef NCollection_List<BOPCol_ListOfShape> BOPCol_ListOfListOfShape;
typedef BOPCol_ListOfListOfShape::Iterator BOPCol_ListIteratorOfListOfListOfShape;
#endif

25
src/BOPCol/BOPCol_ListOfShape.hxx
View File

@ -1,25 +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.
#ifndef BOPCol_ListOfShape_HeaderFile
#define BOPCol_ListOfShape_HeaderFile
#include <NCollection_List.hxx>
#include <TopoDS_Shape.hxx>
typedef NCollection_List<TopoDS_Shape> BOPCol_ListOfShape;
typedef BOPCol_ListOfShape::Iterator BOPCol_ListIteratorOfListOfShape;
#endif

24
src/BOPCol/BOPCol_MapOfInteger.hxx
View File

@ -1,24 +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.
#ifndef BOPCol_MapOfInteger_HeaderFile
#define BOPCol_MapOfInteger_HeaderFile
#include <TColStd_MapIntegerHasher.hxx>
#include <NCollection_Map.hxx>
typedef NCollection_Map<Standard_Integer, TColStd_MapIntegerHasher> BOPCol_MapOfInteger;
typedef BOPCol_MapOfInteger::Iterator BOPCol_MapIteratorOfMapOfInteger;
#endif

26
src/BOPCol/BOPCol_MapOfOrientedShape.hxx
View File

@ -1,26 +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.
#ifndef BOPCol_MapOfOrientedShape_HeaderFile
#define BOPCol_MapOfOrientedShape_HeaderFile
#include <TopoDS_Shape.hxx>
#include <TopTools_OrientedShapeMapHasher.hxx>
#include <NCollection_Map.hxx>
typedef NCollection_Map<TopoDS_Shape, TopTools_OrientedShapeMapHasher> BOPCol_MapOfOrientedShape;
typedef BOPCol_MapOfOrientedShape::Iterator BOPCol_MapIteratorOfMapOfOrientedShape;
#endif

26
src/BOPCol/BOPCol_MapOfShape.hxx
View File

@ -1,26 +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.
#ifndef BOPCol_MapOfShape_HeaderFile
#define BOPCol_MapOfShape_HeaderFile
#include <TopoDS_Shape.hxx>
#include <TopTools_ShapeMapHasher.hxx>
#include <NCollection_Map.hxx>
typedef NCollection_Map<TopoDS_Shape, TopTools_ShapeMapHasher> BOPCol_MapOfShape;
typedef BOPCol_MapOfShape::Iterator BOPCol_MapIteratorOfMapOfShape;
#endif

48
src/BOPCol/BOPCol_NCVector.hxx
View File

@ -1,48 +0,0 @@
// Created by: Peter KURNEV
// Copyright (c) 1999-2013 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef BOPCol_NCVector_HeaderFile
#define BOPCol_NCVector_HeaderFile
#include <Standard.hxx>
#include <NCollection_Vector.hxx>
#include <NCollection_BaseAllocator.hxx>
//=======================================================================
//class : BOPCol_NCVector
//purpose :
//=======================================================================
template <class Type> class BOPCol_NCVector
:
public NCollection_Vector<Type>
{
public:
BOPCol_NCVector(const Standard_Integer theIncrement=256,
const Handle(NCollection_BaseAllocator)& theAlloc = NULL)
: NCollection_Vector<Type>(theIncrement, theAlloc)
{}
//
Type& Append1 ()
{
Type& anAppended = *(Type*)this->expandV (this->myLength);
return anAppended;
}
//
Standard_Integer Extent() const
{
return this->myLength;
}
};
#endif

23
src/BOPCol/BOPCol_PInteger.hxx
View File

@ -1,23 +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.
#ifndef BOPCol_PInteger_HeaderFile
#define BOPCol_PInteger_HeaderFile
#include <Standard_TypeDef.hxx>
#include <BOPCol_ListOfInteger.hxx>
typedef Standard_Integer* BOPCol_PInteger;
#endif

20
src/BOPCol/BOPCol_PListOfInteger.hxx
View File

@ -1,20 +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.
#ifndef BOPCol_PListOfInteger_HeaderFile
#define BOPCol_PListOfInteger_HeaderFile
#include <BOPCol_ListOfInteger.hxx>
#endif

25
src/BOPCol/BOPCol_SequenceOfPnt2d.hxx
View File

@ -1,25 +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.
#ifndef BOPCol_SequenceOfPnt2d_HeaderFile
#define BOPCol_SequenceOfPnt2d_HeaderFile
#include <NCollection_Sequence.hxx>
#include <gp_Pnt2d.hxx>
typedef NCollection_Sequence<gp_Pnt2d> BOPCol_SequenceOfPnt2d;
#endif

24
src/BOPCol/BOPCol_SequenceOfShape.hxx
View File

@ -1,24 +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.
#ifndef BOPCol_SequenceOfShape_HeaderFile
#define BOPCol_SequenceOfShape_HeaderFile
#include <NCollection_Sequence.hxx>
#include <TopoDS_Shape.hxx>
typedef NCollection_Sequence<TopoDS_Shape> BOPCol_SequenceOfShape;
#endif

40
src/BOPCol/FILES
View File

@ -1,40 +0,0 @@
BOPCol_BaseAllocator.hxx
BOPCol_Box2DBndTree.cxx
BOPCol_Box2DBndTree.hxx
BOPCol_BoxBndTree.cxx
BOPCol_BoxBndTree.hxx
BOPCol_DataMapOfIntegerInteger.hxx
BOPCol_DataMapOfIntegerListOfInteger.hxx
BOPCol_DataMapOfIntegerListOfShape.hxx
BOPCol_DataMapOfIntegerMapOfInteger.hxx
BOPCol_DataMapOfIntegerReal.hxx
BOPCol_DataMapOfIntegerShape.hxx
BOPCol_DataMapOfShapeAddress.hxx
BOPCol_DataMapOfShapeBox.hxx
BOPCol_DataMapOfShapeInteger.hxx
BOPCol_DataMapOfShapeListOfShape.hxx
BOPCol_DataMapOfShapeReal.hxx
BOPCol_DataMapOfShapeShape.hxx
BOPCol_DataMapOfTransientAddress.hxx
BOPCol_IndexedDataMapOfIntegerListOfInteger.hxx
BOPCol_IndexedDataMapOfShapeBox.hxx
BOPCol_IndexedDataMapOfShapeInteger.hxx
BOPCol_IndexedDataMapOfShapeListOfShape.hxx
BOPCol_IndexedMapOfInteger.hxx
BOPCol_IndexedMapOfShape.hxx
BOPCol_IndexedDataMapOfShapeShape.hxx
BOPCol_IndexedDataMapOfShapeReal.hxx
BOPCol_IndexedMapOfOrientedShape.hxx
BOPCol_ListOfInteger.hxx
BOPCol_ListOfListOfShape.hxx
BOPCol_ListOfShape.hxx
BOPCol_MapOfInteger.hxx
BOPCol_MapOfOrientedShape.hxx
BOPCol_MapOfShape.hxx
BOPCol_NCVector.hxx
BOPCol_Parallel.hxx
BOPCol_PInteger.hxx
BOPCol_PListOfInteger.hxx
BOPCol_SequenceOfPnt2d.hxx
BOPCol_SequenceOfReal.hxx
BOPCol_SequenceOfShape.hxx

12
src/BOPDS/BOPDS_CommonBlock.cxx
View File

@ -87,7 +87,7 @@ IMPLEMENT_STANDARD_RTTIEXT(BOPDS_CommonBlock,Standard_Transient)
// function: AddFaces
// purpose:
//=======================================================================
void BOPDS_CommonBlock::SetFaces(const BOPCol_ListOfInteger& aLF)
void BOPDS_CommonBlock::SetFaces(const TColStd_ListOfInteger& aLF)
{
myFaces=aLF;
}
@ -95,7 +95,7 @@ IMPLEMENT_STANDARD_RTTIEXT(BOPDS_CommonBlock,Standard_Transient)
// function: AppendFaces
// purpose:
//=======================================================================
void BOPDS_CommonBlock::AppendFaces(BOPCol_ListOfInteger& aLF)
void BOPDS_CommonBlock::AppendFaces(TColStd_ListOfInteger& aLF)
{
myFaces.Append(aLF);
}
@ -103,7 +103,7 @@ void BOPDS_CommonBlock::AppendFaces(BOPCol_ListOfInteger& aLF)
// function: Faces
// purpose:
//=======================================================================
const BOPCol_ListOfInteger& BOPDS_CommonBlock::Faces()const
const TColStd_ListOfInteger& BOPDS_CommonBlock::Faces()const
{
return myFaces;
}
@ -144,7 +144,7 @@ void BOPDS_CommonBlock::AppendFaces(BOPCol_ListOfInteger& aLF)
{
Standard_Boolean bFound;
Standard_Integer nF;
BOPCol_ListIteratorOfListOfInteger anIt;
TColStd_ListIteratorOfListOfInteger anIt;
//
bFound=Standard_False;
anIt.Initialize(myFaces);
@ -236,7 +236,7 @@ void BOPDS_CommonBlock::AppendFaces(BOPCol_ListOfInteger& aLF)
Standard_Boolean BOPDS_CommonBlock::Contains(const Standard_Integer theF)const
{
Standard_Boolean bFound;
BOPCol_ListIteratorOfListOfInteger aIt;
TColStd_ListIteratorOfListOfInteger aIt;
//
bFound=Standard_False;
aIt.Initialize(myFaces);
@ -254,7 +254,7 @@ void BOPDS_CommonBlock::AppendFaces(BOPCol_ListOfInteger& aLF)
void BOPDS_CommonBlock::Dump()const
{
Standard_Integer nF;
BOPCol_ListIteratorOfListOfInteger aIt;
TColStd_ListIteratorOfListOfInteger aIt;
BOPDS_ListIteratorOfListOfPaveBlock aItPB;
//
printf(" -- CB:\n");

18
src/BOPDS/BOPDS_CommonBlock.hxx
View File

@ -19,11 +19,11 @@
#include <Standard_Type.hxx>
#include <BOPDS_ListOfPaveBlock.hxx>
#include <BOPCol_ListOfInteger.hxx>
#include <Standard_Transient.hxx>
#include <BOPCol_BaseAllocator.hxx>
#include <Standard_Integer.hxx>
#include <NCollection_BaseAllocator.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Transient.hxx>
#include <TColStd_ListOfInteger.hxx>
class BOPDS_PaveBlock;
@ -51,7 +51,7 @@ public:
//! Contructor
//! <theAllocator> - the allocator to manage the memory
Standard_EXPORT BOPDS_CommonBlock(const BOPCol_BaseAllocator& theAllocator);
Standard_EXPORT BOPDS_CommonBlock(const Handle(NCollection_BaseAllocator)& theAllocator);
//! Modifier
@ -77,13 +77,13 @@ public:
//! Modifier
//! Sets the list of indices of faces <aLF>
//! of the common block
Standard_EXPORT void SetFaces (const BOPCol_ListOfInteger& aLF);
Standard_EXPORT void SetFaces (const TColStd_ListOfInteger& aLF);
//! Modifier
//! Appends the list of indices of faces <aLF>
//! to the list of indices of faces
//! of the common block (the input list is emptied)
Standard_EXPORT void AppendFaces(BOPCol_ListOfInteger& aLF);
Standard_EXPORT void AppendFaces(TColStd_ListOfInteger& aLF);
//! Selector
@ -95,7 +95,7 @@ public:
//! Selector
//! Returns the list of indices of faces
//! of the common block
Standard_EXPORT const BOPCol_ListOfInteger& Faces() const;
Standard_EXPORT const TColStd_ListOfInteger& Faces() const;
//! Selector
@ -158,7 +158,7 @@ protected:
BOPDS_ListOfPaveBlock myPaveBlocks;
BOPCol_ListOfInteger myFaces;
TColStd_ListOfInteger myFaces;
private:

18
src/BOPDS/BOPDS_Curve.hxx
View File

@ -19,12 +19,12 @@
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <BOPCol_BaseAllocator.hxx>
#include <IntTools_Curve.hxx>
#include <BOPDS_ListOfPaveBlock.hxx>
#include <BOPCol_ListOfInteger.hxx>
#include <Bnd_Box.hxx>
#include <BOPDS_ListOfPaveBlock.hxx>
#include <IntTools_Curve.hxx>
#include <NCollection_BaseAllocator.hxx>
#include <Standard_Boolean.hxx>
#include <TColStd_ListOfInteger.hxx>
class IntTools_Curve;
class Bnd_Box;
class BOPDS_PaveBlock;
@ -48,7 +48,7 @@ virtual ~BOPDS_Curve();
//! Contructor
//! <theAllocator> - the allocator to manage the memory
BOPDS_Curve(const BOPCol_BaseAllocator& theAllocator);
BOPDS_Curve(const Handle(NCollection_BaseAllocator)& theAllocator);
//! Modifier
@ -104,13 +104,13 @@ virtual ~BOPDS_Curve();
//! Selector
//! Returns list of indices of technologic vertices
//! of the curve
const BOPCol_ListOfInteger& TechnoVertices() const;
const TColStd_ListOfInteger& TechnoVertices() const;
//! Selector/Modifier
//! Returns list of indices of technologic vertices
//! of the curve
BOPCol_ListOfInteger& ChangeTechnoVertices();
TColStd_ListOfInteger& ChangeTechnoVertices();
//! Query
@ -138,10 +138,10 @@ virtual ~BOPDS_Curve();
protected:
BOPCol_BaseAllocator myAllocator;
Handle(NCollection_BaseAllocator) myAllocator;
IntTools_Curve myCurve;
BOPDS_ListOfPaveBlock myPaveBlocks;
BOPCol_ListOfInteger myTechnoVertices;
TColStd_ListOfInteger myTechnoVertices;
Bnd_Box myBox;
Standard_Real myTolerance;

4
src/BOPDS/BOPDS_Curve.lxx
View File

@ -115,7 +115,7 @@
//function : TechnoVertices
//purpose :
//=======================================================================
inline const BOPCol_ListOfInteger& BOPDS_Curve::TechnoVertices()const
inline const TColStd_ListOfInteger& BOPDS_Curve::TechnoVertices()const
{
return myTechnoVertices;
}
@ -123,7 +123,7 @@
//function : ChangeTechnoVertices
//purpose :
//=======================================================================
inline BOPCol_ListOfInteger& BOPDS_Curve::ChangeTechnoVertices()
inline TColStd_ListOfInteger& BOPDS_Curve::ChangeTechnoVertices()
{
return myTechnoVertices;
}

160
src/BOPDS/BOPDS_DS.cxx
View File

@ -14,10 +14,6 @@
#include <Bnd_Box.hxx>
#include <BOPCol_DataMapOfIntegerMapOfInteger.hxx>
#include <BOPCol_DataMapOfShapeInteger.hxx>
#include <BOPCol_ListOfInteger.hxx>
#include <BOPCol_MapOfInteger.hxx>
#include <BOPDS_CommonBlock.hxx>
#include <BOPDS_DS.hxx>
#include <BOPDS_FaceInfo.hxx>
@ -49,16 +45,18 @@
#include <TopoDS_Iterator.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Vertex.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <BOPCol_DataMapOfIntegerListOfInteger.hxx>
#include <TColStd_DataMapOfIntegerListOfInteger.hxx>
#include <TColStd_ListOfInteger.hxx>
#include <TColStd_MapOfInteger.hxx>
#include <TopTools_DataMapOfShapeInteger.hxx>
#include <TopTools_MapOfShape.hxx>
#include <algorithm>
//
static
void TotalShapes(const TopoDS_Shape& aS,
Standard_Integer& aNbS,
BOPCol_MapOfShape& aMS);
TopTools_MapOfShape& aMS);
static
Standard_Real ComputeParameter(const TopoDS_Vertex& aV,
@ -168,7 +166,7 @@ void BOPDS_DS::Clear()
//function : SetArguments
//purpose :
//=======================================================================
void BOPDS_DS::SetArguments(const BOPCol_ListOfShape& theLS)
void BOPDS_DS::SetArguments(const TopTools_ListOfShape& theLS)
{
myArguments=theLS;
}
@ -176,7 +174,7 @@ void BOPDS_DS::SetArguments(const BOPCol_ListOfShape& theLS)
//function : Arguments
//purpose :
//=======================================================================
const BOPCol_ListOfShape& BOPDS_DS::Arguments()const
const TopTools_ListOfShape& BOPDS_DS::Arguments()const
{
return myArguments;
}
@ -255,8 +253,8 @@ Standard_Integer BOPDS_DS::Append(const BOPDS_ShapeInfo& theSI)
{
Standard_Integer iX;
//
myLines.Append1()=theSI;
iX=myLines.Extent()-1;
myLines.Appended()=theSI;
iX=myLines.Length()-1;
myMapShapeIndex.Bind(theSI.Shape(), iX);
//
return iX;
@ -269,8 +267,8 @@ Standard_Integer BOPDS_DS::Append(const TopoDS_Shape& theS)
{
Standard_Integer iX;
//
myLines.Append1().SetShape(theS);
iX=myLines.Extent()-1;
myLines.Appended().SetShape(theS);
iX=myLines.Length()-1;
myMapShapeIndex.Bind(theS, iX);
return iX;
}
@ -330,11 +328,11 @@ void BOPDS_DS::Init(const Standard_Real theFuzz)
Standard_Real aTol, aTolAdd;
TopAbs_ShapeEnum aTS;
TopoDS_Iterator aItS;
BOPCol_ListIteratorOfListOfInteger aIt1, aIt2, aIt3;
BOPCol_ListIteratorOfListOfShape aIt;
TColStd_ListIteratorOfListOfInteger aIt1, aIt2, aIt3;
TopTools_ListIteratorOfListOfShape aIt;
BOPDS_IndexRange aR;
Handle(NCollection_BaseAllocator) aAllocator;
BOPCol_MapOfShape aMS;
TopTools_MapOfShape aMS;
//
// 1 Append Source Shapes
aNb=myArguments.Extent();
@ -424,7 +422,7 @@ void BOPDS_DS::Init(const Standard_Real theFuzz)
BRep_Builder aBB;
BOPDS_ShapeInfo aSIx;
//
BOPCol_ListOfInteger& aLI=aSI.ChangeSubShapes();
TColStd_ListOfInteger& aLI=aSI.ChangeSubShapes();
//
aEx=aE;
aEx.Orientation(TopAbs_FORWARD);
@ -465,7 +463,7 @@ void BOPDS_DS::Init(const Standard_Real theFuzz)
Bnd_Box& aBox=aSI.ChangeBox();
BRepBndLib::Add(aE, aBox);
//
const BOPCol_ListOfInteger& aLV=aSI.SubShapes();
const TColStd_ListOfInteger& aLV=aSI.SubShapes();
aIt1.Initialize(aLV);
for (; aIt1.More(); aIt1.Next()) {
nV=aIt1.Value();
@ -478,8 +476,8 @@ void BOPDS_DS::Init(const Standard_Real theFuzz)
}
}
// 2.3 Face
BOPCol_MapOfInteger aMI(100, aAllocator);
BOPCol_MapIteratorOfMapOfInteger aItMI;
TColStd_MapOfInteger aMI(100, aAllocator);
TColStd_MapIteratorOfMapOfInteger aItMI;
//
aNbF=0;
for (j=0; j<myNbSourceShapes; ++j) {
@ -492,13 +490,13 @@ void BOPDS_DS::Init(const Standard_Real theFuzz)
Bnd_Box& aBox=aSI.ChangeBox();
BRepBndLib::Add(aS, aBox);
//
BOPCol_ListOfInteger& aLW=aSI.ChangeSubShapes();
TColStd_ListOfInteger& aLW=aSI.ChangeSubShapes();
aIt1.Initialize(aLW);
for (; aIt1.More(); aIt1.Next()) {
nW=aIt1.Value();
BOPDS_ShapeInfo& aSIW=ChangeShapeInfo(nW);
//
const BOPCol_ListOfInteger& aLE=aSIW.SubShapes();
const TColStd_ListOfInteger& aLE=aSIW.SubShapes();
aIt2.Initialize(aLE);
for (; aIt2.More(); aIt2.Next()) {
nE=aIt2.Value();
@ -512,7 +510,7 @@ void BOPDS_DS::Init(const Standard_Real theFuzz)
aSIE.SetFlag(j);
}
//
const BOPCol_ListOfInteger& aLV=aSIE.SubShapes();
const TColStd_ListOfInteger& aLV=aSIE.SubShapes();
aIt3.Initialize(aLV);
for (; aIt3.More(); aIt3.Next()) {
nV=aIt3.Value();
@ -564,7 +562,7 @@ void BOPDS_DS::Init(const Standard_Real theFuzz)
//
// update sub-shapes by BRep comprising ones
aMI.Clear();
BOPCol_ListOfInteger& aLI1=aSI.ChangeSubShapes();
TColStd_ListOfInteger& aLI1=aSI.ChangeSubShapes();
//
aIt1.Initialize(aLI1);
for (; aIt1.More(); aIt1.Next()) {
@ -574,7 +572,7 @@ void BOPDS_DS::Init(const Standard_Real theFuzz)
continue;
}
//
const BOPCol_ListOfInteger& aLI2=aSI1.SubShapes();
const TColStd_ListOfInteger& aLI2=aSI1.SubShapes();
aIt2.Initialize(aLI2);
for (; aIt2.More(); aIt2.Next()) {
n2=aIt2.Value();
@ -585,7 +583,7 @@ void BOPDS_DS::Init(const Standard_Real theFuzz)
//
aMI.Add(n2);
//
const BOPCol_ListOfInteger& aLI3=aSI2.SubShapes();
const TColStd_ListOfInteger& aLI3=aSI2.SubShapes();
aIt3.Initialize(aLI3);
for (; aIt3.More(); aIt3.Next()) {
n3=aIt3.Value();
@ -614,14 +612,14 @@ void BOPDS_DS::Init(const Standard_Real theFuzz)
if (aSI.ShapeType() != TopAbs_EDGE)
continue;
const BOPCol_ListOfInteger& aLV = aSI.SubShapes();
const TColStd_ListOfInteger& aLV = aSI.SubShapes();
aIt1.Initialize(aLV);
for (; aIt1.More(); aIt1.Next())
{
nV = aIt1.Value();
BOPCol_ListOfInteger* pLE = myMapVE.ChangeSeek(nV);
TColStd_ListOfInteger* pLE = myMapVE.ChangeSeek(nV);
if (!pLE) {
pLE = myMapVE.Bound(nV, BOPCol_ListOfInteger(myAllocator));
pLE = myMapVE.Bound(nV, TColStd_ListOfInteger(myAllocator));
pLE->Append(nE);
}
else
@ -653,13 +651,13 @@ void BOPDS_DS::InitShape
{
Standard_Integer aIx;
TopoDS_Iterator aIt;
BOPCol_ListIteratorOfListOfInteger aIt1;
TColStd_ListIteratorOfListOfInteger aIt1;
//
BOPDS_ShapeInfo& aSI=ChangeShapeInfo(aI);
aSI.SetShapeType(aS.ShapeType());
BOPCol_ListOfInteger& aLI=aSI.ChangeSubShapes();
TColStd_ListOfInteger& aLI=aSI.ChangeSubShapes();
//
BOPCol_MapOfInteger aM;
TColStd_MapOfInteger aM;
//
aIt1.Initialize(aLI);
for (; aIt1.More(); aIt1.Next()) {
@ -715,11 +713,11 @@ Standard_Boolean BOPDS_DS::HasInterfShapeSubShapes
{
Standard_Boolean bRet;
Standard_Integer n2;
BOPCol_ListIteratorOfListOfInteger aIt;
TColStd_ListIteratorOfListOfInteger aIt;
bRet = Standard_False;
//
const BOPDS_ShapeInfo& aSI=ShapeInfo(theI2);
const BOPCol_ListOfInteger& aLI=aSI.SubShapes();
const TColStd_ListOfInteger& aLI=aSI.SubShapes();
aIt.Initialize(aLI);
for (; aIt.More(); aIt.Next()) {
n2=aIt.Value();
@ -747,11 +745,11 @@ Standard_Boolean BOPDS_DS::HasInterfSubShapes
{
Standard_Boolean bRet;
Standard_Integer n1;
BOPCol_ListIteratorOfListOfInteger aIt;
TColStd_ListIteratorOfListOfInteger aIt;
bRet = Standard_False;
//
const BOPDS_ShapeInfo& aSI=ShapeInfo(theI1);
const BOPCol_ListOfInteger& aLI=aSI.SubShapes();
const TColStd_ListOfInteger& aLI=aSI.SubShapes();
aIt.Initialize(aLI);
for (; aIt.More(); aIt.Next()) {
n1=aIt.Value();
@ -835,7 +833,7 @@ void BOPDS_DS::InitPaveBlocks(const Standard_Integer theI)
Standard_Real aT;
TopAbs_Orientation aOrE;
TopoDS_Vertex aV;
BOPCol_ListIteratorOfListOfInteger aIt;
TColStd_ListIteratorOfListOfInteger aIt;
BOPDS_Pave aPave;
Handle(BOPDS_PaveBlock) aPB;
//
@ -843,7 +841,7 @@ void BOPDS_DS::InitPaveBlocks(const Standard_Integer theI)
const TopoDS_Edge& aE=*(TopoDS_Edge*)(&aSI.Shape());
aOrE=aE.Orientation();
//
const BOPCol_ListOfInteger& aLV=aSI.SubShapes();
const TColStd_ListOfInteger& aLV=aSI.SubShapes();
aNbV=aLV.Extent();
if (!aNbV) {
return;
@ -912,8 +910,8 @@ void BOPDS_DS::InitPaveBlocks(const Standard_Integer theI)
}
}
//
BOPDS_ListOfPaveBlock &aLPB=myPaveBlocksPool.Append1();
iRef=myPaveBlocksPool.Extent()-1;
BOPDS_ListOfPaveBlock &aLPB=myPaveBlocksPool.Appended();
iRef=myPaveBlocksPool.Length()-1;
//
aPB->Update(aLPB, Standard_False);
aSI.SetReference(iRef);
@ -1006,7 +1004,7 @@ void BOPDS_DS::UpdateCommonBlock(const Handle(BOPDS_CommonBlock)& theCB,
return;
}
//
const BOPCol_ListOfInteger& aLF=theCB->Faces();
const TColStd_ListOfInteger& aLF=theCB->Faces();
//
BOPDS_VectorOfListOfPaveBlock& aPBP=myPaveBlocksPool;
//
@ -1221,8 +1219,8 @@ void BOPDS_DS::InitFaceInfo(const Standard_Integer theI)
Standard_Integer iRef;
//
BOPDS_ShapeInfo& aSI=ChangeShapeInfo(theI);
BOPDS_FaceInfo &aFI=myFaceInfoPool.Append1();
iRef=myFaceInfoPool.Extent()-1;
BOPDS_FaceInfo &aFI=myFaceInfoPool.Appended();
iRef=myFaceInfoPool.Length()-1;
aSI.SetReference(iRef);
//
aFI.SetIndex(theI);
@ -1243,7 +1241,7 @@ void BOPDS_DS::UpdateFaceInfoIn(const Standard_Integer theI)
BOPDS_FaceInfo &aFI=myFaceInfoPool(iRef);
//
BOPDS_IndexedMapOfPaveBlock& aMPBIn=aFI.ChangePaveBlocksIn();
BOPCol_MapOfInteger& aMVIn=aFI.ChangeVerticesIn();
TColStd_MapOfInteger& aMVIn=aFI.ChangeVerticesIn();
aMPBIn.Clear();
aMVIn.Clear();
FaceInfoIn(theI, aMPBIn, aMVIn);
@ -1263,7 +1261,7 @@ void BOPDS_DS::UpdateFaceInfoOn(const Standard_Integer theI)
BOPDS_FaceInfo &aFI=myFaceInfoPool(iRef);
//
BOPDS_IndexedMapOfPaveBlock& aMPBOn=aFI.ChangePaveBlocksOn();
BOPCol_MapOfInteger& aMVOn=aFI.ChangeVerticesOn();
TColStd_MapOfInteger& aMVOn=aFI.ChangeVerticesOn();
aMPBOn.Clear();
aMVOn.Clear();
FaceInfoOn(theI, aMPBOn, aMVOn);
@ -1275,14 +1273,14 @@ void BOPDS_DS::UpdateFaceInfoOn(const Standard_Integer theI)
//=======================================================================
void BOPDS_DS::FaceInfoOn(const Standard_Integer theF,
BOPDS_IndexedMapOfPaveBlock& theMPB,
BOPCol_MapOfInteger& theMI)
TColStd_MapOfInteger& theMI)
{
Standard_Integer nS, nSD, nV1, nV2;
BOPCol_ListIteratorOfListOfInteger aIt;
TColStd_ListIteratorOfListOfInteger aIt;
BOPDS_ListIteratorOfListOfPaveBlock aItPB;
//
const BOPDS_ShapeInfo& aSI=ShapeInfo(theF);
const BOPCol_ListOfInteger& aLI=aSI.SubShapes();
const TColStd_ListOfInteger& aLI=aSI.SubShapes();
aIt.Initialize(aLI);
for (; aIt.More(); aIt.Next()) {
nS=aIt.Value();
@ -1314,7 +1312,7 @@ void BOPDS_DS::FaceInfoOn(const Standard_Integer theF,
//=======================================================================
void BOPDS_DS::FaceInfoIn(const Standard_Integer theF,
BOPDS_IndexedMapOfPaveBlock& theMPB,
BOPCol_MapOfInteger& theMI)
TColStd_MapOfInteger& theMI)
{
Standard_Integer i, aNbVF, aNbEF, nV, nE, nVSD;
TopoDS_Iterator aItS;
@ -1336,7 +1334,7 @@ void BOPDS_DS::FaceInfoIn(const Standard_Integer theF,
//
// 2. aVFs
BOPDS_VectorOfInterfVF& aVFs=InterfVF();
aNbVF=aVFs.Extent();
aNbVF=aVFs.Length();
for (i=0; i<aNbVF; ++i) {
BOPDS_InterfVF& aVF=aVFs(i);
if(aVF.Contains(theF)) {
@ -1350,7 +1348,7 @@ void BOPDS_DS::FaceInfoIn(const Standard_Integer theF,
//
// 3. aEFs
BOPDS_VectorOfInterfEF& aEFs=InterfEF();
aNbEF=aEFs.Extent();
aNbEF=aEFs.Length();
for (i=0; i<aNbEF; ++i) {
BOPDS_InterfEF& aEF=aEFs(i);
if(aEF.Contains(theF)) {
@ -1388,7 +1386,7 @@ void BOPDS_DS::RefineFaceInfoOn()
Standard_Integer i, aNb, nF, aNbPB, j;
BOPDS_IndexedMapOfPaveBlock aMPB;
//
aNb=myFaceInfoPool.Extent();
aNb=myFaceInfoPool.Length();
for (i=0; i<aNb; ++i) {
BOPDS_FaceInfo &aFI=myFaceInfoPool(i);
nF=aFI.Index();
@ -1413,14 +1411,14 @@ void BOPDS_DS::RefineFaceInfoOn()
//purpose :
//=======================================================================
void BOPDS_DS::AloneVertices(const Standard_Integer theI,
BOPCol_ListOfInteger& theLI)const
TColStd_ListOfInteger& theLI)const
{
if (HasFaceInfo(theI)) {
//
Standard_Integer i, j, nV1, nV2, nV, aNbPB;
BOPCol_MapIteratorOfMapOfInteger aItMI;
TColStd_MapIteratorOfMapOfInteger aItMI;
//
BOPCol_MapOfInteger aMI(100, myAllocator);
TColStd_MapOfInteger aMI(100, myAllocator);
//
const BOPDS_FaceInfo& aFI=FaceInfo(theI);
//
@ -1437,7 +1435,7 @@ void BOPDS_DS::AloneVertices(const Standard_Integer theI,
}
//
for (i=0; i<2; ++i) {
const BOPCol_MapOfInteger& aMIV=
const TColStd_MapOfInteger& aMIV=
(!i) ? aFI.VerticesIn() : aFI.VerticesSc();
aItMI.Initialize(aMIV);
for (; aItMI.More(); aItMI.Next()) {
@ -1458,12 +1456,12 @@ void BOPDS_DS::AloneVertices(const Standard_Integer theI,
void BOPDS_DS::SubShapesOnIn
(const Standard_Integer nF1,
const Standard_Integer nF2,
BOPCol_MapOfInteger& theMVOnIn,
TColStd_MapOfInteger& theMVOnIn,
BOPDS_IndexedMapOfPaveBlock& thePBOnIn,
BOPDS_MapOfPaveBlock& theCommonPB)const
{
Standard_Integer i, j, nV, nV1, nV2, aNbPB;
BOPCol_MapIteratorOfMapOfInteger aIt;
TColStd_MapIteratorOfMapOfInteger aIt;
BOPDS_IndexedMapOfPaveBlock pMPB[4];
//
const BOPDS_FaceInfo& aFI1=FaceInfo(nF1);
@ -1489,13 +1487,13 @@ void BOPDS_DS::SubShapesOnIn
}
}
//
const BOPCol_MapOfInteger& aMVOn1=aFI1.VerticesOn();
const BOPCol_MapOfInteger& aMVIn1=aFI1.VerticesIn();
const BOPCol_MapOfInteger& aMVOn2=aFI2.VerticesOn();
const BOPCol_MapOfInteger& aMVIn2=aFI2.VerticesIn();
const TColStd_MapOfInteger& aMVOn1=aFI1.VerticesOn();
const TColStd_MapOfInteger& aMVIn1=aFI1.VerticesIn();
const TColStd_MapOfInteger& aMVOn2=aFI2.VerticesOn();
const TColStd_MapOfInteger& aMVIn2=aFI2.VerticesIn();
//
for (i=0; i<2; ++i) {
const BOPCol_MapOfInteger& aMV1=(!i) ? aMVOn1 : aMVIn1;
const TColStd_MapOfInteger& aMV1=(!i) ? aMVOn1 : aMVIn1;
aIt.Initialize(aMV1);
for (; aIt.More(); aIt.Next()) {
nV=aIt.Value();
@ -1511,16 +1509,16 @@ void BOPDS_DS::SubShapesOnIn
//=======================================================================
void BOPDS_DS::SharedEdges(const Standard_Integer nF1,
const Standard_Integer nF2,
BOPCol_ListOfInteger& theLI,
TColStd_ListOfInteger& theLI,
const Handle(NCollection_BaseAllocator)& aAllocator)
{
Standard_Integer nE, nSp;
BOPCol_ListIteratorOfListOfInteger aItLI;
TColStd_ListIteratorOfListOfInteger aItLI;
BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
BOPCol_MapOfInteger aMI(100, aAllocator);
TColStd_MapOfInteger aMI(100, aAllocator);
//
const BOPDS_ShapeInfo& aSI1=ShapeInfo(nF1);
const BOPCol_ListOfInteger& aLI1=aSI1.SubShapes();
const TColStd_ListOfInteger& aLI1=aSI1.SubShapes();
aItLI.Initialize(aLI1);
for (; aItLI.More(); aItLI.Next()) {
nE=aItLI.Value();
@ -1542,7 +1540,7 @@ void BOPDS_DS::SharedEdges(const Standard_Integer nF1,
}
//
const BOPDS_ShapeInfo& aSI2=ShapeInfo(nF2);
const BOPCol_ListOfInteger& aLI2=aSI2.SubShapes();
const TColStd_ListOfInteger& aLI2=aSI2.SubShapes();
aItLI.Initialize(aLI2);
for (; aItLI.More(); aItLI.Next()) {
nE=aItLI.Value();
@ -1576,7 +1574,7 @@ void BOPDS_DS::SharedEdges(const Standard_Integer nF1,
//function : ShapesSD
//purpose :
//=======================================================================
BOPCol_DataMapOfIntegerInteger& BOPDS_DS::ShapesSD()
TColStd_DataMapOfIntegerInteger& BOPDS_DS::ShapesSD()
{
return myShapesSD;
}
@ -1697,10 +1695,10 @@ Standard_Boolean BOPDS_DS::IsSubShape
Standard_Integer nS;
bRet = Standard_False;
//
BOPCol_ListIteratorOfListOfInteger aItLI;
TColStd_ListIteratorOfListOfInteger aItLI;
//
const BOPDS_ShapeInfo& aSI = ShapeInfo(theI2);
const BOPCol_ListOfInteger& aLI = aSI.SubShapes();
const TColStd_ListOfInteger& aLI = aSI.SubShapes();
aItLI.Initialize(aLI);
for(;aItLI.More(); aItLI.Next()) {
nS = aItLI.Value();
@ -1768,7 +1766,7 @@ void BOPDS_DS::UpdateEdgeTolerance(const Standard_Integer nE,
Standard_Integer nV;
Standard_Real aTolV;
BRep_Builder aBB;
BOPCol_ListIteratorOfListOfInteger aIt;
TColStd_ListIteratorOfListOfInteger aIt;
//
Standard_Real aTolAdd = Max(theFuzz, Precision::Confusion()) * 0.5;
@ -1779,7 +1777,7 @@ void BOPDS_DS::UpdateEdgeTolerance(const Standard_Integer nE,
BRepBndLib::Add(aE, aBoxE);
aBoxE.SetGap(aBoxE.GetGap() + aTolAdd);
//
const BOPCol_ListOfInteger& aLI = aSIE.SubShapes();
const TColStd_ListOfInteger& aLI = aSIE.SubShapes();
aIt.Initialize(aLI);
for (; aIt.More(); aIt.Next()) {
nV = aIt.Value();
@ -1800,7 +1798,7 @@ void BOPDS_DS::UpdateEdgeTolerance(const Standard_Integer nE,
//=======================================================================
void TotalShapes(const TopoDS_Shape& aS,
Standard_Integer& aNbS,
BOPCol_MapOfShape& aMS)
TopTools_MapOfShape& aMS)
{
if (aMS.Add(aS)) {
TopoDS_Iterator aIt;
@ -1862,7 +1860,7 @@ void BOPDS_DS::BuildBndBoxSolid(const Standard_Integer theIndex,
Standard_Boolean bIsOpenBox, bIsInverted;
Standard_Integer nSh, nFc;
Standard_Real aTolS, aTolFc;
BOPCol_ListIteratorOfListOfInteger aItLI, aItLI1;
TColStd_ListIteratorOfListOfInteger aItLI, aItLI1;
//
const BOPDS_ShapeInfo& aSI=ShapeInfo(theIndex);
const TopoDS_Shape& aS=aSI.Shape();
@ -1871,7 +1869,7 @@ void BOPDS_DS::BuildBndBoxSolid(const Standard_Integer theIndex,
bIsOpenBox=Standard_False;
//
aTolS=0.;
const BOPCol_ListOfInteger& aLISh=aSI.SubShapes();
const TColStd_ListOfInteger& aLISh=aSI.SubShapes();
aItLI.Initialize(aLISh);
for (; aItLI.More(); aItLI.Next()) {
nSh=aItLI.Value();
@ -1880,7 +1878,7 @@ void BOPDS_DS::BuildBndBoxSolid(const Standard_Integer theIndex,
continue;
}
//
const BOPCol_ListOfInteger& aLIFc=aSISh.SubShapes();
const TColStd_ListOfInteger& aLIFc=aSISh.SubShapes();
aItLI1.Initialize(aLIFc);
for (; aItLI1.More(); aItLI1.Next()) {
nFc=aItLI1.Value();
@ -1997,11 +1995,11 @@ void BOPDS_DS::UpdateCommonBlockWithSDVertices
//=======================================================================
void BOPDS_DS::InitPaveBlocksForVertex(const Standard_Integer theNV)
{
const BOPCol_ListOfInteger* pLE = myMapVE.Seek(theNV);
const TColStd_ListOfInteger* pLE = myMapVE.Seek(theNV);
if (!pLE)
return;
BOPCol_ListIteratorOfListOfInteger aItLE(*pLE);
TColStd_ListIteratorOfListOfInteger aItLE(*pLE);
for (; aItLE.More(); aItLE.Next())
ChangePaveBlocks(aItLE.Value());
}
@ -2023,7 +2021,7 @@ void BOPDS_DS::ReleasePaveBlocks()
// of pave blocks will stay to mark the edge as Deleted.
BOPDS_VectorOfListOfPaveBlock& aPBP = ChangePaveBlocksPool();
Standard_Integer aNbPBP = aPBP.Extent();
Standard_Integer aNbPBP = aPBP.Length();
if (!aNbPBP) {
return;
}

77
src/BOPDS/BOPDS_DS.hxx
View File

@ -19,37 +19,38 @@
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <BOPCol_BaseAllocator.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <Standard_Integer.hxx>
#include <BOPDS_VectorOfIndexRange.hxx>
#include <BOPDS_VectorOfShapeInfo.hxx>
#include <BOPCol_DataMapOfShapeInteger.hxx>
#include <BOPDS_VectorOfListOfPaveBlock.hxx>
#include <BOPDS_DataMapOfPaveBlockCommonBlock.hxx>
#include <BOPDS_VectorOfFaceInfo.hxx>
#include <BOPCol_DataMapOfIntegerInteger.hxx>
#include <BOPCol_DataMapOfIntegerListOfInteger.hxx>
#include <BOPDS_IndexedMapOfPaveBlock.hxx>
#include <BOPDS_ListOfPave.hxx>
#include <BOPDS_ListOfPaveBlock.hxx>
#include <BOPDS_MapOfPair.hxx>
#include <BOPDS_VectorOfInterfVV.hxx>
#include <BOPDS_VectorOfInterfVE.hxx>
#include <BOPDS_VectorOfInterfVF.hxx>
#include <BOPDS_MapOfPaveBlock.hxx>
#include <BOPDS_VectorOfFaceInfo.hxx>
#include <BOPDS_VectorOfIndexRange.hxx>
#include <BOPDS_VectorOfInterfEE.hxx>
#include <BOPDS_VectorOfInterfEF.hxx>
#include <BOPDS_VectorOfInterfFF.hxx>
#include <BOPDS_VectorOfInterfVZ.hxx>
#include <BOPDS_VectorOfInterfEZ.hxx>
#include <BOPDS_VectorOfInterfFF.hxx>
#include <BOPDS_VectorOfInterfFZ.hxx>
#include <BOPDS_VectorOfInterfVE.hxx>
#include <BOPDS_VectorOfInterfVF.hxx>
#include <BOPDS_VectorOfInterfVV.hxx>
#include <BOPDS_VectorOfInterfVZ.hxx>
#include <BOPDS_VectorOfInterfZZ.hxx>
#include <Standard_Real.hxx>
#include <Standard_Boolean.hxx>
#include <BOPDS_ListOfPaveBlock.hxx>
#include <BOPDS_IndexedMapOfPaveBlock.hxx>
#include <BOPDS_MapOfPaveBlock.hxx>
#include <BOPCol_MapOfInteger.hxx>
#include <BOPCol_ListOfInteger.hxx>
#include <BOPDS_ListOfPave.hxx>
#include <BOPDS_VectorOfListOfPaveBlock.hxx>
#include <BOPDS_VectorOfShapeInfo.hxx>
#include <NCollection_BaseAllocator.hxx>
#include <Precision.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
#include <TColStd_DataMapOfIntegerInteger.hxx>
#include <TColStd_DataMapOfIntegerListOfInteger.hxx>
#include <TColStd_ListOfInteger.hxx>
#include <TColStd_MapOfInteger.hxx>
#include <TopTools_DataMapOfShapeInteger.hxx>
#include <TopTools_ListOfShape.hxx>
class BOPDS_IndexRange;
class BOPDS_ShapeInfo;
class TopoDS_Shape;
@ -92,7 +93,7 @@ Standard_EXPORT virtual ~BOPDS_DS();
//! Contructor
//! theAllocator - the allocator to manage the memory
Standard_EXPORT BOPDS_DS(const BOPCol_BaseAllocator& theAllocator);
Standard_EXPORT BOPDS_DS(const Handle(NCollection_BaseAllocator)& theAllocator);
//! Clears the contents
@ -100,17 +101,17 @@ Standard_EXPORT virtual ~BOPDS_DS();
//! Selector
Standard_EXPORT const BOPCol_BaseAllocator& Allocator() const;
Standard_EXPORT const Handle(NCollection_BaseAllocator)& Allocator() const;
//! Modifier
//! Sets the arguments [theLS] of an operation
Standard_EXPORT void SetArguments (const BOPCol_ListOfShape& theLS);
Standard_EXPORT void SetArguments (const TopTools_ListOfShape& theLS);
//! Selector
//! Returns the arguments of an operation
Standard_EXPORT const BOPCol_ListOfShape& Arguments() const;
Standard_EXPORT const TopTools_ListOfShape& Arguments() const;
//! Initializes the data structure for
@ -281,19 +282,19 @@ Standard_EXPORT virtual ~BOPDS_DS();
//! Selector
//! Returns the state On
//! [theMPB,theMVP] of face with index theIndex
Standard_EXPORT void FaceInfoOn (const Standard_Integer theIndex, BOPDS_IndexedMapOfPaveBlock& theMPB, BOPCol_MapOfInteger& theMVP);
Standard_EXPORT void FaceInfoOn (const Standard_Integer theIndex, BOPDS_IndexedMapOfPaveBlock& theMPB, TColStd_MapOfInteger& theMVP);
//! Selector
//! Returns the state In
//! [theMPB,theMVP] of face with index theIndex
Standard_EXPORT void FaceInfoIn (const Standard_Integer theIndex, BOPDS_IndexedMapOfPaveBlock& theMPB, BOPCol_MapOfInteger& theMVP);
Standard_EXPORT void FaceInfoIn (const Standard_Integer theIndex, BOPDS_IndexedMapOfPaveBlock& theMPB, TColStd_MapOfInteger& theMVP);
//! Selector
//! Returns the indices of alone vertices
//! for the face with index theIndex
Standard_EXPORT void AloneVertices (const Standard_Integer theF, BOPCol_ListOfInteger& theLI) const;
Standard_EXPORT void AloneVertices (const Standard_Integer theF, TColStd_ListOfInteger& theLI) const;
//! Refine the state On for the all faces having
@ -309,7 +310,7 @@ Standard_EXPORT virtual ~BOPDS_DS();
//! @param theCommonPB the common pave blocks (that are shared by both faces).
Standard_EXPORT void SubShapesOnIn (const Standard_Integer theF1,
const Standard_Integer theF2,
BOPCol_MapOfInteger& theMVOnIn,
TColStd_MapOfInteger& theMVOnIn,
BOPDS_IndexedMapOfPaveBlock& thePBOnIn,
BOPDS_MapOfPaveBlock& theCommonPB) const;
@ -318,12 +319,12 @@ Standard_EXPORT virtual ~BOPDS_DS();
//! for the faces with indices theF1, theF2
//!
//! same domain shapes
Standard_EXPORT void SharedEdges (const Standard_Integer theF1, const Standard_Integer theF2, BOPCol_ListOfInteger& theLI, const BOPCol_BaseAllocator& theAllocator);
Standard_EXPORT void SharedEdges (const Standard_Integer theF1, const Standard_Integer theF2, TColStd_ListOfInteger& theLI, const Handle(NCollection_BaseAllocator)& theAllocator);
//! Selector
//! Returns the collection same domain shapes
Standard_EXPORT BOPCol_DataMapOfIntegerInteger& ShapesSD();
Standard_EXPORT TColStd_DataMapOfIntegerInteger& ShapesSD();
//! Modifier
@ -492,18 +493,18 @@ protected:
const Standard_Real theFuzz);
BOPCol_BaseAllocator myAllocator;
BOPCol_ListOfShape myArguments;
Handle(NCollection_BaseAllocator) myAllocator;
TopTools_ListOfShape myArguments;
Standard_Integer myNbShapes;
Standard_Integer myNbSourceShapes;
BOPDS_VectorOfIndexRange myRanges;
BOPDS_VectorOfShapeInfo myLines;
BOPCol_DataMapOfShapeInteger myMapShapeIndex;
TopTools_DataMapOfShapeInteger myMapShapeIndex;
BOPDS_VectorOfListOfPaveBlock myPaveBlocksPool;
BOPDS_DataMapOfPaveBlockCommonBlock myMapPBCB;
BOPDS_VectorOfFaceInfo myFaceInfoPool;
BOPCol_DataMapOfIntegerInteger myShapesSD;
BOPCol_DataMapOfIntegerListOfInteger myMapVE;
TColStd_DataMapOfIntegerInteger myShapesSD;
TColStd_DataMapOfIntegerListOfInteger myMapVE;
BOPDS_MapOfPair myInterfTB;
BOPDS_VectorOfInterfVV myInterfVV;
BOPDS_VectorOfInterfVE myInterfVE;

Some files were not shown because too many files have changed in this diff Show More