//
#include <GEOMAlgo_Gluer.hxx>
+#include <Basics_OCCTVersion.hxx>
+
#include <NCollection_UBTreeFiller.hxx>
#include <TColStd_MapIteratorOfMapOfInteger.hxx>
myResult=aCmp;
//
if (aMS.Extent()) {
+#if OCC_VERSION_LARGE > 0x07020001
+ TopTools_IndexedMapOfShape aMapToAvoid;
+ BOPTools_AlgoTools::CorrectCurveOnSurface(myResult, aMapToAvoid, 0.0001);
+#else
BOPTools_AlgoTools::CorrectCurveOnSurface(myResult, 0.0001);
+#endif
}
}
//=======================================================================
#include <BOPAlgo_BuilderSolid.hxx>
-#include <BOPTools.hxx>
#include <BOPTools_AlgoTools.hxx>
-#include <BOPCol_MapOfShape.hxx>
+#include <TopTools_MapOfShape.hxx>
//=======================================================================
//function :
TopoDS_Iterator aIt1, aIt2;
TopoDS_Shape aShape;
BRep_Builder aBB;
- BOPCol_MapOfShape aMFence;
- BOPCol_IndexedMapOfShape aMSI;
- BOPCol_IndexedDataMapOfShapeListOfShape aMFS;
- BOPCol_ListOfShape aSFS;
- BOPCol_ListIteratorOfListOfShape aItLS;
+ TopTools_MapOfShape aMFence;
+ TopTools_IndexedMapOfShape aMSI;
+ TopTools_IndexedDataMapOfShapeListOfShape aMFS;
+ TopTools_ListOfShape aSFS;
+ TopTools_ListIteratorOfListOfShape aItLS;
BOPAlgo_BuilderSolid aSB;
//
//modified by NIZNHY-PKV Thu Jul 11 06:54:51 2013f
//
aNbR=aMFence.Extent();
if (aNbS!=aNbR) {
- BOPCol_MapIteratorOfMapOfShape aItMS;
+ TopTools_MapIteratorOfMapOfShape aItMS;
//
BOPTools_AlgoTools::MakeContainer(TopAbs_COMPOUND, aShape);
//
aNbF2=0;
//
// 1. aSFS: Faces
- BOPTools::MapShapesAndAncestors(aShape, TopAbs_FACE, TopAbs_SOLID, aMFS);
+ TopExp::MapShapesAndAncestors(aShape, TopAbs_FACE, TopAbs_SOLID, aMFS);
//
aNbF=aMFS.Extent();
for (i=1; i<=aNbF; ++i) {
aSFS.Append(aFi);
}
else {
- const BOPCol_ListOfShape& aLSx=aMFS(i);
+ const TopTools_ListOfShape& aLSx=aMFS(i);
aNbSx=aLSx.Extent();
if (aNbSx==1) {
aSFS.Append(aFx);
return;
}
//
- const BOPCol_ListOfShape& aLSR=aSB.Areas();
+ const TopTools_ListOfShape& aLSR=aSB.Areas();
//
// 4 Add the internals
if (aNbSI) {
//function : AddInternalShapes
//purpose :
//=======================================================================
-void GEOMAlgo_RemoverWebs::AddInternalShapes(const BOPCol_ListOfShape& aLSR,
- const BOPCol_IndexedMapOfShape& aMSI)
+void GEOMAlgo_RemoverWebs::AddInternalShapes(const TopTools_ListOfShape& aLSR,
+ const TopTools_IndexedMapOfShape& aMSI)
{
Standard_Integer i, aNbSI;
TopAbs_State aState;
TopoDS_Solid aSd;
BRep_Builder aBB;
- BOPCol_ListIteratorOfListOfShape aItLS;
+ TopTools_ListIteratorOfListOfShape aItLS;
Handle(IntTools_Context) aCtx=new IntTools_Context;
//
aNbSI=aMSI.Extent();
#include <Standard_Macro.hxx>
//
#include <GEOMAlgo_ShapeAlgo.hxx>
-#include <BOPCol_ListOfShape.hxx>
-#include <BOPCol_IndexedMapOfShape.hxx>
+#include <TopTools_ListOfShape.hxx>
+#include <TopTools_IndexedMapOfShape.hxx>
//=======================================================================
//function : GEOMAlgo_RemoverWebs
void BuildSolid() ;
Standard_EXPORT
- static void AddInternalShapes(const BOPCol_ListOfShape& ,
- const BOPCol_IndexedMapOfShape& );
+ static void AddInternalShapes(const TopTools_ListOfShape& ,
+ const TopTools_IndexedMapOfShape& );
//
};
#include <BOPTools_AlgoTools.hxx>
-#include <BOPCol_DataMapOfShapeListOfShape.hxx>
-#include <BOPCol_ListOfShape.hxx>
+#include <TopTools_DataMapOfShapeListOfShape.hxx>
+#include <TopTools_ListOfShape.hxx>
#include <IntTools_Context.hxx>
#include <BOPDS_DS.hxx>
#include <BOPAlgo_Builder.hxx>
//
const BOPDS_DS& aDS=myDSFiller->DS();
BOPDS_DS* pDS=(BOPDS_DS*)&aDS;
- const BOPCol_ListOfShape& aLS=pDS->Arguments();
+ const TopTools_ListOfShape& aLS=pDS->Arguments();
//
aNbArgs=aLS.Extent();
if (aNbArgs!=2) {
return;
}
//
- const BOPCol_DataMapOfShapeListOfShape& aImages=aSSB.Images();
+ const TopTools_DataMapOfShapeListOfShape& aImages=aSSB.Images();
//
//-------------------------------
for (i=iBeg; i<=iEnd; ++i) {
aState=BOPTools_AlgoTools::ComputeState(aP, aSolid, aTol, aCtx);
}
else {
- const BOPCol_ListOfShape& aLSp=aImages.Find(aS);
+ const TopTools_ListOfShape& aLSp=aImages.Find(aS);
aNbSp=aLSp.Extent();
if (aNbSp>0) {
continue;
#include <BRep_Builder.hxx>
-#include <BOPCol_MapOfShape.hxx>
-#include <BOPCol_ListOfShape.hxx>
+#include <TopTools_MapOfShape.hxx>
+#include <TopTools_ListOfShape.hxx>
-#include <BOPTools.hxx>
+#include <TopExp.hxx>
static
void TreatCompound(const TopoDS_Shape& aC,
- BOPCol_ListOfShape& aLSX);
+ TopTools_ListOfShape& aLSX);
//=======================================================================
//function :
//function : Tools
//purpose :
//=======================================================================
-const BOPCol_ListOfShape& GEOMAlgo_Splitter::Tools()const
+const TopTools_ListOfShape& GEOMAlgo_Splitter::Tools()const
{
return myTools;
}
{
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()) {
aType=aS.ShapeType();
if (aType==theType && !myMapTools.Contains(aS)) {
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();
Standard_Integer i, aNbS;
BRep_Builder aBB;
TopoDS_Compound aC;
- BOPCol_IndexedMapOfShape aMx;
+ TopTools_IndexedMapOfShape aMx;
//
aBB.MakeCompound(aC);
//
- BOPTools::MapShapes(myShape, myLimit, aMx);
+ TopExp::MapShapes(myShape, myLimit, aMx);
aNbS=aMx.Extent();
for (i=1; i<=aNbS; ++i) {
const TopoDS_Shape& aS=aMx(i);
if (myLimitMode) {
Standard_Integer iType, iLimit, iTypeX;
TopAbs_ShapeEnum aType, aTypeX;
- BOPCol_ListOfShape aLSP, aLSX;
- BOPCol_ListIteratorOfListOfShape aIt, aItX, aItIm;
- BOPCol_MapOfShape aM;
+ TopTools_ListOfShape aLSP, aLSX;
+ TopTools_ListIteratorOfListOfShape aIt, aItX, aItIm;
+ TopTools_MapOfShape aM;
//
iLimit=(Standard_Integer)myLimit;
//
}// for (; aIt.More(); aIt.Next()) {
//
aMx.Clear();
- BOPTools::MapShapes(aC, aMx);
+ TopExp::MapShapes(aC, aMx);
// 2. Add them to aC
aIt.Initialize(aLSP);
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);
aItIm.Initialize(aLSIm);
for (; aItIm.More(); aItIm.Next()) {
const TopoDS_Shape& aSIm=aItIm.Value();
//
Standard_Integer aNbS;
TopoDS_Iterator aIt;
- BOPCol_ListOfShape aLS;
+ TopTools_ListOfShape aLS;
//
aIt.Initialize(myShape);
for (; aIt.More(); aIt.Next()) {
//purpose :
//=======================================================================
void TreatCompound(const TopoDS_Shape& aC1,
- BOPCol_ListOfShape& aLSX)
+ TopTools_ListOfShape& aLSX)
{
Standard_Integer aNbC1;
TopAbs_ShapeEnum aType;
- BOPCol_ListOfShape aLC, aLC1;
- BOPCol_ListIteratorOfListOfShape aIt, aIt1;
+ TopTools_ListOfShape aLC, aLC1;
+ TopTools_ListIteratorOfListOfShape aIt, aIt1;
TopoDS_Iterator aItC;
//
aLC.Append (aC1);
#include <TopoDS_Shape.hxx>
-#include <BOPCol_ListOfShape.hxx>
-#include <BOPCol_MapOfShape.hxx>
+#include <TopTools_ListOfShape.hxx>
+#include <TopTools_MapOfShape.hxx>
#include <BOPAlgo_Builder.hxx>
void AddTool(const TopoDS_Shape& theShape);
Standard_EXPORT
- const BOPCol_ListOfShape& Tools()const;
+ const TopTools_ListOfShape& Tools()const;
Standard_EXPORT
void SetLimit(const TopAbs_ShapeEnum aLimit);
virtual void PostTreat();
protected:
- BOPCol_ListOfShape myTools;
- BOPCol_MapOfShape myMapTools;
+ TopTools_ListOfShape myTools;
+ TopTools_MapOfShape myMapTools;
TopAbs_ShapeEnum myLimit;
Standard_Integer myLimitMode;
};
#include <BRep_Tool.hxx>
#include <BRepClass3d_SolidClassifier.hxx>
//
-#include <BOPCol_ListOfShape.hxx>
+#include <TopTools_ListOfShape.hxx>
#include <IntTools_Context.hxx>
//
#include <BOPDS_DS.hxx>
TopTools_IndexedMapOfShape aM;
//
const BOPDS_DS& aDS=myDSFiller->DS();
- const BOPCol_ListOfShape& aLS=aDS.Arguments();
+ const TopTools_ListOfShape& aLS=aDS.Arguments();
aNbArgs=aLS.Extent();
if (aNbArgs!=2) {
myErrorStatus=14;
BOPDS_VectorOfInterfVE& aVEs=pDS->InterfVE();
BOPDS_VectorOfInterfVF& aVFs=pDS->InterfVF();
//
- const BOPCol_ListOfShape& aLS=aDS.Arguments();
+ const TopTools_ListOfShape& aLS=aDS.Arguments();
const TopoDS_Shape& aObj=aLS.First();
//
const TopoDS_Shape& aTool=aLS.Last();
iFound=0;
//
// 1
- aNbVV=aVVs.Extent();
+ aNbVV=aVVs.Length();
for (j=0; j<aNbVV; ++j) {
BOPDS_InterfVV& aVV=aVVs(j);
if (aVV.Contains(i)) {
continue;
}
// 2
- aNbVE=aVEs.Extent();
+ aNbVE=aVEs.Length();
for (j=0; j<aNbVE; ++j) {
BOPDS_InterfVE& aVE=aVEs(j);
if (aVE.Contains(i)) {
continue;
}
// 3
- aNbVF=aVFs.Extent();
+ aNbVF=aVFs.Length();
for (j=0; j<aNbVF; ++j) {
BOPDS_InterfVF& aVF=aVFs(j);
if (aVF.Contains(i)) {
Standard_Integer aNbArgs;
//
const BOPDS_DS& aDS=myDSFiller->DS();
- const BOPCol_ListOfShape& aLS=aDS.Arguments();
+ const TopTools_ListOfShape& aLS=aDS.Arguments();
aNbArgs=aLS.Extent();
if (!aNbArgs) {
myErrorStatus=13;
const BOPDS_DS& aDS=myDSFiller->DS();
BOPDS_DS* pDS=(BOPDS_DS*)&aDS;
//
- const BOPCol_ListOfShape& aLS=pDS->Arguments();
+ const TopTools_ListOfShape& aLS=pDS->Arguments();
aNbArgs=aLS.Extent();
if (aNbArgs!=2) {
myErrorStatus=14;
if (isCheckSelfInte) {
BOPAlgo_CheckerSI aCSI; // checker of self-interferences
aCSI.SetLevelOfCheck(BOP_SELF_INTERSECTIONS_LEVEL);
- BOPCol_ListOfShape aList1, aList2;
+ TopTools_ListOfShape aList1, aList2;
aList1.Append(aShape1);
aList2.Append(aShape2);
aCSI.SetArguments(aList1);
if (isCheckSelfInte) {
aCSI.SetLevelOfCheck(BOP_SELF_INTERSECTIONS_LEVEL);
- BOPCol_ListOfShape aList1;
+ TopTools_ListOfShape aList1;
aList1.Append(aShape);
aCSI.SetArguments(aList1);
aCSI.Perform();
StdFail_NotDone::Raise("Boolean operation will not be performed, because argument shape is not valid");
if (isCheckSelfInte) {
- BOPCol_ListOfShape aList2;
+ TopTools_ListOfShape aList2;
aList2.Append(aShape2);
aCSI.SetArguments(aList2);
aCSI.Perform();
if (isCheckSelfInte) {
aCSI.SetLevelOfCheck(BOP_SELF_INTERSECTIONS_LEVEL);
- BOPCol_ListOfShape aList1;
+ TopTools_ListOfShape aList1;
aList1.Append(aShape);
aCSI.SetArguments(aList1);
aCSI.Perform();
StdFail_NotDone::Raise("Boolean operation will not be performed, because argument shape is not valid");
if (isCheckSelfInte) {
- BOPCol_ListOfShape aList2;
+ TopTools_ListOfShape aList2;
aList2.Append(aTool);
aCSI.SetArguments(aList2);
aCSI.Perform();
}
}
- BOPCol_ListOfShape aListShapes;
+ TopTools_ListOfShape aListShapes;
BOPTools_AlgoTools::MakeConnexityBlocks(aFaces, TopAbs_EDGE, TopAbs_FACE, aListShapes);
if (aListShapes.IsEmpty())
TopoDS_Compound aResult;
B.MakeCompound(aResult);
- BOPCol_ListIteratorOfListOfShape anIter(aListShapes);
+ TopTools_ListIteratorOfListOfShape anIter(aListShapes);
for (; anIter.More(); anIter.Next()) {
TopoDS_Shell aShell;
// OCCT Includes
#include <Bnd_Box.hxx>
#include <BOPAlgo_CheckerSI.hxx>
-#include <BOPCol_ListOfShape.hxx>
+#include <TopTools_ListOfShape.hxx>
#include <BOPDS_DS.hxx>
-#include <BOPDS_MapOfPassKey.hxx>
#include <BOPDS_MapOfPair.hxx>
#include <BOPDS_Pair.hxx>
#include <BRepBndLib.hxx>
TopTools_IndexedMapOfShape anIndices;
TopExp::MapShapes(aScopy, anIndices);
- BOPCol_ListOfShape aLCS;
+ TopTools_ListOfShape aLCS;
aLCS.Append(aScopy);
//
BOPAlgo_CheckerSI aCSI; // checker of self-interferences
TopExp::MapShapes(aScopy1, anIndices1);
TopExp::MapShapes(aScopy2, anIndices2);
- BOPCol_ListOfShape aLCS1, aLCS2;
+ TopTools_ListOfShape aLCS1, aLCS2;
aLCS1.Append(aScopy1); aLCS2.Append(aScopy2);
//
BRepExtrema_ShapeProximity aBSP; // checker of fast interferences
#include <StdFail_NotDone.hxx>
#include <BOPAlgo_CheckerSI.hxx>
#include <BOPAlgo_Alerts.hxx>
-#include <BOPCol_IndexedDataMapOfShapeListOfShape.hxx>
-#include <BOPCol_ListOfShape.hxx>
+#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
+#include <TopTools_ListOfShape.hxx>
#include <BOPDS_DS.hxx>
// Depth of self-intersection check (see BOPAlgo_CheckerSI::SetLevelOfCheck() for more details)
static void CheckSelfIntersection(const TopoDS_Shape &theShape)
{
BOPAlgo_CheckerSI aCSI; // checker of self-interferences
- BOPCol_ListOfShape aList;
+ TopTools_ListOfShape aList;
aList.Append(theShape);
aCSI.SetLevelOfCheck(BOP_SELF_INTERSECTIONS_LEVEL);
TopExp::MapShapes(aShape, aResIndices);
// Map: source_shape/images of source_shape in Result
- const BOPCol_IndexedDataMapOfShapeListOfShape& aMR = PS.ImagesResult();
+ const TopTools_IndexedDataMapOfShapeListOfShape& aMR = PS.ImagesResult();
//const TopTools_IndexedDataMapOfShapeListOfShape& aMR = PS.ImagesResult();
// history for all argument shapes
//
if (!aMR.Contains(anEntity)) continue;
- const BOPCol_ListOfShape& aModified = aMR.FindFromKey(anEntity);
+ const TopTools_ListOfShape& aModified = aMR.FindFromKey(anEntity);
//const TopTools_ListOfShape& aModified = aMR.FindFromKey(anEntity);
Standard_Integer nbModified = aModified.Extent();
if (nbModified > 0) { // Mantis issue 0021182
int ih = 1;
- BOPCol_ListIteratorOfListOfShape itM (aModified);
+ TopTools_ListIteratorOfListOfShape itM (aModified);
for (; itM.More() && nbModified > 0; itM.Next(), ++ih) {
if (!aResIndices.Contains(itM.Value())) {
nbModified = 0;
TDataStd_IntegerArray::Set(aWhatHistoryLabel, 1, nbModified);
int ih = 1;
- BOPCol_ListIteratorOfListOfShape itM (aModified);
+ TopTools_ListIteratorOfListOfShape itM (aModified);
//TopTools_ListIteratorOfListOfShape itM (aModified);
for (; itM.More(); itM.Next(), ++ih) {
int id = aResIndices.FindIndex(itM.Value());
unsigned int ind, nbshapes = aShapes->Length();
// add faces
- BOPCol_ListOfShape aLS;
+ TopTools_ListOfShape aLS;
for (ind = 1; ind <= nbshapes; ind++) {
Handle(GEOM_Function) aRefShape = Handle(GEOM_Function)::DownCast(aShapes->Value(ind));
TopoDS_Shape aShape_i = aRefShape->GetValue();