// 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 <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 :
//=======================================================================
- void BOPAlgo_Builder::FillImagesFaces()
+void BOPAlgo_Builder::FillImagesFaces()
{
myErrorStatus=0;
//
//function : BuildSplitFaces
//purpose :
//=======================================================================
- void BOPAlgo_Builder::BuildSplitFaces()
+void BOPAlgo_Builder::BuildSplitFaces()
{
Standard_Boolean bHasFaceInfo, bIsClosed, bIsDegenerated, bToReverse;
- Standard_Integer i, j, aNbS, aNbPBIn, aNbPBOn, aNbPBSc, aNbAV, nSp;
+ Standard_Integer i, j, k, aNbS, aNbPBIn, aNbPBOn, aNbPBSc, aNbAV, nSp;
+ Standard_Size aNbBF;
TopoDS_Face aFF, aFSD;
TopoDS_Edge aSp, aEE;
TopAbs_Orientation anOriF, anOriE;
BOPCol_ListIteratorOfListOfShape aIt;
BOPCol_ListOfInteger aLIAV;
BOPCol_MapOfShape aMFence;
- Handle(NCollection_IncAllocator) aAllocator;
+ 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);
//
aNbS=myDS->NbSourceShapes();
+ //
for (i=0; i<aNbS; ++i) {
const BOPDS_ShapeInfo& aSI=myDS->ShapeInfo(i);
if (aSI.ShapeType()!=TopAbs_FACE) {
continue;
}
//
- // aLFIm will contain images of aF
- aLFIm.Clear();
- //
const BOPDS_FaceInfo& aFI=myDS->FaceInfo(i);
//
const BOPDS_IndexedMapOfPaveBlock& aMPBIn=aFI.PaveBlocksIn();
anOriF=aF.Orientation();
aFF=aF;
aFF.Orientation(TopAbs_FORWARD);
- //
-
//
// 1. Fill the egdes set for the face aFF -> LE
aLE.Clear();
aLE.Append(aSp);
}
//
+ if (!myPaveFiller->NonDestructive()) {
+ // speed up for planar faces
+ BOPTools_AlgoTools2D::BuildPCurveForEdgesOnPlane (aLE, aFF);
+ }
// 3 Build split faces
- BOPAlgo_BuilderFace aBF(aAllocator);
- //
- aBF.SetFace(aFF);
- //aBF.SetContext(myContext);
- //
- // <-DEB ft
- //
+ BOPAlgo_BuilderFace& aBF=aVBF.Append1();
+ aBF.SetFace(aF);
aBF.SetShapes(aLE);
+ aBF.SetRunParallel(myRunParallel);
+ aBF.SetProgressIndicator(myProgressIndicator);
//
- aBF.Perform();
+ }// for (i=0; i<aNbS; ++i) {
+ //
+ aNbBF=aVBF.Extent();
+ //
+ //===================================================
+ BOPAlgo_BuilderFaceCnt::Perform(myRunParallel, aVBF);
+ //===================================================
+ //
+ for (k=0; k<(Standard_Integer)aNbBF; ++k) {
+ aLFIm.Clear();
+ //
+ BOPAlgo_BuilderFace& aBF=aVBF(k);
+ TopoDS_Face aF=aBF.Face();
+ anOriF=aBF.Orientation();
+ aF.Orientation(anOriF);
//
const BOPCol_ListOfShape& aLFR=aBF.Areas();
aIt.Initialize(aLFR);
}
//
mySplits.Bind(aF, aLFIm);
- }// for (i=0; i<aNbS; ++i) {
+ }// for (k=0; k<aNbBF; ++k) {
//
- aAllocator.Nullify();
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~scope t
}
//=======================================================================
//function : FillSameDomainFaces
//purpose :
//=======================================================================
- void BOPAlgo_Builder::FillSameDomainFaces()
+void BOPAlgo_Builder::FillSameDomainFaces()
{
Standard_Boolean bFlag;
- Standard_Integer i, aNbFFs, aNbCurves, aNbPoints, nF1, nF2, aNbS;
- Standard_Integer j;
- Handle(NCollection_IncAllocator) aAllocator;
- BOPCol_ListIteratorOfListOfShape aItF1, aItF2;
- BOPTools_ListOfCoupleOfShape aLCS;
- BOPCol_ListIteratorOfListOfShape aItLS;
- BOPCol_MapOfShape aMF;
- BOPCol_MapIteratorOfMapOfShape aItMF;
+ Standard_Integer i, j, k, aNbFFs, aNbCurves, aNbPoints, nF1, nF2, aNbS;
+ Handle(NCollection_BaseAllocator) aAllocator;
+ BOPCol_ListIteratorOfListOfShape aItF;
+ BOPCol_MapOfShape aMFence;
+ BOPAlgo_IndexedDataMapOfSetInteger aIDMSS;
+ BOPAlgo_VectorOfVectorOfShape aVVS;
//
myErrorStatus=0;
//
if (!aNbFFs) {
return;
}
- //-----------------------------------------------------scope f
- aAllocator=new NCollection_IncAllocator();
- BOPCol_IndexedDataMapOfShapeListOfShape aDMSLS(100, aAllocator);
- BOPCol_DataMapOfIntegerListOfShape aMBlocks(100, aAllocator);
- BOPTools_DataMapOfShapeSet aMSST(100, aAllocator);
- //
- BOPCol_ListOfShape aLFIm;
//
for (i=0; i<aNbFFs; ++i) {
const BOPDS_InterfFF& aFF=aFFs(i);
//
const BOPDS_FaceInfo& aFI1=myDS->FaceInfo(nF1);
const BOPDS_FaceInfo& aFI2=myDS->FaceInfo(nF2);
- bFlag=HasPaveBlocksOnIn(aFI1, aFI2);
//
- const TopoDS_Face& aF1=(*(TopoDS_Face*)(&myDS->Shape(nF1)));
- const TopoDS_Face& aF2=(*(TopoDS_Face*)(&myDS->Shape(nF2)));
+ const TopoDS_Shape& aF1=myDS->Shape(nF1);
+ const TopoDS_Shape& aF2=myDS->Shape(nF2);
+ //
+ bFlag=HasPaveBlocksOnIn(aFI1, aFI2);
bFlag=bFlag && (mySplits.IsBound(aF1) && mySplits.IsBound(aF2));
//
- if (!bFlag) {
- //case when the faces have shared bounds
- if (!aMSST.IsBound(aF1)) {
- BOPTools_Set aST1(aAllocator);
- aMSST.Bind(aF1, aST1);
- BOPTools_Set& aST=aMSST.ChangeFind(aF1);
- aST.AddEdges(aF1);
+ 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.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;
//
- if (!aMSST.IsBound(aF2)) {
- BOPTools_Set aST2(aAllocator);
- aMSST.Bind(aF2, aST2);
- BOPTools_Set& aST=aMSST.ChangeFind(aF2);
- aST.AddEdges(aF2);
- }
+ aST1.Add(aF1, TopAbs_EDGE);
+ aST2.Add(aF2, TopAbs_EDGE);
//
- const BOPTools_Set& aST1=aMSST.Find(aF1);
- const BOPTools_Set& aST2=aMSST.Find(aF2);
if (aST1.IsEqual(aST2)) {
- bFlag=BOPTools_AlgoTools::AreFacesSameDomain(aF1, aF2, myContext);
- if (bFlag) {
- FillMap(aF1, aF2, aDMSLS, aAllocator);
- aMF.Add(aF1);
- aMF.Add(aF2);
- }
- }
- continue;
- }
- //
- const BOPCol_ListOfShape& aLF1=mySplits.Find(aF1);
- const BOPCol_ListOfShape& aLF2=mySplits.Find(aF2);
- //
- aItF1.Initialize(aLF1);
- for (; aItF1.More(); aItF1.Next()) {
- const TopoDS_Face& aF1x=(*(TopoDS_Face*)(&aItF1.Value()));
- if (!aMSST.IsBound(aF1x)) {
- BOPTools_Set aST1(aAllocator);
- //
- aMSST.Bind(aF1x, aST1);
- BOPTools_Set& aST=aMSST.ChangeFind(aF1x);
- aST.AddEdges(aF1x);
- }
- //
- aItF2.Initialize(aLF2);
- for (; aItF2.More(); aItF2.Next()) {
- const TopoDS_Face& aF2y=(*(TopoDS_Face*)(&aItF2.Value()));
- if (!aMSST.IsBound(aF2y)) {
- BOPTools_Set aST2(aAllocator);
+ if (!aIDMSS.Contains(aST1)) {
+ BOPAlgo_VectorOfShape& aVS=aVVS.Append1();
+ if (aMFence.Add(aF1)) {
+ aVS.Append(aF1);
+ }
+ if (aMFence.Add(aF2)) {
+ aVS.Append(aF2);
+ }
//
- aMSST.Bind(aF2y, aST2);
- BOPTools_Set& aST=aMSST.ChangeFind(aF2y);
- aST.AddEdges(aF2y);
+ k=aVVS.Extent()-1;
+ aIDMSS.Add (aST1, k);
}
- //
- const BOPTools_Set& aST1=aMSST.Find(aF1x);
- const BOPTools_Set& aST2=aMSST.Find(aF2y);
- //
- if (aST1.IsEqual(aST2)) {
- bFlag=BOPTools_AlgoTools::AreFacesSameDomain(aF1x, aF2y, myContext);
- if (bFlag) {
- FillMap(aF1x, aF2y, aDMSLS, aAllocator);
+ 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 (i=0; i<aNbFFs; ++i) {
+ //
+ aIDMSS.Clear();
+ //
+ Standard_Boolean bFlagSD;
+ Standard_Integer aNbVPSB, aNbVVS, aNbF, aNbF1;
+ BOPAlgo_VectorOfPairOfShapeBoolean aVPSB;
+ //
+ aNbVVS=aVVS.Extent();
+ for (i=0; i<aNbVVS; ++i) {
+ const BOPAlgo_VectorOfShape& aVS=aVVS(i);
+ aNbF=aVS.Extent();
+ if (aNbF<2) {
+ continue;
+ }
+ //
+ aNbF1=aNbF-1;
+ 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;
+ aPSB.SetProgressIndicator(myProgressIndicator);
}
- }
- } // for (i=0; i<aNbFFs; ++i) {
+ }
+ }
+ //================================================================
+ BOPAlgo_BuilderSDFaceCnt::Perform(myRunParallel, aVPSB, myContext);
+ //================================================================
+ aAllocator=
+ NCollection_BaseAllocator::CommonBaseAllocator();
+ BOPCol_IndexedDataMapOfShapeListOfShape aDMSLS(100, aAllocator);
+ BOPCol_DataMapOfIntegerListOfShape aMBlocks(100, aAllocator);
+ //
+ aNbVPSB=aVPSB.Extent();
+ for (i=0; i<aNbVPSB; ++i) {
+ BOPAlgo_PairOfShapeBoolean& aPSB=aVPSB(i);
+ bFlagSD=aPSB.Flag();
+ if (bFlagSD) {
+ const TopoDS_Shape& aFj=aPSB.Shape1();
+ const TopoDS_Shape& aFk=aPSB.Shape2();
+ FillMap(aFj, aFk, aDMSLS, aAllocator);
+ }
+ }
+ aVPSB.Clear();
//
// 2. Make blocks
MakeBlocksCnx(aDMSLS, aMBlocks, aAllocator);
aNbS = aMBlocks.Extent();
for (i=0; i<aNbS; ++i) {
const BOPCol_ListOfShape& aLSD=aMBlocks.Find(i);
- if (aLSD.Extent()) {
- const TopoDS_Shape& aFSD1=aLSD.First();
- aItLS.Initialize(aLSD);
- for (; aItLS.More(); aItLS.Next()) {
- const TopoDS_Shape& aFSD=aItLS.Value();
- myShapesSD.Bind(aFSD, aFSD1);
- }
+ if (aLSD.IsEmpty()) {
+ continue;
}
- }
- //
- aItMF.Initialize(aMF);
- for (; aItMF.More(); aItMF.Next()){
- const TopoDS_Shape& aF = aItMF.Value();
//
- BOPCol_ListOfShape aLS;
- aLS.Append(aF);
- mySplits.Bind(aF, aLS);
+ const TopoDS_Shape& aFSD1=aLSD.First();
+ aItF.Initialize(aLSD);
+ for (; aItF.More(); aItF.Next()) {
+ const TopoDS_Shape& aFSD=aItF.Value();
+ myShapesSD.Bind(aFSD, aFSD1);
+ //
+ // 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);
+ }
+ }
}
- //-----------------------------------------------------scope t
- aMSST.Clear();
aMBlocks.Clear();
aDMSLS.Clear();
- aAllocator.Nullify();
}
//=======================================================================
// function: FillImagesFaces1
// purpose:
//=======================================================================
- void BOPAlgo_Builder::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;
aMVAdd.Clear();
//
aMVP.Add(nV);
- while(1) {
+ for(;;) {
aNbVP=aMVP.Extent();
for (j=1; j<=aNbVP; ++j) {
const TopoDS_Shape& nVP=aMVP(j);
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;
}
projects / occt.git / blobdiff