// Created by: Peter KURNEV
-// Copyright (c) 2010-2012 OPEN CASCADE SAS
+// 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
//
-// The content of this file is subject to the Open CASCADE Technology Public
-// License Version 6.5 (the "License"). You may not use the content of this file
-// except in compliance with the License. Please obtain a copy of the License
-// at http://www.opencascade.org and read it completely before using this file.
+// This file is part of Open CASCADE Technology software library.
//
-// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
-// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
+// 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.
//
-// The Original Code and all software distributed under the License is
-// distributed on an "AS IS" basis, without warranty of any kind, and the
-// Initial Developer hereby disclaims all such warranties, including without
-// limitation, any warranties of merchantability, fitness for a particular
-// purpose or non-infringement. Please see the License for the specific terms
-// and conditions governing the rights and limitations under the License.
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
-#include <BOPAlgo_Builder.ixx>
-#include <NCollection_IncAllocator.hxx>
-
-#include <TopoDS_Shape.hxx>
-#include <TopoDS_Face.hxx>
-#include <TopoDS_Edge.hxx>
-#include <TopoDS_Vertex.hxx>
-#include <TopoDS_Compound.hxx>
-
-#include <BRep_Tool.hxx>
-#include <BRep_Builder.hxx>
-
-#include <TopExp_Explorer.hxx>
-
-#include <BOPCol_ListOfShape.hxx>
-#include <BOPCol_ListOfInteger.hxx>
-#include <BOPCol_MapOfInteger.hxx>
+#include <BOPAlgo_Builder.hxx>
+#include <BOPAlgo_BuilderFace.hxx>
+#include <BOPAlgo_PaveFiller.hxx>
#include <BOPCol_DataMapOfIntegerListOfShape.hxx>
#include <BOPCol_DataMapOfShapeShape.hxx>
-
-#include <BOPInt_Context.hxx>
-
-#include <BOPDS_PaveBlock.hxx>
-#include <BOPDS_ShapeInfo.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_MapOfPaveBlock.hxx>
-#include <BOPDS_VectorOfInterfFF.hxx>
#include <BOPDS_Interf.hxx>
+#include <BOPDS_MapOfPaveBlock.hxx>
+#include <BOPDS_PaveBlock.hxx>
+#include <BOPDS_ShapeInfo.hxx>
#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>
-#include <BOPAlgo_BuilderFace.hxx>
#include <BOPTools_CoupleOfShape.hxx>
+#include <BOPTools_DataMapOfShapeSet.hxx>
#include <BOPTools_ListOfCoupleOfShape.hxx>
#include <BOPTools_MapOfSet.hxx>
-#include <BOPTools_DataMapOfShapeSet.hxx>
-#include <BOPAlgo_Builder_2Cnt.hxx>
+#include <BRep_Builder.hxx>
+#include <BRep_Tool.hxx>
+#include <IntTools_Context.hxx>
+#include <TopExp_Explorer.hxx>
+#include <TopoDS_Compound.hxx>
+#include <TopoDS_Edge.hxx>
+#include <TopoDS_Face.hxx>
+#include <TopoDS_Shape.hxx>
+#include <TopoDS_Vertex.hxx>
+//
+//
+//
+//
+//
+//
+//
+//
static
Standard_Boolean HasPaveBlocksOnIn(const BOPDS_FaceInfo& aFI1,
const BOPDS_FaceInfo& aFI2);
void FillMap(const TopoDS_Shape& aS1,
const TopoDS_Shape& aS2,
BOPCol_IndexedDataMapOfShapeListOfShape& aDMSLS,
- Handle(NCollection_IncAllocator)& aAllocator);
+ Handle(NCollection_BaseAllocator)& aAllocator);
static
void MakeBlocksCnx(const BOPCol_IndexedDataMapOfShapeListOfShape& aMILI,
BOPCol_DataMapOfIntegerListOfShape& aMBlocks,
- Handle(NCollection_IncAllocator)& aAllocator);
+ Handle(NCollection_BaseAllocator)& aAllocator);
+//
+typedef BOPCol_NCVector<TopoDS_Shape> BOPAlgo_VectorOfShape;
+//
+typedef BOPCol_NCVector<BOPAlgo_VectorOfShape> \
+ BOPAlgo_VectorOfVectorOfShape;
+//
+typedef NCollection_IndexedDataMap\
+ <BOPTools_Set, Standard_Integer, BOPTools_SetMapHasher> \
+ BOPAlgo_IndexedDataMapOfSetInteger;
+//
+//=======================================================================
+//class : BOPAlgo_PairOfShapeBoolean
+//purpose :
+//=======================================================================
+class BOPAlgo_PairOfShapeBoolean : public BOPAlgo_Algo {
+
+ public:
+ DEFINE_STANDARD_ALLOC
+ BOPAlgo_PairOfShapeBoolean() :
+ BOPAlgo_Algo(),
+ myFlag(Standard_False) {
+ }
+ //
+ virtual ~BOPAlgo_PairOfShapeBoolean() {
+ }
+ //
+ TopoDS_Shape& Shape1() {
+ return myShape1;
+ }
+ //
+ TopoDS_Shape& Shape2() {
+ return myShape2;
+ }
+ //
+ Standard_Boolean& Flag() {
+ return myFlag;
+ }
+ //
+ void SetContext(const Handle(IntTools_Context)& aContext) {
+ myContext=aContext;
+ }
+ //
+ const Handle(IntTools_Context)& Context()const {
+ return myContext;
+ }
+ //
+ virtual void Perform() {
+ BOPAlgo_Algo::UserBreak();
+ //
+ const TopoDS_Face& aFj=*((TopoDS_Face*)&myShape1);
+ const TopoDS_Face& aFk=*((TopoDS_Face*)&myShape2);
+ myFlag=BOPTools_AlgoTools::AreFacesSameDomain(aFj, aFk, myContext);
+ }
+ //
+ protected:
+ Standard_Boolean myFlag;
+ TopoDS_Shape myShape1;
+ TopoDS_Shape myShape2;
+ Handle(IntTools_Context) myContext;
+};
+//
+typedef BOPCol_NCVector<BOPAlgo_PairOfShapeBoolean> \
+ BOPAlgo_VectorOfPairOfShapeBoolean;
+//
+typedef BOPCol_ContextFunctor
+ <BOPAlgo_PairOfShapeBoolean,
+ BOPAlgo_VectorOfPairOfShapeBoolean,
+ Handle(IntTools_Context),
+ IntTools_Context> BOPCol_BuilderSDFaceFunctor;
+//
+typedef BOPCol_ContextCnt
+ <BOPCol_BuilderSDFaceFunctor,
+ BOPAlgo_VectorOfPairOfShapeBoolean,
+ Handle(IntTools_Context)> BOPAlgo_BuilderSDFaceCnt;
+//
+//=======================================================================
+// BuilderFace
+//
+typedef BOPCol_NCVector<BOPAlgo_BuilderFace> BOPAlgo_VectorOfBuilderFace;
+//
+typedef BOPCol_Functor
+ <BOPAlgo_BuilderFace,
+ BOPAlgo_VectorOfBuilderFace> BOPAlgo_BuilderFaceFunctor;
+//
+typedef BOPCol_Cnt
+ <BOPAlgo_BuilderFaceFunctor,
+ BOPAlgo_VectorOfBuilderFace> BOPAlgo_BuilderFaceCnt;
+//
+//=======================================================================
+//class : BOPAlgo_VFI
+//purpose :
+//=======================================================================
+class BOPAlgo_VFI : public BOPAlgo_Algo {
+ public:
+ DEFINE_STANDARD_ALLOC
+
+ BOPAlgo_VFI() :
+ BOPAlgo_Algo(),
+ myFlag(-1) {
+ }
+ //
+ virtual ~BOPAlgo_VFI(){
+ }
+ //
+ void SetVertex(const TopoDS_Vertex& aV) {
+ myV=aV;
+ }
+ //
+ TopoDS_Vertex& Vertex() {
+ return myV;
+ }
+ //
+ void SetFace(const TopoDS_Face& aF) {
+ myF=aF;
+ }
+ //
+ TopoDS_Face& Face() {
+ return myF;
+ }
+ //
+ Standard_Integer Flag()const {
+ return myFlag;
+ }
+ //
+ void SetContext(const Handle(IntTools_Context)& aContext) {
+ myContext=aContext;
+ }
+ //
+ const Handle(IntTools_Context)& Context()const {
+ return myContext;
+ }
+ //
+ virtual void Perform() {
+ Standard_Real aT1, aT2, dummy;
+ //
+ BOPAlgo_Algo::UserBreak();
+ myFlag = myContext->ComputeVF(myV, myF, aT1, aT2, dummy);
+ }
+ //
+ protected:
+ Standard_Integer myFlag;
+ TopoDS_Vertex myV;
+ TopoDS_Face myF;
+ Handle(IntTools_Context) myContext;
+};
+//
+typedef BOPCol_NCVector<BOPAlgo_VFI> BOPAlgo_VectorOfVFI;
+//
+typedef BOPCol_ContextFunctor
+ <BOPAlgo_VFI,
+ BOPAlgo_VectorOfVFI,
+ Handle(IntTools_Context),
+ IntTools_Context> BOPAlgo_VFIFunctor;
+//
+typedef BOPCol_ContextCnt
+ <BOPAlgo_VFIFunctor,
+ BOPAlgo_VectorOfVFI,
+ Handle(IntTools_Context)> BOPAlgo_VFICnt;
+//
//=======================================================================
//function : FillImagesFaces
//purpose :
{
Standard_Boolean bHasFaceInfo, bIsClosed, bIsDegenerated, bToReverse;
Standard_Integer i, j, k, aNbS, aNbPBIn, aNbPBOn, aNbPBSc, aNbAV, nSp;
- Standard_Boolean bRunParallel;
Standard_Size aNbBF;
TopoDS_Face aFF, aFSD;
TopoDS_Edge aSp, aEE;
BOPCol_MapOfShape aMFence;
Handle(NCollection_BaseAllocator) aAllocator;
BOPCol_ListOfShape aLFIm(myAllocator);
- BOPCol_MapIteratorOfMapOfShape aItMS;
BOPAlgo_VectorOfBuilderFace aVBF;
//
myErrorStatus=0;
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~scope f
- aAllocator=new NCollection_IncAllocator();
+ aAllocator=
+ NCollection_BaseAllocator::CommonBaseAllocator();
//
BOPCol_ListOfShape aLE(aAllocator);
BOPCol_MapOfShape aMDE(100, aAllocator);
anOriF=aF.Orientation();
aFF=aF;
aFF.Orientation(TopAbs_FORWARD);
- //
-
//
// 1. Fill the egdes set for the face aFF -> LE
aLE.Clear();
aLE.Append(aSp);
}
//
- BOPTools_AlgoTools2D::BuildPCurveForEdgesOnPlane (aLE, aFF);
- //
+ if (!myPaveFiller->NonDestructive()) {
+ // speed up for planar faces
+ BOPTools_AlgoTools2D::BuildPCurveForEdgesOnPlane (aLE, aFF);
+ }
// 3 Build split faces
BOPAlgo_BuilderFace& aBF=aVBF.Append1();
aBF.SetFace(aF);
aBF.SetShapes(aLE);
+ aBF.SetRunParallel(myRunParallel);
+ aBF.SetProgressIndicator(myProgressIndicator);
//
}// for (i=0; i<aNbS; ++i) {
//
mySplits.Bind(aF, aLFIm);
}// for (k=0; k<aNbBF; ++k) {
//
- aAllocator.Nullify();
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~scope t
}
//=======================================================================
{
Standard_Boolean bFlag;
Standard_Integer i, j, k, aNbFFs, aNbCurves, aNbPoints, nF1, nF2, aNbS;
- Handle(NCollection_IncAllocator) aAllocator;
+ Handle(NCollection_BaseAllocator) aAllocator;
BOPCol_ListIteratorOfListOfShape aItF;
BOPCol_MapOfShape aMFence;
BOPAlgo_IndexedDataMapOfSetInteger aIDMSS;
BOPAlgo_VectorOfVectorOfShape aVVS;
-//
+ //
myErrorStatus=0;
//
const BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
//
if (bFlag) {
for (k=0; k<2; ++k) {
- const TopoDS_Shape& aF=(!k) ? aF1 : aF2;
- const BOPCol_ListOfShape& aLF=mySplits.Find(aF);
- //
- aItF.Initialize(aLF);
- for (; aItF.More(); aItF.Next()) {
- const TopoDS_Shape& aFx=aItF.Value();
- //
- if (aMFence.Add(aFx)) {
- BOPTools_Set aSTx;
- //
- aSTx.AddEdges(aFx);
- //
- if (!aIDMSS.Contains(aSTx)) {
- BOPAlgo_VectorOfShape& aVS=aVVS.Append1();
- aVS.Append(aFx);
- //
- j=aVVS.Extent()-1;
- aIDMSS.Add (aSTx, j);
- }
- else {
- j=aIDMSS.ChangeFromKey(aSTx);
- BOPAlgo_VectorOfShape& aVS=aVVS(j);
- aVS.Append(aFx);
- }
- }
- }
+ const TopoDS_Shape& aF=(!k) ? aF1 : aF2;
+ const BOPCol_ListOfShape& aLF=mySplits.Find(aF);
+ //
+ aItF.Initialize(aLF);
+ for (; aItF.More(); aItF.Next()) {
+ const TopoDS_Shape& aFx=aItF.Value();
+ //
+ if (aMFence.Add(aFx)) {
+ BOPTools_Set aSTx;
+ //
+ aSTx.Add(aFx, TopAbs_EDGE);
+ //
+ if (!aIDMSS.Contains(aSTx)) {
+ BOPAlgo_VectorOfShape& aVS=aVVS.Append1();
+ aVS.Append(aFx);
+ //
+ j=aVVS.Extent()-1;
+ aIDMSS.Add (aSTx, j);
+ }
+ else {
+ j=aIDMSS.ChangeFromKey(aSTx);
+ BOPAlgo_VectorOfShape& aVS=aVVS(j);
+ aVS.Append(aFx);
+ }
+ }
+ }
}
}// if (bFlag) {
else {// if (!bFlag)
BOPTools_Set aST1, aST2;
//
- aST1.AddEdges(aF1);
- aST2.AddEdges(aF2);
+ aST1.Add(aF1, TopAbs_EDGE);
+ aST2.Add(aF2, TopAbs_EDGE);
//
if (aST1.IsEqual(aST2)) {
- if (!aIDMSS.Contains(aST1)) {
- BOPAlgo_VectorOfShape& aVS=aVVS.Append1();
- if (aMFence.Add(aF1)) {
- aVS.Append(aF1);
- }
- if (aMFence.Add(aF2)) {
- aVS.Append(aF2);
- }
- //
- k=aVVS.Extent()-1;
- aIDMSS.Add (aST1, k);
- }
- else {
- k=aIDMSS.ChangeFromKey(aST1);
- BOPAlgo_VectorOfShape& aVS=aVVS(k);
- if (aMFence.Add(aF1)) {
- aVS.Append(aF1);
- }
- if (aMFence.Add(aF2)) {
- aVS.Append(aF2);
- }
- }
+ if (!aIDMSS.Contains(aST1)) {
+ BOPAlgo_VectorOfShape& aVS=aVVS.Append1();
+ if (aMFence.Add(aF1)) {
+ aVS.Append(aF1);
+ }
+ if (aMFence.Add(aF2)) {
+ aVS.Append(aF2);
+ }
+ //
+ k=aVVS.Extent()-1;
+ aIDMSS.Add (aST1, k);
+ }
+ else {
+ k=aIDMSS.ChangeFromKey(aST1);
+ BOPAlgo_VectorOfShape& aVS=aVVS(k);
+ if (aMFence.Add(aF1)) {
+ aVS.Append(aF1);
+ }
+ if (aMFence.Add(aF2)) {
+ aVS.Append(aF2);
+ }
+ }
}//if (aST1.IsEqual(aST2)) {
}// else {// if (!bFlag)
//
for (j=0; j<aNbF1; ++j) {
const TopoDS_Shape& aFj=aVS(j);
for (k=j+1; k<aNbF; ++k) {
- const TopoDS_Shape& aFk=aVS(k);
- BOPAlgo_PairOfShapeBoolean& aPSB=aVPSB.Append1();
- aPSB.Shape1()=aFj;
- aPSB.Shape2()=aFk;
+ const TopoDS_Shape& aFk=aVS(k);
+ BOPAlgo_PairOfShapeBoolean& aPSB=aVPSB.Append1();
+ aPSB.Shape1()=aFj;
+ aPSB.Shape2()=aFk;
+ aPSB.SetProgressIndicator(myProgressIndicator);
}
}
}
- //====================================================
- BOPAlgo_BuilderSDFaceCnt::Perform(myRunParallel, aVPSB);
- //====================================================
- aAllocator=new NCollection_IncAllocator();
+ //================================================================
+ BOPAlgo_BuilderSDFaceCnt::Perform(myRunParallel, aVPSB, myContext);
+ //================================================================
+ aAllocator=
+ NCollection_BaseAllocator::CommonBaseAllocator();
BOPCol_IndexedDataMapOfShapeListOfShape aDMSLS(100, aAllocator);
BOPCol_DataMapOfIntegerListOfShape aMBlocks(100, aAllocator);
//
// If the face has no splits but are SD face,
// it is considered as splitted face
if (!mySplits.IsBound(aFSD)) {
- BOPCol_ListOfShape aLS;
- aLS.Append(aFSD);
- mySplits.Bind(aFSD, aLS);
+ BOPCol_ListOfShape aLS;
+ aLS.Append(aFSD);
+ mySplits.Bind(aFSD, aLS);
}
}
}
aMBlocks.Clear();
aDMSLS.Clear();
- aAllocator.Nullify();
}
//=======================================================================
// function: FillImagesFaces1
//=======================================================================
void BOPAlgo_Builder::FillImagesFaces1()
{
- Standard_Integer i, aNbS, iSense;
+ Standard_Integer i, aNbS, iSense, nVx, aNbVFI, iFlag;
TopoDS_Face aFSD;
+ TopoDS_Vertex aVx;
+ BRep_Builder aBB;
BOPCol_ListOfInteger aLIAV;
BOPCol_ListOfShape aLFIm;
- BOPCol_ListIteratorOfListOfShape aItLS;
+ BOPCol_ListIteratorOfListOfInteger aItV;
+ BOPCol_ListIteratorOfListOfShape aItLS, aItF;
+ BOPAlgo_VectorOfVFI aVVFI;
//
aNbS=myDS->NbSourceShapes();
for (i=0; i<aNbS; ++i) {
if (!mySplits.IsBound(aF)) {
continue;
}
- //
+ //
+ // 1.
aLIAV.Clear();
myDS->AloneVertices(i, aLIAV);
aLFIm.Clear();
}
}
//
- FillInternalVertices(aLFIm, aLIAV);
+ //FillInternalVertices(aLFIm, aLIAV);
//
myImages.Bind(aF, aLFIm);
//
- //fill myOrigins
+ // 2. fill myOrigins
aItLS.Initialize(aLFIm);
for (; aItLS.More(); aItLS.Next()) {
const TopoDS_Face& aFSp=(*(TopoDS_Face*)(&aItLS.Value()));
myOrigins.Bind(aFSp, aF);
}
- }// for (i=0; i<aNbS; ++i) {
-}
-//=======================================================================
-// function: FillInternalVertices
-// purpose:
-//=======================================================================
-void BOPAlgo_Builder::FillInternalVertices(BOPCol_ListOfShape& aLFIm,
- BOPCol_ListOfInteger& aLIAV)
-{
- Standard_Integer nV, iFlag;
- Standard_Real aU1, aU2;
- TopoDS_Vertex aV;
- BRep_Builder aBB;
- BOPCol_ListIteratorOfListOfInteger aItV;
- BOPCol_ListIteratorOfListOfShape aItF;
- //
- aItV.Initialize(aLIAV);
- for (; aItV.More(); aItV.Next()) {
- nV=aItV.Value();
- aV=(*(TopoDS_Vertex*)(&myDS->Shape(nV)));
- aV.Orientation(TopAbs_INTERNAL);
//
- aItF.Initialize(aLFIm);
- for (; aItF.More(); aItF.Next()) {
- TopoDS_Face& aF=(*(TopoDS_Face*)(&aItF.Value()));
- iFlag=myContext->ComputeVF(aV, aF, aU1, aU2);
- if (!iFlag) {
- aBB.Add(aF, aV);
- break;
+ // 3.
+ aItV.Initialize(aLIAV);
+ for (; aItV.More(); aItV.Next()) {
+ nVx=aItV.Value();
+ aVx=(*(TopoDS_Vertex*)(&myDS->Shape(nVx)));
+ aVx.Orientation(TopAbs_INTERNAL);
+ //
+ aItF.Initialize(aLFIm);
+ for (; aItF.More(); aItF.Next()) {
+ TopoDS_Face& aFy=(*(TopoDS_Face*)(&aItF.Value()));
+ //
+ BOPAlgo_VFI& aVFI=aVVFI.Append1();
+ aVFI.SetVertex(aVx);
+ aVFI.SetFace(aFy);
+ aVFI.SetProgressIndicator(myProgressIndicator);
}
}
+ }// for (i=0; i<aNbS; ++i) {
+ //
+ // 4.
+ aNbVFI=aVVFI.Extent();
+ //================================================================
+ BOPAlgo_VFICnt::Perform(myRunParallel, aVVFI, myContext);
+ //================================================================
+ //
+ for (i=0; i < aNbVFI; ++i) {
+ BOPAlgo_VFI& aVFI=aVVFI(i);
+ //
+ iFlag=aVFI.Flag();
+ if (!iFlag) {
+ TopoDS_Vertex& aVertex=aVFI.Vertex();
+ TopoDS_Face& aFy=aVFI.Face();
+ aBB.Add(aFy, aVertex);
+ }
}
}
//=======================================================================
//=======================================================================
void MakeBlocksCnx(const BOPCol_IndexedDataMapOfShapeListOfShape& aMILI,
BOPCol_DataMapOfIntegerListOfShape& aMBlocks,
- Handle(NCollection_IncAllocator)& aAllocator)
+ Handle(NCollection_BaseAllocator)& aAllocator)
{
Standard_Integer aNbV, aNbVS, aNbVP, aNbEC, k, i, j;
BOPCol_ListIteratorOfListOfShape aItLI;
aMEC.Clear();
aMVS.Clear();
}
-
//=======================================================================
//function : FillMap
//purpose :
void FillMap(const TopoDS_Shape& aS1,
const TopoDS_Shape& aS2,
BOPCol_IndexedDataMapOfShapeListOfShape& aDMSLS,
- Handle(NCollection_IncAllocator)& aAllocator)
+ Handle(NCollection_BaseAllocator)& aAllocator)
{
if (aDMSLS.Contains(aS1)) {
BOPCol_ListOfShape& aLS=aDMSLS.ChangeFromKey(aS1);
const BOPDS_FaceInfo& aFI2)
{
Standard_Boolean bRet;
- BOPDS_MapIteratorOfMapOfPaveBlock aItMPB;
+ Standard_Integer i, aNbPB;
//
bRet=Standard_False;
- const BOPDS_IndexedMapOfPaveBlock& aMPBOn1=aFI1.PaveBlocksOn();
- const BOPDS_IndexedMapOfPaveBlock& aMPBIn1=aFI1.PaveBlocksIn();
- //
- const BOPDS_IndexedMapOfPaveBlock& aMPBOn2=aFI2.PaveBlocksOn();
- aItMPB.Initialize(aMPBOn2);
- for (; aItMPB.More(); aItMPB.Next()) {
- const Handle(BOPDS_PaveBlock)& aPB=aItMPB.Value();
- bRet=aMPBOn1.Contains(aPB) || aMPBIn1.Contains(aPB);
+ const BOPDS_IndexedMapOfPaveBlock& aMPBOn1 = aFI1.PaveBlocksOn();
+ const BOPDS_IndexedMapOfPaveBlock& aMPBIn1 = aFI1.PaveBlocksIn();
+ //
+ const BOPDS_IndexedMapOfPaveBlock& aMPBOn2 = aFI2.PaveBlocksOn();
+ aNbPB = aMPBOn2.Extent();
+ for (i = 1; i <= aNbPB; ++i) {
+ const Handle(BOPDS_PaveBlock)& aPB = aMPBOn2(i);
+ bRet = aMPBOn1.Contains(aPB) || aMPBIn1.Contains(aPB);
if (bRet) {
return bRet;
}
}
//
- const BOPDS_IndexedMapOfPaveBlock& aMPBIn2=aFI2.PaveBlocksIn();
- aItMPB.Initialize(aMPBIn2);
- for (; aItMPB.More(); aItMPB.Next()) {
- const Handle(BOPDS_PaveBlock)& aPB=aItMPB.Value();
- bRet=aMPBOn1.Contains(aPB) || aMPBIn1.Contains(aPB);
+ const BOPDS_IndexedMapOfPaveBlock& aMPBIn2 = aFI2.PaveBlocksIn();
+ aNbPB = aMPBIn2.Extent();
+ for (i = 1; i <= aNbPB; ++i) {
+ const Handle(BOPDS_PaveBlock)& aPB = aMPBIn2(i);
+ bRet = aMPBOn1.Contains(aPB) || aMPBIn1.Contains(aPB);
if (bRet) {
return bRet;
}
}
return bRet;
}
+
/*
//DEBf
{
projects / occt.git / blobdiff