//=======================================================================
// function: CheckFacePaves
// purpose:
//=======================================================================
Standard_Integer NMTTools_PaveFiller::CheckFacePaves
(const TopoDS_Vertex& aNewVertex,
const Standard_Integer nF)
{
Standard_Integer nEF, nVF, iFlag, i, aNbV, iRet;
BOPTools_ListIteratorOfListOfPave anIt;
TColStd_IndexedMapOfInteger aMVF;
//
iRet=0;
//
BooleanOperations_OnceExplorer aExp(*myDS);
aExp.Init(nF, TopAbs_EDGE);
for (; aExp.More(); aExp.Next()) {
nEF=aExp.Current();
BOPTools_PaveSet& aPaveSet=myPavePool(myDS->RefEdge(nEF));
const BOPTools_ListOfPave& aLP=aPaveSet.Set();
anIt.Initialize(aLP);
for (; anIt.More(); anIt.Next()) {
const BOPTools_Pave& aPave=anIt.Value();
nVF=aPave.Index();
aMVF.Add(nVF);
}
}
//
aNbV=aMVF.Extent();
for (i=1; i<=aNbV; ++i) {
nVF=aMVF(i);
const TopoDS_Vertex aVF=TopoDS::Vertex(myDS->Shape(nVF));
iFlag=IntTools_Tools::ComputeVV(aNewVertex, aVF);
if (!iFlag) {
return nVF;
}
}
return iRet;
}
//=======================================================================
// function: UpdateCandidates
// purpose:
//=======================================================================
void UpdateCandidates(const Standard_Integer theNF,
const Standard_Integer theNV,
NMTTools_IndexedDataMapOfIndexedMapOfInteger& theMFMV)
{
if (theMFMV.Contains(theNF)) {
TColStd_IndexedMapOfInteger& aMV=theMFMV.ChangeFromKey(theNF);
aMV.Add(theNV);
}
else {
TColStd_IndexedMapOfInteger aMV;
aMV.Add(theNV);
theMFMV.Add(theNF, aMV);
}
}
//=======================================================================
//function : GetAllSuccessorsS
//purpose :
//=======================================================================
void GetAllSuccessorsS(const Standard_Integer nS,
const NMTDS_ShapesDataStructure* myDS,
TColStd_IndexedMapOfInteger& aMA)
{
TopAbs_ShapeEnum aT;
Standard_Integer i, nSx, aNbSuccessors, *pSuccessors;
Standard_Address xSuccessors;
//
const TopoDS_Shape& aS=myDS->Shape(nS);
aT=aS.ShapeType();
if(NMTDS_Tools::HasBRep(aT)) {
aMA.Add(nS);
//
if (aT==TopAbs_VERTEX) {
return;
}
}
//
myDS->GetSuccessors(nS, xSuccessors, aNbSuccessors);
pSuccessors=(Standard_Integer*)xSuccessors;
for (i=0; i<aNbSuccessors; ++i) {
nSx=pSuccessors[i];
GetAllSuccessorsS(nSx, myDS, aMA);
}
}
//=======================================================================
// function: MakeAloneVertices
// purpose:
//=======================================================================
void NMTTools_PaveFiller::MakeAloneVertices()
{
Standard_Integer i, aNbFFs, nF1, nF2, j, aNbPnts, nFx, aNbV;
Standard_Real aTolF1, aTolF2, aTolSum, aTolV;
TColStd_ListIteratorOfListOfInteger aIt;
TColStd_ListOfInteger aLI;
TopoDS_Vertex aV;
TopoDS_Compound aCompound;
BRep_Builder aBB;
TopTools_DataMapOfShapeListOfInteger aDMVFF, aDMVFF1;
TopTools_DataMapIteratorOfDataMapOfShapeListOfInteger aItDMVFF;
TopTools_DataMapOfShapeShape aDMVV;
TopTools_DataMapOfIntegerShape aDMIV;
TopTools_DataMapOfShapeInteger aDMVI;
TopTools_DataMapIteratorOfDataMapOfShapeInteger aItDMVI;
TopTools_DataMapIteratorOfDataMapOfIntegerShape aItDMIV;
//
aBB.MakeCompound(aCompound);
//
myAloneVertices.Clear();
//
BOPTools_CArray1OfSSInterference& aFFs=myIP->SSInterferences();
//
// 1. Collect alone vertices from FFs
aNbV=0;
aNbFFs=aFFs.Extent();
for (i=1; i<=aNbFFs; ++i) {
BOPTools_SSInterference& aFFi=aFFs(i);
aFFi.Indices(nF1, nF2);
//
const TopoDS_Face aF1=TopoDS::Face(myDS->Shape(nF1));//mpv
const TopoDS_Face aF2=TopoDS::Face(myDS->Shape(nF2));//mpv
//
aTolF1=BRep_Tool::Tolerance(aF1);
aTolF2=BRep_Tool::Tolerance(aF2);
aTolSum=aTolF1+aTolF2;
//
aLI.Clear();
aLI.Append(nF1);
aLI.Append(nF2);
//
const IntTools_SequenceOfPntOn2Faces& aSeqAlonePnts=aFFi.AlonePnts();
aNbPnts=aSeqAlonePnts.Length();
for (j=1; j<=aNbPnts; ++j) {
const gp_Pnt& aP=aSeqAlonePnts(j).P1().Pnt();
BOPTools_Tools::MakeNewVertex(aP, aTolSum, aV);
aDMVFF.Bind(aV, aLI);
aBB.Add(aCompound, aV);
++aNbV;
}
}
if (!aNbV) {
return;
}
//
// 2. Try to fuse alone vertices themselves;
FuseVertices(aCompound, aDMVV);
//
// if some are fused, replace them by new ones
aItDMVFF.Initialize(aDMVFF);
for (; aItDMVFF.More(); aItDMVFF.Next()) {
const TopoDS_Shape& aVx=aItDMVFF.Key();
const TColStd_ListOfInteger& aLIx=aItDMVFF.Value();
//
if (!aDMVV.IsBound(aVx)) {
aDMVFF1.Bind(aVx, aLIx);
}
else {
const TopoDS_Shape& aVy=aDMVV.Find(aVx);
if (aDMVFF1.IsBound(aVy)) {
TColStd_ListOfInteger& aLIy=aDMVFF1.ChangeFind(aVy);
aIt.Initialize(aLIx);
for(; aIt.More(); aIt.Next()) {
nFx=aIt.Value();
aLIy.Append(nFx);
}
}
else {
aDMVFF1.Bind(aVy, aLIx);
}
}
}
aDMVFF.Clear();
//
// refine lists of faces in aDMVFF1;
aItDMVFF.Initialize(aDMVFF1);
for (; aItDMVFF.More(); aItDMVFF.Next()) {
TColStd_MapOfInteger aMIy;
TColStd_ListOfInteger aLIy;
//
const TopoDS_Shape& aVx=aItDMVFF.Key();
TColStd_ListOfInteger& aLIx=aDMVFF1.ChangeFind(aVx);
aIt.Initialize(aLIx);
for(; aIt.More(); aIt.Next()) {
nFx=aIt.Value();
if (aMIy.Add(nFx)) {
aLIy.Append(nFx);
}
}
aLIx.Clear();
aLIx.Append(aLIy);
}
//==================================
//
// 3. Collect vertices from DS
Standard_Integer aNbS, nV, nVSD, aNbVDS, i1, i2, aNbVSD;
//
aNbS=myDS->NumberOfShapesOfTheObject();
// old shapes
for (i=1; i<=aNbS; ++i) {
const TopoDS_Shape& aS=myDS->Shape(i);
if (aS.ShapeType() != TopAbs_VERTEX){
continue;
}
//
nVSD=FindSDVertex(i);
nV=(nVSD) ? nVSD : i;
const TopoDS_Shape& aVx=myDS->Shape(nV);
if (!aDMVI.IsBound(aVx)) {
aDMVI.Bind(aVx, nV);
}
}
// new shapes
i1=myDS->NumberOfSourceShapes()+1;
i2=myDS->NumberOfInsertedShapes();
for (i=i1; i<=i2; ++i) {
const TopoDS_Shape aS=myDS->Shape(i);//mpv
if (aS.ShapeType() != TopAbs_VERTEX){
continue;
}
if (!aDMVI.IsBound(aS)) {
aDMVI.Bind(aS, i);
}
}
//
// 4. Initialize BoundSortBox on aDMVI
//
Handle(Bnd_HArray1OfBox) aHAB;
Bnd_BoundSortBox aBSB;
//
aNbVDS=aDMVI.Extent();
aHAB=new Bnd_HArray1OfBox(1, aNbVDS);
//
aItDMVI.Initialize(aDMVI);
for (i=1; aItDMVI.More(); aItDMVI.Next(), ++i) {
Bnd_Box aBox;
//
nV=aItDMVI.Value();
aV=TopoDS::Vertex(aItDMVI.Key());
aTolV=BRep_Tool::Tolerance(aV);
aBox.SetGap(aTolV);
BRepBndLib::Add(aV, aBox);
aHAB->SetValue(i, aBox);
//
aDMIV.Bind(i, aV);
}
aBSB.Initialize(aHAB);
//
// 5. Compare
aItDMVFF.Initialize(aDMVFF1);
for (; aItDMVFF.More(); aItDMVFF.Next()) {
Bnd_Box aBoxV;
//
const TColStd_ListOfInteger& aLIFF=aItDMVFF.Value();
aV=TopoDS::Vertex(aItDMVFF.Key());
//
aTolV=BRep_Tool::Tolerance(aV);
aBoxV.SetGap(aTolV);
BRepBndLib::Add(aV, aBoxV);
//
const TColStd_ListOfInteger& aLIVSD=aBSB.Compare(aBoxV);
aNbVSD=aLIVSD.Extent();
if (aNbVSD==0) {
// add new vertex in DS and update map myAloneVertices
BooleanOperations_AncestorsSeqAndSuccessorsSeq anASSeq;
//
myDS->InsertShapeAndAncestorsSuccessors(aV, anASSeq);
nV=myDS->NumberOfInsertedShapes();
//
aIt.Initialize(aLIFF);
for (; aIt.More(); aIt.Next()) {
nFx=aIt.Value();
if (myAloneVertices.Contains(nFx)) {
TColStd_IndexedMapOfInteger& aMVx=myAloneVertices.ChangeFromKey(nFx);
aMVx.Add(nV);
}
else {
TColStd_IndexedMapOfInteger aMVx;
aMVx.Add(nV);
myAloneVertices.Add(nFx, aMVx);
}
}
}
}
// qqf
{
Standard_Integer aNbF, aNbAV, nF, k;
NMTTools_IndexedDataMapOfIndexedMapOfInteger aMAVF;
//
aNbF=myAloneVertices.Extent();
if (aNbF<2) {
return;
}
//
// 1. fill map Alone Vertex/Face -> aMAVF
for (i=1; i<=aNbF; ++i) {
nF=myAloneVertices.FindKey(i);
const TColStd_IndexedMapOfInteger& aMAV=myAloneVertices(i);
aNbAV=aMAV.Extent();
for(j=1; j<=aNbAV; ++j) {
nV=aMAV(j);
if (aMAVF.Contains(nV)) {
TColStd_IndexedMapOfInteger& aMF=aMAVF.ChangeFromKey(nV);
aMF.Add(nF);
}
else{
TColStd_IndexedMapOfInteger aMF;
aMF.Add(nF);
aMAVF.Add(nV, aMF);
}
}
}
//
// 2 Obtain pairs of faces
aNbAV=aMAVF.Extent();
for (i=1; i<=aNbAV; ++i) {
const TColStd_IndexedMapOfInteger& aMF=aMAVF(i);
aNbF=aMF.Extent();
for(j=1; j<aNbF; ++j) {
nF1=aMF(j);
for(k=j+1; k<=aNbF; ++k) {
nF2=aMF(k);
myIP->Add(nF1, nF2, Standard_True, NMTDS_TI_FF);
}
}
}
}
// qqt
}
//=======================================================================
// function: BuildSplitFaces
// purpose:
//=======================================================================
void GEOMAlgo_Builder::BuildSplitFaces()
{
const NMTDS_ShapesDataStructure& aDS=*myPaveFiller->DS();
NMTTools_PaveFiller* pPF=myPaveFiller;
NMTDS_InterfPool* pIP=pPF->IP();
BOPTools_CArray1OfSSInterference& aFFs=pIP->SSInterferences();
const Handle(IntTools_Context)& aCtx= pPF->Context();
//
Standard_Boolean bToReverse, bIsClosed, bIsDegenerated;
Standard_Integer i, aNb, aNbF, nF;
TopTools_MapOfShape aMFence;
TColStd_IndexedMapOfInteger aMFP;
TopExp_Explorer anExp;
TopoDS_Face aFF;
TopoDS_Edge aSp, aEE;
TopTools_ListIteratorOfListOfShape aIt;
TopAbs_Orientation anOriF, anOriE;
//
mySplitFaces.Clear();
//
// 1. Select Faces to process (MFP)
aNb=aDS.NumberOfShapesOfTheObject();
for (i=1; i<=aNb; ++i) {
const TopoDS_Shape& aF=aDS.Shape(i);
if (aF.ShapeType()!=TopAbs_FACE) {
continue;
}
if (!aMFence.Add(aF)) {
continue;
}
//
if (myInParts.Contains(aF)) {
aMFP.Add(i);
continue;
}
//
anExp.Init(aF, TopAbs_EDGE);
for (; anExp.More(); anExp.Next()) {
const TopoDS_Shape& aE=anExp.Current();
if (myImages.HasImage(aE)) {
aMFP.Add(i);
break;
}
}
//
//===
{
Standard_Integer aNbFFs, aNbSE, j, n1, n2;
//
aNbFFs=aFFs.Extent();
for (j=1; j<=aNbFFs; ++j) {
BOPTools_SSInterference& aFFj=aFFs(j);
aFFj.Indices(n1, n2);
if (!(n1==i || n2==i)) {
continue;
}
//
const TColStd_ListOfInteger& aLSE=aFFj.SharedEdges();
aNbSE=aLSE.Extent();
if (aNbSE) {
aMFP.Add(i);
break;
}
}
}
//===
//
}// for (i=1; i<=aNb; ++i)
//
// 2. ProcessFaces
aNbF=aMFP.Extent();
for (i=1; i<=aNbF; ++i) {
nF=aMFP(i);
const TopoDS_Face& aF=TopoDS::Face(aDS.Shape(nF));
anOriF=aF.Orientation();
aFF=aF;
aFF.Orientation(TopAbs_FORWARD);
//
aMFence.Clear();
//
// 2.1. Fill WES
GEOMAlgo_WireEdgeSet aWES;
aWES.SetFace(aFF);
//
// 2.1.1. Add Split parts
anExp.Init(aFF, TopAbs_EDGE);
for (; anExp.More(); anExp.Next()) {
const TopoDS_Edge& aE=TopoDS::Edge(anExp.Current());
anOriE=aE.Orientation();
//
if (!myImages.HasImage(aE)) {
if (anOriE==TopAbs_INTERNAL) {
aEE=aE;
aEE.Orientation(TopAbs_FORWARD);
aWES.AddStartElement(aEE);
aEE.Orientation(TopAbs_REVERSED);
aWES.AddStartElement(aEE);
}
else {
aWES.AddStartElement(aE);
}
continue;
}
//
bIsDegenerated=BRep_Tool::Degenerated(aE);
//modified by NIZNHY-PKV Wed Mar 07 07:46:09 2012f
bIsClosed=IsClosed(aE, aF);
//bIsClosed=BRep_Tool::IsClosed(aE, aF);
//modified by NIZNHY-PKV Wed Mar 07 07:46:13 2012t
//
const TopTools_ListOfShape& aLIE=myImages.Image(aE);
aIt.Initialize(aLIE);
for (; aIt.More(); aIt.Next()) {
aSp=TopoDS::Edge(aIt.Value());
//
if (bIsDegenerated) {
aSp.Orientation(anOriE);
aWES.AddStartElement(aSp);
continue;
}
//
if (anOriE==TopAbs_INTERNAL) {
aSp.Orientation(TopAbs_FORWARD);
aWES.AddStartElement(aSp);
aSp.Orientation(TopAbs_REVERSED);
aWES.AddStartElement(aSp);
continue;
}
//
if (bIsClosed){
if (aMFence.Add(aSp)) {
//
if (!BRep_Tool::IsClosed(aSp, aF)){
BOPTools_Tools3D::DoSplitSEAMOnFace(aSp, aF);
}
//
aSp.Orientation(TopAbs_FORWARD);
aWES.AddStartElement(aSp);
aSp.Orientation(TopAbs_REVERSED);
aWES.AddStartElement(aSp);
}
continue;
}// if (aMFence.Add(aSp))
//
aSp.Orientation(anOriE);
bToReverse=BOPTools_Tools3D::IsSplitToReverse1(aSp, aE, aCtx);
if (bToReverse) {
aSp.Reverse();
}
aWES.AddStartElement(aSp);
}// for (; aIt.More(); aIt.Next()) {
}// for (; anExp.More(); anExp.Next()) {
//
// 2.1.2. Add In2D Parts
if (myInParts.Contains(aF)) {
const TopTools_ListOfShape& aLE=myInParts.FindFromKey(aF);
aIt.Initialize(aLE);
for (; aIt.More(); aIt.Next()) {
aSp=TopoDS::Edge(aIt.Value());
//
aSp.Orientation(TopAbs_FORWARD);
aWES.AddStartElement(aSp);
//
aSp.Orientation(TopAbs_REVERSED);
aWES.AddStartElement(aSp);
}
}
//
// 2.2. Build images Faces
TopTools_ListOfShape aLFR;
GEOMAlgo_ShapeSet aS1, aS2;
//
const TopTools_ListOfShape& aSE=aWES.StartElements();
aS1.Add(aSE);
aS2.Add(aFF, TopAbs_EDGE);
if (aS1.IsEqual(aS2)) {
aLFR.Append(aF);
}
else {
GEOMAlgo_BuilderFace aBF;
//
aBF.SetFace(aFF);
aBF.SetContext(aCtx);
aBF.SetShapes(aSE);
// <-DEB
aBF.Perform();
//
const TopTools_ListOfShape& aLF=aBF.Areas();
aIt.Initialize(aLF);
for (; aIt.More(); aIt.Next()) {
TopoDS_Shape& aFR=aIt.Value();
if (anOriF==TopAbs_REVERSED) {
aFR.Orientation(TopAbs_REVERSED);
}
aLFR.Append(aFR);
}
}
//
// 2.3. Collect draft images Faces
mySplitFaces.Bind(aF, aLFR);
}//for (i=1; i<=aNbF; ++i)
}
//
//=======================================================================
// function: PerformEF
// purpose:
//=======================================================================
void NMTTools_PaveFiller::PerformEF()
{
Standard_Boolean bJustAdd;
Standard_Integer n1, n2, anIndexIn, nE, nF, aNbEFs, aBlockLength;
Standard_Integer aDiscretize;
Standard_Real aTolE, aTolF, aDeflection;
BooleanOperations_IndexedDataMapOfShapeInteger aMapVI;
BOPTools_IDMapOfPaveBlockIMapOfInteger aMapCB;
BOPTools_IMapOfPaveBlock aIMPBx;
//
myIsDone=Standard_False;
aDeflection=0.01;
aDiscretize=35;
//
BOPTools_CArray1OfESInterference& aEFs=myIP->ESInterferences();
//
myDSIt->Initialize(TopAbs_EDGE, TopAbs_FACE);
//
// BlockLength correction
aNbEFs=myDSIt->BlockLength();
aBlockLength=aEFs.BlockLength();
if (aNbEFs > aBlockLength) {
aEFs.SetBlockLength(aNbEFs);
}
//
for (; myDSIt->More(); myDSIt->Next()) {
myDSIt->Current(n1, n2, bJustAdd);
//
if(bJustAdd) {
continue;
}
//
anIndexIn = 0;
//
nE=n1;
nF=n2;
if (myDS->GetShapeType(n2)==TopAbs_EDGE) {
nE=n2;
nF=n1;
}
//
// all Common Blocks for face nF
NMTTools_ListOfCommonBlock aLCBF;
CommonBlocksFace(nF, aLCBF);
NMTTools_CommonBlockAPI aCBAPIF(aLCBF);
//
// Edge
const TopoDS_Edge aE=TopoDS::Edge(myDS->Shape(nE));
if (BRep_Tool::Degenerated(aE)){
continue;
}
//
// Face
const TopoDS_Face aF=TopoDS::Face(myDS->Shape(nF));
//
TopTools_IndexedMapOfShape aME;
TopExp::MapShapes(aF, TopAbs_EDGE, aME);
if (aME.Contains(aE)) {
continue;
}
//
aTolF=BRep_Tool::Tolerance(aF);
aTolE=BRep_Tool::Tolerance(aE);
const Bnd_Box& aBBF=myDS->GetBoundingBox(nF);
//
// Process each PaveBlock on edge nE
BOPTools_ListOfPaveBlock& aLPB=mySplitShapesPool(myDS->RefEdge(nE));
//
BOPTools_ListIteratorOfListOfPaveBlock anIt(aLPB);
for (; anIt.More(); anIt.Next()) {
BOPTools_PaveBlock& aPB=anIt.Value();
if (aCBAPIF.IsCommonBlock(aPB)) {
continue;
}
//
const IntTools_ShrunkRange& aShrunkRange=aPB.ShrunkRange();
const IntTools_Range& aSR =aShrunkRange.ShrunkRange();
const Bnd_Box& aBBE=aShrunkRange.BndBox();
//
if (aBBF.IsOut (aBBE)) {
continue;
}
//
// EF
IntTools_EdgeFace aEF;
aEF.SetEdge (aE);
aEF.SetFace (aF);
aEF.SetTolE (aTolE);
aEF.SetTolF (aTolF);
aEF.SetDiscretize (aDiscretize);
aEF.SetDeflection (aDeflection);
//
aEF.SetContext((IntTools_PContext)&myContext);
//
IntTools_Range anewSR = aSR;
//
// Correction of the Shrunk Range
BOPTools_Tools::CorrectRange(aE, aF, aSR, anewSR);
aEF.SetRange (anewSR);
//
aEF.Perform();
//
if (aEF.IsDone()) {
Standard_Boolean bCoinsideFlag;
Standard_Integer i, aNbCPrts;
TopAbs_ShapeEnum aType;
//
const IntTools_SequenceOfCommonPrts& aCPrts=aEF.CommonParts();
//
aNbCPrts=aCPrts.Length();
for (i=1; i<=aNbCPrts; ++i) {
anIndexIn=0;
//
const IntTools_CommonPrt& aCPart=aCPrts(i);
aType=aCPart.Type();
//
switch (aType) {
//
case TopAbs_VERTEX: {
Standard_Boolean bIsOnPave1, bIsOnPave2;
Standard_Integer nVF;
Standard_Real aT, aTolToDecide;
TopoDS_Vertex aNewVertex;
//
const IntTools_Range& aR=aCPart.Range1();
//
// New Vertex
VertexParameter(aCPart, aT);
BOPTools_Tools::MakeNewVertex(aE, aT, aF, aNewVertex);
//
//decide to add pave or not
aTolToDecide=5.e-8;
bIsOnPave1=IsOnPave(anewSR.First(), aR, aTolToDecide);
bIsOnPave2=IsOnPave(anewSR.Last() , aR, aTolToDecide);
//
if (!bIsOnPave1 && !bIsOnPave2) {
nVF=CheckFacePaves(aNewVertex, nF);
if (!nVF) {
// really new vertex
// Add Interference to the Pool
BOPTools_ESInterference anInterf (nE, nF, aCPart);
anIndexIn=aEFs.Append(anInterf);
anInterf.SetNewShape(0);
//
aMapVI.Add(aNewVertex, anIndexIn);
aIMPBx.Add(aPB);
//
myIP->Add(nE, nF, Standard_True, NMTDS_TI_EF);
//
}// if (!nVF)
}// if (!bIsOnPave1 && !bIsOnPave2)
//
//modified by NIZNHY-PKV Fri Apr 18 10:55:38 2008f
else {
const BOPTools_Pave& aPave=(bIsOnPave1)? aPB.Pave1() : aPB.Pave2();
nVF=aPave.Index();
const TopoDS_Vertex& aVF=TopoDS::Vertex(myDS->Shape(nVF));
BOPTools_Tools::UpdateVertex (aVF, aNewVertex);
}
//modified by NIZNHY-PKV Fri Apr 18 10:55:40 2008t
//
}// case TopAbs_VERTEX:
break;
//
case TopAbs_EDGE: {
bCoinsideFlag=BOPTools_Tools::IsBlockInOnFace(aPB, aF, myContext);
if (!bCoinsideFlag) {
break;
}
//
// Fill aMapCB
if (aMapCB.Contains(aPB)) {
TColStd_IndexedMapOfInteger& aMapF=aMapCB.ChangeFromKey(aPB);
aMapF.Add(nF);
}
else {
TColStd_IndexedMapOfInteger aMapF;
aMapF.Add(nF);
aMapCB.Add(aPB, aMapF);
}
//
aIMPBx.Add(aPB);
myIP->Add(nE, nF, Standard_True, NMTDS_TI_EF);
}// case TopAbs_EDGE:
break;
default:
break;
} // switch (aType)
} // for (i=1; i<=aNbCPrts; i++)
} //if (aEF.IsDone())
} // for (; anIt.More(); anIt.Next())
}// for (; myDSIt.More(); myDSIt.Next())
//
// Treat New vertices
EFNewVertices(aMapVI);
//
// Add draft Common Blocks of EF type
EFCommonBlocks(aMapCB);
//
// Collect all CB we suspected to split by new vertices
NMTTools_ListOfCommonBlock aLCBx;
{
Standard_Integer i, aNbPBx, nEx;
BOPTools_IMapOfPaveBlock aMx;
//
aNbPBx=aIMPBx.Extent();
for (i=1; i<=aNbPBx; ++i) {
const BOPTools_PaveBlock& aPBx=aIMPBx(i);
nEx=aPBx.OriginalEdge();
NMTTools_ListOfCommonBlock& aLCB=myCommonBlockPool(myDS->RefEdge(nEx));
if (aLCB.Extent()) {
NMTTools_CommonBlockAPI aCBAPIx(aLCB);
if (aCBAPIx.IsCommonBlock(aPBx)) {
NMTTools_CommonBlock& aCBx=aCBAPIx.CommonBlock(aPBx);
const BOPTools_PaveBlock& aPB1=aCBx.PaveBlock1();
if (!aMx.Contains(aPB1)){
aMx.Add(aPB1);
aLCBx.Append(aCBx);
}
}
}
}
}
//
// Split the common blocks above
if (aLCBx.Extent()) {
ReplaceCommonBlocks(aLCBx);
}
//
myIsDone=Standard_True;
}