The methods BOPAlgo_Tools::MakeBlocksCnx(), BOPAlgo_Tools::MakeBlocks() and static method MakeBlocksCnx in BOPAlgo_Builder_2.cxx have been replaced with the new template method BOPAlgo_Tools::MakeBlocks(). The blocks of connected elements are now stored into the list of list instead of data map.
All methods BOPAlgo_Tools::FillMap() have been replaced with the new template method BOPAlgo_Tools::FillMap().
Making the Pave Block with the smallest index of original edge to be the first in the Common Block (i.e. the representing Pave Block).
The following improvements have been made in Boolean Operations algorithm to avoid regressions:
- When updating the existing common block update its pave blocks in a way that the parameters of the paves should be valid for the original edge (bugs/modalg_5/bug24809);
- When trying to reduce the tolerance of the section edge check the tolerance of all Face/Face interferences that created this edge (boolean/volumemaker/C4,D2);
- Avoid producing the different Pave Blocks for the same section edge (boolean/volumemaker/D6);
Adjustment of the test cases.
#include <BOPAlgo_Builder.hxx>
#include <BOPAlgo_BuilderFace.hxx>
#include <BOPAlgo_PaveFiller.hxx>
+#include <BOPAlgo_Tools.hxx>
#include <BOPCol_DataMapOfIntegerListOfShape.hxx>
#include <BOPCol_DataMapOfShapeShape.hxx>
#include <BOPCol_ListOfInteger.hxx>
static
Standard_Boolean HasPaveBlocksOnIn(const BOPDS_FaceInfo& aFI1,
const BOPDS_FaceInfo& aFI2);
-static
- void FillMap(const TopoDS_Shape& aS1,
- const TopoDS_Shape& aS2,
- BOPCol_IndexedDataMapOfShapeListOfShape& aDMSLS,
- Handle(NCollection_BaseAllocator)& aAllocator);
-static
- void MakeBlocksCnx(const BOPCol_IndexedDataMapOfShapeListOfShape& aMILI,
- BOPCol_DataMapOfIntegerListOfShape& aMBlocks,
- Handle(NCollection_BaseAllocator)& aAllocator);
//
typedef BOPCol_NCVector<TopoDS_Shape> BOPAlgo_VectorOfShape;
//
void BOPAlgo_Builder::FillSameDomainFaces()
{
Standard_Boolean bFlag;
- Standard_Integer i, j, k, aNbFFs, nF1, nF2, aNbS;
+ Standard_Integer i, j, k, aNbFFs, nF1, nF2;
Handle(NCollection_BaseAllocator) aAllocator;
BOPCol_ListIteratorOfListOfShape aItF;
BOPCol_MapOfShape aMFence;
aAllocator=
NCollection_BaseAllocator::CommonBaseAllocator();
BOPCol_IndexedDataMapOfShapeListOfShape aDMSLS(100, aAllocator);
- BOPCol_DataMapOfIntegerListOfShape aMBlocks(100, aAllocator);
+ NCollection_List<BOPCol_ListOfShape> aMBlocks(aAllocator);
//
aNbVPSB=aVPSB.Extent();
for (i=0; i<aNbVPSB; ++i) {
if (bFlagSD) {
const TopoDS_Shape& aFj=aPSB.Shape1();
const TopoDS_Shape& aFk=aPSB.Shape2();
- FillMap(aFj, aFk, aDMSLS, aAllocator);
+ BOPAlgo_Tools::FillMap<TopoDS_Shape, TopTools_ShapeMapHasher>(aFj, aFk, aDMSLS, aAllocator);
}
}
aVPSB.Clear();
//
// 2. Make blocks
- MakeBlocksCnx(aDMSLS, aMBlocks, aAllocator);
+ BOPAlgo_Tools::MakeBlocks<TopoDS_Shape, TopTools_ShapeMapHasher>(aDMSLS, aMBlocks, aAllocator);
//
// 3. Fill same domain faces map -> aMSDF
- aNbS = aMBlocks.Extent();
- for (i=0; i<aNbS; ++i) {
- const BOPCol_ListOfShape& aLSD=aMBlocks.Find(i);
- if (aLSD.IsEmpty()) {
- continue;
- }
+ NCollection_List<BOPCol_ListOfShape>::Iterator aItB(aMBlocks);
+ for (; aItB.More(); aItB.Next()) {
+ const BOPCol_ListOfShape& aLSD = aItB.Value();
//
const TopoDS_Shape& aFSD1=aLSD.First();
aItF.Initialize(aLSD);
}
}
//=======================================================================
-//function : MakeBlocksCnx
-//purpose :
-//=======================================================================
-void MakeBlocksCnx(const BOPCol_IndexedDataMapOfShapeListOfShape& aMILI,
- BOPCol_DataMapOfIntegerListOfShape& aMBlocks,
- Handle(NCollection_BaseAllocator)& aAllocator)
-{
- Standard_Integer aNbV, aNbVS, aNbVP, aNbEC, k, i, j;
- BOPCol_ListIteratorOfListOfShape aItLI;
- //
- BOPCol_MapOfShape aMVS(100, aAllocator);
- BOPCol_IndexedMapOfShape aMEC(100, aAllocator);
- BOPCol_IndexedMapOfShape aMVP(100, aAllocator);
- BOPCol_IndexedMapOfShape aMVAdd(100, aAllocator);
- //
- aNbV=aMILI.Extent();
- //
- for (k=0,i=1; i<=aNbV; ++i) {
- aNbVS=aMVS.Extent();
- if (aNbVS==aNbV) {
- break;
- }
- //
- const TopoDS_Shape& nV=aMILI.FindKey(i);
- if (aMVS.Contains(nV)){
- continue;
- }
- aMVS.Add(nV);
- //
- aMEC.Clear();
- aMVP.Clear();
- aMVAdd.Clear();
- //
- aMVP.Add(nV);
- for(;;) {
- aNbVP=aMVP.Extent();
- for (j=1; j<=aNbVP; ++j) {
- const TopoDS_Shape& nVP=aMVP(j);
- const BOPCol_ListOfShape& aLV=aMILI.FindFromKey(nVP);
- aItLI.Initialize(aLV);
- for (; aItLI.More(); aItLI.Next()) {
- const TopoDS_Shape& nVx=aItLI.Value();
- if (aMEC.Contains(nVx)) {
- continue;
- }
- //
- aMVS.Add(nVx);
- aMEC.Add(nVx);
- aMVAdd.Add(nVx);
- }
- }
- //
- aNbVP=aMVAdd.Extent();
- if (!aNbVP) {
- break; // from while(1)
- }
- //
- aMVP.Clear();
- for (j=1; j<=aNbVP; ++j) {
- aMVP.Add(aMVAdd(j));
- }
- aMVAdd.Clear();
- }//while(1) {
- //
- BOPCol_ListOfShape aLIx(aAllocator);
- //
- aNbEC = aMEC.Extent();
- for (j=1; j<=aNbEC; ++j) {
- const TopoDS_Shape& nVx=aMEC(j);
- aLIx.Append(nVx);
- }
- //
- aMBlocks.Bind(k, aLIx);
- ++k;
- }//for (k=0,i=1; i<=aNbV; ++i)
- aMVAdd.Clear();
- aMVP.Clear();
- aMEC.Clear();
- aMVS.Clear();
-}
-//=======================================================================
-//function : FillMap
-//purpose :
-//=======================================================================
-void FillMap(const TopoDS_Shape& aS1,
- const TopoDS_Shape& aS2,
- BOPCol_IndexedDataMapOfShapeListOfShape& aDMSLS,
- Handle(NCollection_BaseAllocator)& aAllocator)
-{
- if (aDMSLS.Contains(aS1)) {
- BOPCol_ListOfShape& aLS=aDMSLS.ChangeFromKey(aS1);
- aLS.Append(aS2);
- }
- else {
- BOPCol_ListOfShape aLS(aAllocator);
- aLS.Append(aS2);
- aDMSLS.Add(aS1, aLS);
- }
- //
- if (aDMSLS.Contains(aS2)) {
- BOPCol_ListOfShape& aLS=aDMSLS.ChangeFromKey(aS2);
- aLS.Append(aS1);
- }
- else {
- BOPCol_ListOfShape aLS(aAllocator);
- aLS.Append(aS1);
- aDMSLS.Add(aS2, aLS);
- }
-}
-//=======================================================================
//function :HasPaveBlocksOnIn
//purpose :
//=======================================================================
}
return bRet;
}
-
-/*
-//DEBf
- {
- TopoDS_Compound aCx;
- BRep_Builder aBBx;
- BOPCol_ListIteratorOfListOfShape aItx;
- //
- aBBx.MakeCompound(aCx);
- aBBx.Add(aCx, aFF);
- aItx.Initialize(aLE);
- for (; aItx.More(); aItx.Next()) {
- const TopoDS_Shape& aEx=aItx.Value();
- aBBx.Add(aCx, aEx);
- }
- int a=0;
- }
- //DEBt
-*/
#include <BOPAlgo_Tools.hxx>
#include <BOPCol_DataMapOfIntegerInteger.hxx>
#include <BOPCol_DataMapOfIntegerListOfInteger.hxx>
+#include <BOPCol_IndexedDataMapOfIntegerListOfInteger.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_MapOfInteger.hxx>
#include <BOPDS_Curve.hxx>
//=======================================================================
void BOPAlgo_PaveFiller::PerformVV()
{
- Standard_Integer n1, n2, iFlag, aSize, k, aNbBlocks;
+ Standard_Integer n1, n2, iFlag, aSize;
Handle(NCollection_BaseAllocator) aAllocator;
//
myErrorStatus=0;
aAllocator=
NCollection_BaseAllocator::CommonBaseAllocator();
BOPCol_IndexedDataMapOfIntegerListOfInteger aMILI(100, aAllocator);
- BOPCol_DataMapOfIntegerListOfInteger aMBlocks(100, aAllocator);
+ NCollection_List<BOPCol_ListOfInteger> aMBlocks(aAllocator);
//
// 1. Map V/LV
for (; myIterator->More(); myIterator->Next()) {
//
iFlag=BOPTools_AlgoTools::ComputeVV(aV1, aV2, myFuzzyValue);
if (!iFlag) {
- BOPAlgo_Tools::FillMap(n1, n2, aMILI, aAllocator);
+ BOPAlgo_Tools::FillMap<Standard_Integer, TColStd_MapIntegerHasher>(n1, n2, aMILI, aAllocator);
}
}
//
// 2. Make blocks
- BOPAlgo_Tools::MakeBlocksCnx(aMILI, aMBlocks, aAllocator);
+ BOPAlgo_Tools::MakeBlocks<Standard_Integer, TColStd_MapIntegerHasher>(aMILI, aMBlocks, aAllocator);
//
// 3. Make vertices
- aNbBlocks=aMBlocks.Extent();
- for (k=0; k<aNbBlocks; ++k) {
- const BOPCol_ListOfInteger& aLI=aMBlocks.Find(k);
- //
+ NCollection_List<BOPCol_ListOfInteger>::Iterator aItB(aMBlocks);
+ for (; aItB.More(); aItB.Next()) {
+ const BOPCol_ListOfInteger& aLI = aItB.Value();
MakeSDVertices(aLI);
}
//
}
//
if (aMCB.Add(aCB)) {
- myDS->SortPaveBlocks(aCB);
aPB->Indices(nV1, nV2);
UpdateVertex(nV1, aTolV);
UpdateVertex(nV2, aTolV);
// 2
myDS->AddInterf(nE1, nE2);
//
- BOPAlgo_Tools::FillMap(aPB1, aPB2, aMPBLPB, aAllocator);
+ BOPAlgo_Tools::FillMap<Handle(BOPDS_PaveBlock), TColStd_MapTransientHasher>(aPB1, aPB2, aMPBLPB, aAllocator);
}//case TopAbs_EDGE
break;
default:
}
aPDS=aPF.PDS();
//
+ // Map to store the real tolerance of the common block
+ // and avoid repeated computation of it
+ NCollection_DataMap<Handle(BOPDS_CommonBlock),
+ Standard_Real,
+ TColStd_MapTransientHasher> aMCBTol;
+ // Map to avoid creation of different pave blocks for
+ // the same intersection edge
+ NCollection_DataMap<Standard_Integer, Handle(BOPDS_PaveBlock)> aMEPB;
+ //
aItLS.Initialize(aLS);
for (; aItLS.More(); aItLS.Next()) {
const TopoDS_Shape& aSx=aItLS.Value();
// add edge
aE=aPDS->Shape(aPBRx->Edge());
iE = myDS->Index(aE);
- //
if (iE < 0) {
aSI.SetShapeType(aType);
aSI.SetShape(aE);
iE=myDS->Append(aSI);
- // update real edge tolerance according to distances in common block if any
- if (aPDS->IsCommonBlock(aPBRx)) {
- const Handle(BOPDS_CommonBlock)& aCB = aPDS->CommonBlock(aPBRx);
+ }
+ //
+ // update real edge tolerance according to distances in common block if any
+ if (aPDS->IsCommonBlock(aPBRx)) {
+ const Handle(BOPDS_CommonBlock)& aCB = aPDS->CommonBlock(aPBRx);
+ Standard_Real *pTol = aMCBTol.ChangeSeek(aCB);
+ if (!pTol) {
Standard_Real aTol = BOPAlgo_Tools::ComputeToleranceOfCB(aCB, aPDS, aPF.Context());
- if (aNC.Tolerance() < aTol) {
- aNC.SetTolerance(aTol);
- }
+ pTol = aMCBTol.Bound(aCB, aTol);
+ }
+ //
+ if (aNC.Tolerance() < *pTol) {
+ aNC.SetTolerance(*pTol);
}
}
// append new PaveBlock to aLPBC
- Handle(BOPDS_PaveBlock) aPBC=new BOPDS_PaveBlock();
- BOPDS_Pave aPaveR1, aPaveR2;
- aPaveR1 = aPBRx->Pave1();
- aPaveR2 = aPBRx->Pave2();
- aPaveR1.SetIndex(myDS->Index(aPDS->Shape(aPaveR1.Index())));
- aPaveR2.SetIndex(myDS->Index(aPDS->Shape(aPaveR2.Index())));
+ Handle(BOPDS_PaveBlock) *pPBC = aMEPB.ChangeSeek(iE);
+ if (!pPBC) {
+ pPBC = aMEPB.Bound(iE, new BOPDS_PaveBlock());
+ BOPDS_Pave aPaveR1, aPaveR2;
+ aPaveR1 = aPBRx->Pave1();
+ aPaveR2 = aPBRx->Pave2();
+ aPaveR1.SetIndex(myDS->Index(aPDS->Shape(aPaveR1.Index())));
+ aPaveR2.SetIndex(myDS->Index(aPDS->Shape(aPaveR2.Index())));
+ //
+ (*pPBC)->SetPave1(aPaveR1);
+ (*pPBC)->SetPave2(aPaveR2);
+ (*pPBC)->SetEdge(iE);
+ }
//
- aPBC->SetPave1(aPaveR1);
- aPBC->SetPave2(aPaveR2);
- aPBC->SetEdge(iE);
if (bOld) {
- aPBC->SetOriginalEdge(aPB1->OriginalEdge());
- aDMExEdges.ChangeFind(aPB1).Append(aPBC);
+ (*pPBC)->SetOriginalEdge(aPB1->OriginalEdge());
+ aDMExEdges.ChangeFind(aPB1).Append(*pPBC);
}
else {
- aLPBC.Append(aPBC);
+ aLPBC.Append(*pPBC);
}
}
}
//
// 2. Update pave blocks
if (bCB) {
- //create new common blocks
+ // Create new common blocks
BOPDS_ListOfPaveBlock aLPBNew;
const BOPCol_ListOfInteger& aFaces = aCB1->Faces();
aIt.Initialize(aLPB);
for (; aIt.More(); aIt.Next()) {
const Handle(BOPDS_PaveBlock)& aPBValue = aIt.Value();
+ BOPDS_Pave aPBValuePaves[2] = {aPBValue->Pave1(), aPBValue->Pave2()};
//
aCB = new BOPDS_CommonBlock;
aIt1.Initialize(aLPB1);
aPB2 = aIt1.Value();
nE = aPB2->OriginalEdge();
//
+ // Create new pave block
aPB2n = new BOPDS_PaveBlock;
- aPB2n->SetPave1(aPBValue->Pave1());
- aPB2n->SetPave2(aPBValue->Pave2());
+ if (aPBValue->OriginalEdge() == nE) {
+ aPB2n->SetPave1(aPBValuePaves[0]);
+ aPB2n->SetPave2(aPBValuePaves[1]);
+ }
+ else {
+ // For the different original edge compute the parameters of paves
+ BOPDS_Pave aPave[2];
+ for (Standard_Integer i = 0; i < 2; ++i) {
+ Standard_Integer nV = aPBValuePaves[i].Index();
+ aPave[i].SetIndex(nV);
+ if (nV == aPB2->Pave1().Index()) {
+ aPave[i].SetParameter(aPB2->Pave1().Parameter());
+ }
+ else if (nV == aPB2->Pave2().Index()) {
+ aPave[i].SetParameter(aPB2->Pave2().Parameter());
+ }
+ else {
+ // Compute the parameter by projecting the point
+ const TopoDS_Vertex& aV = TopoDS::Vertex(myDS->Shape(nV));
+ const TopoDS_Edge& aEOr = TopoDS::Edge(myDS->Shape(nE));
+ Standard_Real aTOut, aDist;
+ Standard_Integer iErr = myContext->ComputeVE(aV, aEOr, aTOut, aDist, myFuzzyValue);
+ if (!iErr) {
+ aPave[i].SetParameter(aTOut);
+ }
+ else {
+ // Unable to project - set the parameter of the closest boundary
+ const TopoDS_Vertex& aV1 = TopoDS::Vertex(myDS->Shape(aPB2->Pave1().Index()));
+ const TopoDS_Vertex& aV2 = TopoDS::Vertex(myDS->Shape(aPB2->Pave2().Index()));
+ //
+ gp_Pnt aP = BRep_Tool::Pnt(aV);
+ gp_Pnt aP1 = BRep_Tool::Pnt(aV1);
+ gp_Pnt aP2 = BRep_Tool::Pnt(aV2);
+ //
+ Standard_Real aDist1 = aP.SquareDistance(aP1);
+ Standard_Real aDist2 = aP.SquareDistance(aP2);
+ //
+ aPave[i].SetParameter(aDist1 < aDist2 ? aPB2->Pave1().Parameter() : aPB2->Pave2().Parameter());
+ }
+ }
+ }
+ //
+ if (aPave[1].Parameter() < aPave[0].Parameter()) {
+ BOPDS_Pave aPaveTmp = aPave[0];
+ aPave[0] = aPave[1];
+ aPave[1] = aPaveTmp;
+ }
+ //
+ aPB2n->SetPave1(aPave[0]);
+ aPB2n->SetPave2(aPave[1]);
+ }
+ //
aPB2n->SetEdge(aPBValue->Edge());
aPB2n->SetOriginalEdge(nE);
aCB->AddPaveBlock(aPB2n);
myDS->ChangePaveBlocks(nE).Append(aPB2n);
}
aCB->SetFaces(aFaces);
- myDS->SortPaveBlocks(aCB);
//
const Handle(BOPDS_PaveBlock)& aPBNew = aCB->PaveBlocks().First();
aLPBNew.Append(aPBNew);
BOPDS_VectorOfInterfFF& aFFs = myDS->InterfFF();
NCollection_IndexedDataMap<Standard_Integer,BOPDS_ListOfPaveBlock> aMVIPBs;
BOPCol_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;
continue;
}
//
+ if (!aMPB.Add(aPB)) {
+ aItLPB.Next();
+ continue;
+ }
+ //
Standard_Boolean bIsReduced = Standard_False;
if (aPB->OriginalEdge() < 0) {
// It is possible that due to small angle between faces the
bCB=myDS->IsCommonBlock(aPB);
//
if (!(bV1 || bV2)) { // no new vertices here
- if (!myNonDestructive || (myNonDestructive && !bCB)) {
- nE = aPB->OriginalEdge();
- aPB->SetEdge(nE);
- if (!myNonDestructive && bCB) {
- const Handle(BOPDS_CommonBlock)& aCB = myDS->CommonBlock(aPB);
- Standard_Real aTol = BOPAlgo_Tools::ComputeToleranceOfCB(aCB, myDS, myContext);
- myDS->UpdateEdgeTolerance(nE, aTol);
+ if (!myNonDestructive || !bCB) {
+ if (bCB) {
+ if (!aPB->HasEdge()) {
+ const Handle(BOPDS_CommonBlock)& aCB = myDS->CommonBlock(aPB);
+ nE = aCB->PaveBlock1()->OriginalEdge();
+ aCB->SetEdge(nE);
+ // Compute tolerance of the common block and update the edge
+ Standard_Real aTol = BOPAlgo_Tools::ComputeToleranceOfCB(aCB, myDS, myContext);
+ myDS->UpdateEdgeTolerance(nE, aTol);
+ }
+ }
+ else {
+ nE = aPB->OriginalEdge();
+ aPB->SetEdge(nE);
}
continue;
}
const Handle(BOPDS_CommonBlock)& aCB=myDS->CommonBlock(aPB);
bCB=!aCB.IsNull();
if (bCB) {
- myDS->SortPaveBlocks(aCB);
aPB=aCB->PaveBlock1();
}
//
Standard_Boolean FindEdgeTangent(const BRepAdaptor_Curve& theCurve,
gp_Vec& theTangent);
-//=======================================================================
-//function : MakeBlocksCnx
-//purpose :
-//=======================================================================
-void BOPAlgo_Tools::MakeBlocksCnx(const BOPCol_IndexedDataMapOfIntegerListOfInteger& aMILI,
- BOPCol_DataMapOfIntegerListOfInteger& aMBlocks,
- const Handle(NCollection_BaseAllocator)& aAllocator)
-{
- Standard_Integer aNbV, nV, aNbVS, nVP, nVx, aNbVP, aNbEC, k, i, j;
- BOPCol_ListIteratorOfListOfInteger aItLI;
- //
- BOPCol_MapOfInteger aMVS(100, aAllocator);
- BOPCol_IndexedMapOfInteger aMEC(100, aAllocator);
- BOPCol_IndexedMapOfInteger aMVP(100, aAllocator);
- BOPCol_IndexedMapOfInteger aMVAdd(100, aAllocator);
- //
- aNbV=aMILI.Extent();
- //
- for (k=0,i=1; i<=aNbV; ++i) {
- aNbVS=aMVS.Extent();
- if (aNbVS==aNbV) {
- break;
- }
- //
- nV = aMILI.FindKey(i);
- if (aMVS.Contains(nV)){
- continue;
- }
- aMVS.Add(nV);
- //
- aMEC.Clear();
- aMVP.Clear();
- aMVAdd.Clear();
- //
- aMVP.Add(nV);
- for(;;) {
- aNbVP=aMVP.Extent();
- for (j=1; j<=aNbVP; ++j) {
- nVP=aMVP(j);
- const BOPCol_ListOfInteger& aLV=aMILI.FindFromKey(nVP);
- aItLI.Initialize(aLV);
- for (; aItLI.More(); aItLI.Next()) {
- nVx=aItLI.Value();
- if (aMEC.Contains(nVx)) {
- continue;
- }
- //
- aMVS.Add(nVx);
- aMEC.Add(nVx);
- aMVAdd.Add(nVx);
- }
- }
- //
- aNbVP=aMVAdd.Extent();
- if (!aNbVP) {
- break; // from while(1)
- }
- //
- aMVP.Clear();
- for (j=1; j<=aNbVP; ++j) {
- aMVP.Add(aMVAdd(j));
- }
- aMVAdd.Clear();
- }//while(1) {
- //
- BOPCol_ListOfInteger aLIx(aAllocator);
- //
- aNbEC = aMEC.Extent();
- for (j=1; j<=aNbEC; ++j) {
- nVx=aMEC(j);
- aLIx.Append(nVx);
- }
- //
- aMBlocks.Bind(k, aLIx);
- ++k;
- }//for (k=0,i=1; i<=aNbV; ++i)
- aMVAdd.Clear();
- aMVP.Clear();
- aMEC.Clear();
- aMVS.Clear();
-}
-//=======================================================================
-//function : FillMap
-//purpose :
-//=======================================================================
-void BOPAlgo_Tools::FillMap(const Standard_Integer n1,
- const Standard_Integer n2,
- BOPCol_IndexedDataMapOfIntegerListOfInteger& aMILI,
- const Handle(NCollection_BaseAllocator)& aAllocator)
-{
- if (aMILI.Contains(n1)) {
- BOPCol_ListOfInteger& aLI=aMILI.ChangeFromKey(n1);
- aLI.Append(n2);
- }
- else {
- BOPCol_ListOfInteger aLI(aAllocator);
- aLI.Append(n2);
- aMILI.Add(n1, aLI);
- }
- if (aMILI.Contains(n2)) {
- BOPCol_ListOfInteger& aLI=aMILI.ChangeFromKey(n2);
- aLI.Append(n1);
- }
- else {
- BOPCol_ListOfInteger aLI(aAllocator);
- aLI.Append(n1);
- aMILI.Add(n2, aLI);
- }
-}
-//=======================================================================
-//function : FillMap
-//purpose :
-//=======================================================================
-void BOPAlgo_Tools::FillMap(const Handle(BOPDS_PaveBlock)& aPB1,
- const Handle(BOPDS_PaveBlock)& aPB2,
- BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock& aMPBLPB,
- const Handle(NCollection_BaseAllocator)& aAllocator)
-{
- if (aMPBLPB.Contains(aPB1)) {
- BOPDS_ListOfPaveBlock& aLPB=aMPBLPB.ChangeFromKey(aPB1);
- aLPB.Append(aPB2);
- }
- else {
- BOPDS_ListOfPaveBlock aLPB(aAllocator);
- aLPB.Append(aPB2);
- aMPBLPB.Add(aPB1, aLPB);
- }
- if (aMPBLPB.Contains(aPB2)) {
- BOPDS_ListOfPaveBlock& aLPB=aMPBLPB.ChangeFromKey(aPB2);
- aLPB.Append(aPB1);
- }
- else {
- BOPDS_ListOfPaveBlock aLPB(aAllocator);
- aLPB.Append(aPB1);
- aMPBLPB.Add(aPB2, aLPB);
- }
-}
//=======================================================================
//function : FillMap
//purpose :
BOPDS_IndexedDataMapOfPaveBlockListOfInteger& aMPBLI,
const Handle(NCollection_BaseAllocator)& aAllocator)
{
- if (aMPBLI.Contains(aPB)) {
- BOPCol_ListOfInteger& aLI=aMPBLI.ChangeFromKey(aPB);
- aLI.Append(nF);
+ BOPCol_ListOfInteger *pLI = aMPBLI.ChangeSeek(aPB);
+ if (!pLI) {
+ pLI = &aMPBLI(aMPBLI.Add(aPB, BOPCol_ListOfInteger(aAllocator)));
}
- else {
- BOPCol_ListOfInteger aLI(aAllocator);
- aLI.Append(nF);
- aMPBLI.Add(aPB, aLI);
- }
-}
-//=======================================================================
-//function : MakeBlocks
-//purpose :
-//=======================================================================
-void BOPAlgo_Tools::MakeBlocks(const BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock& aMILI,
- BOPDS_DataMapOfIntegerListOfPaveBlock& aMBlocks,
- const Handle(NCollection_BaseAllocator)& aAllocator)
-{
- Standard_Integer aNbV, aNbVS, aNbVP, aNbEC, k, i, j;
- BOPDS_ListIteratorOfListOfPaveBlock aItLI;
- //
- BOPDS_MapOfPaveBlock aMVS(100, aAllocator);
- BOPDS_IndexedMapOfPaveBlock aMEC(100, aAllocator);
- BOPDS_IndexedMapOfPaveBlock aMVP(100, aAllocator);
- BOPDS_IndexedMapOfPaveBlock aMVAdd(100, aAllocator);
- //
- aNbV=aMILI.Extent();
- //
- for (k=0, i=1; i<=aNbV; ++i) {
- aNbVS=aMVS.Extent();
- if (aNbVS==aNbV) {
- break;
- }
- //
- const Handle(BOPDS_PaveBlock)& nV=aMILI.FindKey(i);
- if (aMVS.Contains(nV)){
- continue;
- }
- aMVS.Add(nV);
- //
- aMEC.Clear();
- aMVP.Clear();
- aMVAdd.Clear();
- //
- aMVP.Add(nV);
- for(;;) {
- aNbVP=aMVP.Extent();
- for (j=1; j<=aNbVP; ++j) {
- const Handle(BOPDS_PaveBlock)& nVP=aMVP(j);
- const BOPDS_ListOfPaveBlock& aLV=aMILI.FindFromKey(nVP);
- aItLI.Initialize(aLV);
- for (; aItLI.More(); aItLI.Next()) {
- const Handle(BOPDS_PaveBlock)& nVx=aItLI.Value();
- if (aMEC.Contains(nVx)) {
- continue;
- }
- //
- aMVS.Add(nVx);
- aMEC.Add(nVx);
- aMVAdd.Add(nVx);
- }
- }
- //
- aNbVP=aMVAdd.Extent();
- if (!aNbVP) {
- break; // from while(1)
- }
- //
- aMVP.Clear();
- for (j=1; j<=aNbVP; ++j) {
- aMVP.Add(aMVAdd(j));
- }
- aMVAdd.Clear();
- }//while(1) {
- //
- BOPDS_ListOfPaveBlock aLIx(aAllocator);
- //
- aNbEC = aMEC.Extent();
- for (j=1; j<=aNbEC; ++j) {
- const Handle(BOPDS_PaveBlock)& nVx=aMEC(j);
- aLIx.Append(nVx);
- }
- //
- aMBlocks.Bind(k, aLIx);
- ++k;
- }//for (k=0, i=1; i<=aNbV; ++i)
- aMVAdd.Clear();
- aMVP.Clear();
- aMEC.Clear();
- aMVS.Clear();
+ pLI->Append(nF);
}
//=======================================================================
//function : PerformCommonBlocks
return;
}
//
- Standard_Integer aNbPB, aNbBlocks, k;
- BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
Handle(BOPDS_CommonBlock) aCB;
- BOPDS_DataMapOfIntegerListOfPaveBlock aMBlocks(100, aAllocator);
+ NCollection_List<BOPDS_ListOfPaveBlock> aMBlocks(aAllocator);
//
- BOPAlgo_Tools::MakeBlocks(aMPBLPB, aMBlocks, aAllocator);
+ BOPAlgo_Tools::MakeBlocks<Handle(BOPDS_PaveBlock), TColStd_MapTransientHasher>(aMPBLPB, aMBlocks, aAllocator);
//
- aNbBlocks = aMBlocks.Extent();
- for (k=0; k<aNbBlocks; ++k) {
- const BOPDS_ListOfPaveBlock& aLPB=aMBlocks.Find(k);
- aNbPB=aLPB.Extent();
+ NCollection_List<BOPDS_ListOfPaveBlock>::Iterator aItB(aMBlocks);
+ for (; aItB.More(); aItB.Next()) {
+ const BOPDS_ListOfPaveBlock& aLPB = aItB.Value();
+ Standard_Integer aNbPB = aLPB.Extent();
if (aNbPB>1) {
aCB=new BOPDS_CommonBlock;
+ aCB->SetPaveBlocks(aLPB);
//
- aItLPB.Initialize(aLPB);
- for (; aItLPB.More(); aItLPB.Next()) {
- const Handle(BOPDS_PaveBlock)& aPBx=aItLPB.Value();
- aCB->AddPaveBlock(aPBx);
- }
- //
- aItLPB.Initialize(aLPB);
+ BOPDS_ListIteratorOfListOfPaveBlock aItLPB(aLPB);
for (; aItLPB.More(); aItLPB.Next()) {
- const Handle(BOPDS_PaveBlock)& aPBx=aItLPB.Value();
- pDS->SetCommonBlock(aPBx, aCB);
+ pDS->SetCommonBlock(aItLPB.Value(), aCB);
}
}//if (aNbPB>1) {
}
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
-#include <BOPCol_IndexedDataMapOfIntegerListOfInteger.hxx>
-#include <BOPCol_DataMapOfIntegerListOfInteger.hxx>
#include <BOPCol_BaseAllocator.hxx>
+#include <BOPDS_IndexedDataMapOfPaveBlockListOfInteger.hxx>
#include <BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock.hxx>
-#include <BOPDS_DataMapOfIntegerListOfPaveBlock.hxx>
#include <BOPDS_PDS.hxx>
#include <Standard_Integer.hxx>
-#include <BOPDS_IndexedDataMapOfPaveBlockListOfInteger.hxx>
class BOPDS_PaveBlock;
class BOPDS_CommonBlock;
class IntTools_Context;
class TopoDS_Shape;
-class BOPAlgo_Tools
+class BOPAlgo_Tools
{
public:
- DEFINE_STANDARD_ALLOC
+ //! Makes the chains of the connected elements from the given connexity map
+ 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)
+ {
+ NCollection_Map<theType, theTypeHasher> aMFence;
+ Standard_Integer i, aNb = theMILI.Extent();
+ for (i = 1; i <= aNb; ++i) {
+ const theType& n = theMILI.FindKey(i);
+ if (!aMFence.Add(n))
+ continue;
+ //
+ // Start the chain
+ NCollection_List<theType>& aChain = theMBlocks.Append(NCollection_List<theType>(theAllocator));
+ aChain.Append(n);
+ // Look for connected elements
+ typename NCollection_List<theType>::Iterator aItLChain(aChain);
+ for (; aItLChain.More(); aItLChain.Next()) {
+ const theType& n1 = aItLChain.Value();
+ const NCollection_List<theType>& aLI = theMILI.FindFromKey(n1);
+ // Add connected elements into the chain
+ typename NCollection_List<theType>::Iterator aItLI(aLI);
+ for (; aItLI.More(); aItLI.Next()) {
+ const theType& n2 = aItLI.Value();
+ if (aMFence.Add(n2)) {
+ aChain.Append(n2);
+ }
+ }
+ }
+ }
+ }
+ //! Fills the map with the connected entities
+ template <class theType, class theTypeHasher>
+ static void FillMap(const theType& n1,
+ const theType& n2,
+ NCollection_IndexedDataMap<theType, NCollection_List<theType>, theTypeHasher>& theMILI,
+ const BOPCol_BaseAllocator& theAllocator)
+ {
+ NCollection_List<theType> *pList1 = theMILI.ChangeSeek(n1);
+ if (!pList1) {
+ pList1 = &theMILI(theMILI.Add(n1, NCollection_List<theType>(theAllocator)));
+ }
+ pList1->Append(n2);
+ //
+ NCollection_List<theType> *pList2 = theMILI.ChangeSeek(n2);
+ if (!pList2) {
+ pList2 = &theMILI(theMILI.Add(n2, NCollection_List<theType>(theAllocator)));
+ }
+ pList2->Append(n1);
+ }
+
+ Standard_EXPORT static void FillMap(const Handle(BOPDS_PaveBlock)& thePB1,
+ const Standard_Integer theF,
+ BOPDS_IndexedDataMapOfPaveBlockListOfInteger& theMILI,
+ const BOPCol_BaseAllocator& theAllocator);
- Standard_EXPORT static void MakeBlocksCnx (const BOPCol_IndexedDataMapOfIntegerListOfInteger& theMILI, BOPCol_DataMapOfIntegerListOfInteger& theMBlocks, const BOPCol_BaseAllocator& theAllocator);
-
- Standard_EXPORT static void MakeBlocks (const BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock& theMILI, BOPDS_DataMapOfIntegerListOfPaveBlock& theMBlocks, const BOPCol_BaseAllocator& theAllocator);
-
- Standard_EXPORT static void PerformCommonBlocks (BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock& theMBlocks, const BOPCol_BaseAllocator& theAllocator, BOPDS_PDS& pDS);
-
- Standard_EXPORT static void FillMap (const Standard_Integer tneN1, const Standard_Integer tneN2, BOPCol_IndexedDataMapOfIntegerListOfInteger& theMILI, const BOPCol_BaseAllocator& theAllocator);
-
- Standard_EXPORT static void FillMap (const Handle(BOPDS_PaveBlock)& tnePB1, const Handle(BOPDS_PaveBlock)& tnePB2, BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock& theMILI, const BOPCol_BaseAllocator& theAllocator);
-
- Standard_EXPORT static void FillMap (const Handle(BOPDS_PaveBlock)& tnePB1, const Standard_Integer tneF, BOPDS_IndexedDataMapOfPaveBlockListOfInteger& theMILI, const BOPCol_BaseAllocator& theAllocator);
-
- Standard_EXPORT static void PerformCommonBlocks (const BOPDS_IndexedDataMapOfPaveBlockListOfInteger& theMBlocks, const BOPCol_BaseAllocator& theAllocator, BOPDS_PDS& pDS);
+ Standard_EXPORT static void PerformCommonBlocks(BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock& theMBlocks,
+ const BOPCol_BaseAllocator& theAllocator,
+ BOPDS_PDS& theDS);
+
+ Standard_EXPORT static void PerformCommonBlocks(const BOPDS_IndexedDataMapOfPaveBlockListOfInteger& theMBlocks,
+ const BOPCol_BaseAllocator& theAllocator,
+ BOPDS_PDS& pDS);
Standard_EXPORT static Standard_Real ComputeToleranceOfCB
(const Handle(BOPDS_CommonBlock)& theCB,
//=======================================================================
void BOPDS_CommonBlock::AddPaveBlock(const Handle(BOPDS_PaveBlock)& aPB)
{
- myPaveBlocks.Append(aPB);
+ if (myPaveBlocks.IsEmpty()) {
+ myPaveBlocks.Append(aPB);
+ return;
+ }
+ //
+ // Put the pave block with the minimal index of the original edge in the first place
+ if (aPB->OriginalEdge() < myPaveBlocks.First()->OriginalEdge()) {
+ myPaveBlocks.Prepend(aPB);
+ }
+ else {
+ myPaveBlocks.Append(aPB);
+ }
}
//=======================================================================
-// function: AddPaveBlocks
+// function: SetPaveBlocks
// purpose:
//=======================================================================
- void BOPDS_CommonBlock::AddPaveBlocks(const BOPDS_ListOfPaveBlock& aLPB)
+ void BOPDS_CommonBlock::SetPaveBlocks(const BOPDS_ListOfPaveBlock& aLPB)
{
- myPaveBlocks=aLPB;
+ myPaveBlocks.Clear();
+ BOPDS_ListIteratorOfListOfPaveBlock aIt(aLPB);
+ for (; aIt.More(); aIt.Next()) {
+ AddPaveBlock(aIt.Value());
+ }
}
//=======================================================================
// function: PaveBlocks
DEFINE_STANDARD_HANDLE(BOPDS_CommonBlock, MMgt_TShared)
-//! The class BOPDS_CommonBlock is to store
-//! the information about pave blocks that have
-//! geometry coincidence (in terms of a tolerance) with
-//! a) other pave block(s)
-//! b) face(s)
+//! The class BOPDS_CommonBlock is to store the information
+//! about pave blocks that have geometrical coincidence
+//! (in terms of a tolerance) with:<br>
+//! a) other pave block(s);<br>
+//! b) face(s).<br>
+//! First pave block in the common block (real pave block)
+//! is always a pave block with the minimal index of the original edge.
class BOPDS_CommonBlock : public MMgt_TShared
{
//! Adds the list of pave blocks <aLPB>
//! to the list of pave blocks
//! of the common block
- Standard_EXPORT void AddPaveBlocks (const BOPDS_ListOfPaveBlock& aLPB);
+ Standard_EXPORT void SetPaveBlocks (const BOPDS_ListOfPaveBlock& aLPB);
//! Modifier
//
while (aLPBx.Extent()) {
Standard_Boolean bCoinside;
- Standard_Real aTol, aTolMax(0.);
BOPDS_ListOfPaveBlock aLPBxN;
//
aItPB.Initialize(aLPBx);
const Handle(BOPDS_PaveBlock)& aPBCx = aLPBxN.First();
bCoinside = CheckCoincidence(aPBx, aPBCx, theFuzz);
if (bCoinside) {
- nE = aPBx->OriginalEdge();
- const TopoDS_Edge& aE = *(TopoDS_Edge*)&Shape(nE);
- aTol = BRep_Tool::Tolerance(aE);
- //
- //pave block with the max tolerance of the original edge
- //must be the first in the common block
- if (aTolMax < aTol) {
- aTolMax = aTol;
- aLPBxN.Prepend(aPBx);
- } else {
- aLPBxN.Append(aPBx);
- }
+ aLPBxN.Append(aPBx);
aLPBx.Remove(aItPB);
continue;
}//if (bCoinside) {
}//if (aLPBxN.Extent()) {
else {
- nE = aPBx->OriginalEdge();
- const TopoDS_Edge& aE = *(TopoDS_Edge*)&Shape(nE);
- aTolMax = BRep_Tool::Tolerance(aE);
- //
aLPBxN.Append(aPBx);
aLPBx.Remove(aItPB);
continue;
}//for(; aItPB.More(); ) {
//
aCBx=new BOPDS_CommonBlock;
- aCBx->AddPaveBlocks(aLPBxN);
+ aCBx->SetPaveBlocks(aLPBxN);
aCBx->SetFaces(aLF);
//
aItPB.Initialize(aLPBxN);
if (aNbPoints) {
aD=aPPC.LowerDistance();
//
- aTol=BRep_Tool::Tolerance(aE1);
- aTol = aTol + BRep_Tool::Tolerance(aE2) + Max(theFuzz, Precision::Confusion());
+ aTol = BRep_Tool::MaxTolerance(aE1, TopAbs_VERTEX);
+ aTol = aTol + BRep_Tool::MaxTolerance(aE2, TopAbs_VERTEX) + Max(theFuzz, Precision::Confusion());
if (aD<aTol) {
aT2x=aPPC.LowerDistanceParameter();
if (aT2x>aT21 && aT2x<aT22) {
return bRet;
}
//=======================================================================
-// function: SortPaveBlocks
-// purpose:
-//=======================================================================
-void BOPDS_DS::SortPaveBlocks(const Handle(BOPDS_CommonBlock)& aCB)
-{
- Standard_Integer theI;
- Standard_Boolean bToSort;
- bToSort = IsToSort(aCB, theI);
- if (!bToSort) {
- return;
- }
-
- Standard_Integer i(0);
- const BOPDS_ListOfPaveBlock& aLPB = aCB->PaveBlocks();
- BOPDS_ListOfPaveBlock aLPBN = aLPB;
-
- Handle(BOPDS_PaveBlock) aPB;
- BOPDS_ListIteratorOfListOfPaveBlock aIt;
- //
- aIt.Initialize(aLPBN);
- for (aIt.Next(); aIt.More(); ) {
- i++;
- if(i == theI) {
- aPB = aIt.Value();
- aLPBN.Remove(aIt);
- aLPBN.Prepend(aPB);
- break;
- }
- aIt.Next();
- }
- //
- aCB->AddPaveBlocks(aLPBN);
-}
-//=======================================================================
-// function: IsToSort
-// purpose:
-//=======================================================================
-Standard_Boolean BOPDS_DS::IsToSort
- (const Handle(BOPDS_CommonBlock)& aCB,
- Standard_Integer& theI)
-{
- Standard_Boolean bRet;
- bRet = Standard_False;
- const BOPDS_ListOfPaveBlock& aLPB = aCB->PaveBlocks();
- if (aLPB.Extent()==1) {
- return bRet;
- }
-
- Standard_Integer nE;
- Standard_Real aTolMax, aTol;
- Handle(BOPDS_PaveBlock) aPB;
- TopoDS_Edge aE;
- BOPDS_ListIteratorOfListOfPaveBlock aIt;
- //
- aPB = aLPB.First();
- nE = aPB->OriginalEdge();
- aE = (*(TopoDS_Edge *)(&Shape(nE)));
- aTolMax = BRep_Tool::Tolerance(aE);
- //
- theI = 0;
- aIt.Initialize(aLPB);
- for (aIt.Next(); aIt.More(); aIt.Next()) {
- theI++;
- aPB = aIt.Value();
- nE = aPB->OriginalEdge();
- aE = (*(TopoDS_Edge *)(&Shape(nE)));
- aTol = BRep_Tool::Tolerance(aE);
- if (aTolMax < aTol) {
- aTolMax = aTol;
- bRet = Standard_True;
- }
- }
-
- return bRet;
-}
-//=======================================================================
// function: IsSubShape
// purpose:
//=======================================================================
Standard_EXPORT void Dump() const;
- Standard_EXPORT void SortPaveBlocks (const Handle(BOPDS_CommonBlock)& theCB);
-
- Standard_EXPORT Standard_Boolean IsToSort (const Handle(BOPDS_CommonBlock)& theCB, Standard_Integer& theI);
-
Standard_EXPORT Standard_Boolean IsSubShape (const Standard_Integer theI1, const Standard_Integer theI2);
//! Fills theLP with sorted paves
#include <NCollection_IndexedDataMap.hxx>
#include <TColStd_MapTransientHasher.hxx>
#include <BOPCol_ListOfInteger.hxx>
+#include <BOPDS_PaveBlock.hxx>
typedef NCollection_IndexedDataMap<Handle(BOPDS_PaveBlock), BOPCol_ListOfInteger, TColStd_MapTransientHasher> BOPDS_IndexedDataMapOfPaveBlockListOfInteger;
// function: MakeConnexityBlocks
// purpose:
//=======================================================================
-void BOPTools_AlgoTools::MakeConnexityBlocks
+void BOPTools_AlgoTools::MakeConnexityBlocks
(const TopoDS_Shape& theS,
const TopAbs_ShapeEnum theType1,
const TopAbs_ShapeEnum theType2,
BOPCol_ListOfShape& theLCB)
{
- Standard_Integer aNbF, aNbAdd, aNbAdd1, i;
+ // Map shapes to find connected elements
+ BOPCol_IndexedDataMapOfShapeListOfShape aDMSLS;
+ BOPTools::MapShapesAndAncestors(theS, theType1, theType2, aDMSLS);
+ // Fence map
+ BOPCol_MapOfShape aMFence;
+ Standard_Integer i;
BRep_Builder aBB;
- TopoDS_Compound aC;
- TopoDS_Iterator aIt;
- TopExp_Explorer aExp;
- BOPCol_MapOfShape aMP;
- BOPCol_IndexedMapOfShape aMCB, aMAdd, aMAdd1;
- BOPCol_IndexedDataMapOfShapeListOfShape aMEF;
- BOPCol_ListIteratorOfListOfShape aItLF;
//
- // 1. aMEF
- BOPTools::MapShapesAndAncestors(theS, theType1, theType2, aMEF);
- //
- // 2. aMCB
- aIt.Initialize(theS);
- for (; aIt.More(); aIt.Next()) {
- const TopoDS_Shape& aF1=aIt.Value();
- if (aMP.Contains(aF1)) {
+ TopExp_Explorer aExp(theS, theType2);
+ for (; aExp.More(); aExp.Next()) {
+ const TopoDS_Shape& aS = aExp.Current();
+ if (!aMFence.Add(aS)) {
continue;
}
- //
- aMCB.Clear();
- aMAdd.Clear();
- aMAdd.Add(aF1);
- //
- for(;;) {
- aMAdd1.Clear();
- //
- aNbAdd = aMAdd.Extent();
- for (i=1; i<=aNbAdd; ++i) {
- const TopoDS_Shape& aF=aMAdd(i);
- //
- aExp.Init(aF, theType1);
- for (; aExp.More(); aExp.Next()) {
- const TopoDS_Shape& aE=aExp.Current();
- //
- const BOPCol_ListOfShape& aLF=aMEF.FindFromKey(aE);
- aItLF.Initialize(aLF);
- for (; aItLF.More(); aItLF.Next()) {
- const TopoDS_Shape& aFx=aItLF.Value();
- if (aFx.IsSame(aF)) {
- continue;
- }
- if (aMCB.Contains(aFx)) {
- continue;
- }
- aMAdd1.Add(aFx);
+ // The block
+ BOPCol_IndexedMapOfShape aMBlock;
+ TopoDS_Compound aBlock;
+ aBB.MakeCompound(aBlock);
+ // Start the block
+ aMBlock.Add(aS);
+ aBB.Add(aBlock, aS);
+ // Look for connected parts
+ for (i = 1; i <= aMBlock.Extent(); ++i) {
+ const TopoDS_Shape& aS1 = aMBlock(i);
+ TopExp_Explorer aExpSS(aS1, theType1);
+ for (; aExpSS.More(); aExpSS.Next()) {
+ const TopoDS_Shape& aSubS = aExpSS.Current();
+ const BOPCol_ListOfShape& aLS = aDMSLS.FindFromKey(aSubS);
+ BOPCol_ListIteratorOfListOfShape aItLS(aLS);
+ for (; aItLS.More(); aItLS.Next()) {
+ const TopoDS_Shape& aS2 = aItLS.Value();
+ if (aMFence.Add(aS2)) {
+ aMBlock.Add(aS2);
+ aBB.Add(aBlock, aS2);
}
- }//for (; aExp.More(); aExp.Next()){
- aMCB.Add(aF);
- }// for (i=1; i<=aNbAdd; ++i) {
- //
- aNbAdd1=aMAdd1.Extent();
- if (!aNbAdd1) {
- break;// ->make new CB from aMCB
- }
- //
- aMAdd.Clear();
- for (i=1; i<=aNbAdd1; ++i) {
- const TopoDS_Shape& aFAdd = aMAdd1(i);
- aMAdd.Add(aFAdd);
- }
- }//while(1) {
- //
- aNbF=aMCB.Extent();
- if (aNbF) {
- aBB.MakeCompound(aC);
- //
- for (i=1; i<=aNbF; ++i) {
- const TopoDS_Shape& aF=aMCB(i);
- aBB.Add(aC, aF);
- aMP.Add(aF);
+ }
}
- theLCB.Append(aC);
}
- }// for (; aIt.More(); aIt.Next())
+ // Add the block into result
+ theLCB.Append(aBlock);
+ }
}
//=======================================================================
// function: OrientEdgesOnWire
if (F1.IsSame(F2)) return;
if (IsDone(F1,F2)) return;
+
const TopoDS_Shape& InitF1 = InitOffsetFace.ImageFrom(F1);
const TopoDS_Shape& InitF2 = InitOffsetFace.ImageFrom(F2);
+ if (InitF1.IsSame(InitF2)) return;
+
Standard_Boolean InterPipes = (InitF2.ShapeType() == TopAbs_EDGE &&
InitF1.ShapeType() == TopAbs_EDGE );
Standard_Boolean InterFaces = (InitF1.ShapeType() == TopAbs_FACE &&
const TopoDS_Shape& Root = itLOF.Value();
if (!myFaces.Contains(Root)) {
if (myInitOffsetFace.HasImage(Root)) {
- OffsetFaces.Append(myInitOffsetFace.Image(Root).First());
+ TopTools_ListIteratorOfListOfShape aItLS(myInitOffsetFace.Image(Root));
+ for (; aItLS.More(); aItLS.Next()) {
+ OffsetFaces.Append(aItLS.Value());
+ }
}
}
}
//
// intersect valid splits with bounds and update both
BOPAlgo_Builder aGF;
- aGF.AddArgument(aSplits);
+ // The order is important here, because we need to keep the
+ // unmodified edges from the Bounds in the resulting maps.
+ // In case of total coincidence of the edges with the same vertices
+ // the edges in the common block will not be split and no new
+ // edges will be created and the first pave block
+ // will be used as a real pave block.
aGF.AddArgument(aBounds);
+ aGF.AddArgument(aSplits);
aGF.Perform();
//
// update splits
UpdateOrigins(aLABounds, theEdgesOrigins, aGF);
UpdateIntersectedEdges(aLABounds, theETrimEInf, aGF);
//
- // update the edges to avoid with the splits
+ // update the EdgesToAvoid with the splits
TopTools_IndexedMapOfShape aNewEdges;
const TopTools_ListOfShape* pSplitsIm = aGF.Images().Seek(aSplits);
if (pSplitsIm) {
for (; aItLEIm.More(); aItLEIm.Next()) {
const TopoDS_Shape& aEIm = aItLEIm.Value();
if (!aNewEdges.Contains(aEIm)) {
- theEdgesToAvoid.Add(aItLEIm.Value());
+ theEdgesToAvoid.Add(aEIm);
}
}
}
checkprops result -s 181.203
checkshape result
-checknbshapes result -vertex 2 -edge 3 -wire 3 -face 1 -shell 0 -solid 0 -compsolid 0 -compound 1 -shape 10
+checknbshapes result -face 1
checkview -display result -2d -path ${imagedir}/${test_image}.png
puts "0027383: Modeling - improve handling of regularity on edges"
puts "========"
puts ""
-puts "Check regularity setting on edges between same-domain faces after fuse"
+#################################################################
+# Check regularity setting on edges between same-domain faces after fuse
+#################################################################
# fuse of two boxes
pload MODELING
bfuse r b1 b2
explode r f
explode r_7 e
-getedgeregularity r_7_3 r_3 r_7 ;# returns C0: regularity is not set at all
+getedgeregularity r_7_4 r_3 r_7 ;# returns C0: regularity is not set at all
encoderegularity r
-explode res f
-explode res_3 e
-explode res_4 e
-if { ! [regexp "CN" [getedgeregularity r_7_3 r_3 r_7]] } {
+if { ! [regexp "CN" [getedgeregularity r_7_4 r_3 r_7]] } {
puts "Error: Invalid regularity of the edge, expected CN"
}
-puts "TODO OCC27414 ALL: Error : The volume of result shape is"
-puts "TODO OCC27414 ALL: Error : The area of result shape is"
+puts "TODO OCC27414 ALL: Error: The command cannot be built"
+puts "TODO OCC27414 ALL: gives an empty result"
+puts "TODO OCC27414 ALL: TEST INCOMPLETE"
restore [locate_data_file bug26917_input.dom7742_trim1.brep] s
projects / occt-copy.git / commitdiff