[occt.git] / src / BOPAlgo / BOPAlgo_Builder_2.cxx

// Created by: Peter KURNEV
// Copyright (c) 2010-2012 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.
//
// 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.
//
// 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.

#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 <BOPCol_DataMapOfIntegerListOfShape.hxx>
#include <BOPCol_DataMapOfShapeShape.hxx>

#include <BOPInt_Context.hxx>

#include <BOPDS_PaveBlock.hxx>
#include <BOPDS_ShapeInfo.hxx>
#include <BOPDS_DS.hxx>
#include <BOPDS_FaceInfo.hxx>
#include <BOPDS_MapOfPaveBlock.hxx>
#include <BOPDS_VectorOfInterfFF.hxx>
#include <BOPDS_Interf.hxx>
#include <BOPDS_VectorOfCurve.hxx>
#include <BOPDS_VectorOfPoint.hxx>

#include <BOPTools.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_AlgoTools3D.hxx>
#include <BOPAlgo_BuilderFace.hxx>
#include <BOPTools_CoupleOfShape.hxx>
#include <BOPTools_ListOfCoupleOfShape.hxx>
#include <BOPTools_MapOfSet.hxx>
#include <BOPTools_DataMapOfShapeSet.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_IncAllocator)& aAllocator);
static
  void MakeBlocksCnx(const BOPCol_IndexedDataMapOfShapeListOfShape& aMILI,
                     BOPCol_DataMapOfIntegerListOfShape& aMBlocks,
                     Handle(NCollection_IncAllocator)& aAllocator);

//=======================================================================
//function : FillImagesFaces
//purpose  : 
//=======================================================================
  void BOPAlgo_Builder::FillImagesFaces()
{
  myErrorStatus=0;
  //
  BuildSplitFaces();
  FillSameDomainFaces();
  FillImagesFaces1();
}
//=======================================================================
//function : BuildSplitFaces
//purpose  : 
//=======================================================================
  void BOPAlgo_Builder::BuildSplitFaces()
{
  Standard_Boolean bHasFaceInfo, bIsClosed, bIsDegenerated, bToReverse;
  Standard_Integer i, j, aNbS, aNbPBIn, aNbPBOn, aNbPBSc, aNbAV, nSp;
  TopoDS_Face aFF, aFSD;
  TopoDS_Edge aSp, aEE;
  TopAbs_Orientation anOriF, anOriE;
  TopExp_Explorer aExp;
  BOPCol_ListIteratorOfListOfShape aIt;
  BOPCol_ListOfInteger aLIAV;
  BOPCol_MapOfShape aMFence;
  Handle(NCollection_IncAllocator) aAllocator;
  BOPCol_ListOfShape aLFIm(myAllocator);
  BOPCol_MapIteratorOfMapOfShape aItMS;
  //
  myErrorStatus=0;
  //
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~scope f
  aAllocator=new NCollection_IncAllocator();
  //
  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;
    }
    //
    const TopoDS_Face& aF=(*(TopoDS_Face*)(&aSI.Shape()));
    //
    bHasFaceInfo=myDS->HasFaceInfo(i);
    if(!bHasFaceInfo) {
      continue;
    }
    //
    // aLFIm will contain images of aF
    aLFIm.Clear();
    //
    const BOPDS_FaceInfo& aFI=myDS->FaceInfo(i);
    //
    const BOPDS_IndexedMapOfPaveBlock& aMPBIn=aFI.PaveBlocksIn();
    const BOPDS_IndexedMapOfPaveBlock& aMPBOn=aFI.PaveBlocksOn();
    const BOPDS_IndexedMapOfPaveBlock& aMPBSc=aFI.PaveBlocksSc();
    aLIAV.Clear();
    myDS->AloneVertices(i, aLIAV);
    
    aNbPBIn=aMPBIn.Extent();
    aNbPBOn=aMPBOn.Extent();
    aNbPBSc=aMPBSc.Extent();
    aNbAV=aLIAV.Extent();
    if (!aNbPBIn && !aNbPBOn && !aNbPBSc && !aNbAV) { // not compete
      continue;
    }
    //
    aMFence.Clear();
    //
    anOriF=aF.Orientation();
    aFF=aF;
    aFF.Orientation(TopAbs_FORWARD);
    //
    
    //
    // 1. Fill the egdes set for the face aFF -> LE
    aLE.Clear();
    //
    //
    // 1.1 Bounding edges
    aExp.Init(aFF, TopAbs_EDGE);
    for (; aExp.More(); aExp.Next()) {
      const TopoDS_Edge& aE=(*(TopoDS_Edge*)(&aExp.Current()));
      anOriE=aE.Orientation();
      bIsDegenerated=BRep_Tool::Degenerated(aE);
      bIsClosed=BRep_Tool::IsClosed(aE, aF);
      //
      if (!myImages.IsBound(aE)) {
        if (anOriE==TopAbs_INTERNAL) {
          aEE=aE;
          aEE.Orientation(TopAbs_FORWARD);
          aLE.Append(aEE);
          aEE.Orientation(TopAbs_REVERSED);
          aLE.Append(aEE);
        }
        else {
          aLE.Append(aE);
        }
      }
      else {//else 1
        const BOPCol_ListOfShape& aLIE=myImages.Find(aE);
        aIt.Initialize(aLIE);
        for (; aIt.More(); aIt.Next()) {
          aSp=(*(TopoDS_Edge*)(&aIt.Value()));
          if (bIsDegenerated) {
            aSp.Orientation(anOriE);
            aLE.Append(aSp);
            continue;
          }
          //
          if (anOriE==TopAbs_INTERNAL) {
            aSp.Orientation(TopAbs_FORWARD);
            aLE.Append(aSp);
            aSp.Orientation(TopAbs_REVERSED);
            aLE.Append(aSp);
            continue;
          }
          //
          if (bIsClosed) {
            if (aMFence.Add(aSp)) {
              if (!BRep_Tool::IsClosed(aSp, aF)){
                BOPTools_AlgoTools3D::DoSplitSEAMOnFace(aSp, aF);
                }
              //
              aSp.Orientation(TopAbs_FORWARD);
              aLE.Append(aSp);
              aSp.Orientation(TopAbs_REVERSED);
              aLE.Append(aSp);
            }// if (aMFence.Add(aSp))
            continue;
          }// if (bIsClosed){
          //
          aSp.Orientation(anOriE);
          bToReverse=BOPTools_AlgoTools::IsSplitToReverse(aSp, aE, myContext);
          if (bToReverse) {
            aSp.Reverse();
          }
          aLE.Append(aSp);
        }// for (; aIt.More(); aIt.Next()) {
      }// else 1
    }// for (; aExp.More(); aExp.Next()) {
    // 
    //
    // 1.2 In edges
    for (j=1; j<=aNbPBIn; ++j) {
      const Handle(BOPDS_PaveBlock)& aPB=aMPBIn(j);
      nSp=aPB->Edge();
      aSp=(*(TopoDS_Edge*)(&myDS->Shape(nSp)));
      //
      aSp.Orientation(TopAbs_FORWARD);
      aLE.Append(aSp);
      aSp.Orientation(TopAbs_REVERSED);
      aLE.Append(aSp);
    }
    //
    //
    // 1.3 Section edges
    for (j=1; j<=aNbPBSc; ++j) {
      const Handle(BOPDS_PaveBlock)& aPB=aMPBSc(j);
      nSp=aPB->Edge();
      aSp=(*(TopoDS_Edge*)(&myDS->Shape(nSp)));
      //
      aSp.Orientation(TopAbs_FORWARD);
      aLE.Append(aSp);
      aSp.Orientation(TopAbs_REVERSED);
      aLE.Append(aSp);
    }
    //
    // 3 Build split faces
    BOPAlgo_BuilderFace aBF(aAllocator);
    //
    aBF.SetFace(aFF);
    //aBF.SetContext(myContext);
    //
    // <-DEB ft
    //
    aBF.SetShapes(aLE);
    //
    aBF.Perform();
    //
    const BOPCol_ListOfShape& aLFR=aBF.Areas();
    aIt.Initialize(aLFR);
    for (; aIt.More(); aIt.Next()) {
      TopoDS_Shape& aFR=aIt.ChangeValue();
      if (anOriF==TopAbs_REVERSED) {
        aFR.Orientation(TopAbs_REVERSED);
      }
      //aFR.Orientation(anOriF);
      aLFIm.Append(aFR);
    }
    //
    mySplits.Bind(aF, aLFIm); 
  }// for (i=0; i<aNbS; ++i) {
  //
  aAllocator.Nullify();
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~scope t
}
//=======================================================================
//function : FillSameDomainFaces
//purpose  : 
//=======================================================================
  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;
  //
  myErrorStatus=0;
  //
  const BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
  //
  aNbFFs=aFFs.Extent();
  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);
    aFF.Indices(nF1, nF2);
    //
    const BOPDS_VectorOfCurve& aCurves=aFF.Curves();
    aNbCurves=aCurves.Extent();
    if (aNbCurves) {
      //
      bFlag=Standard_False;
      for (j=0; j<aNbCurves; ++j) {
        const BOPDS_Curve& aNC=aCurves.Value(j);
        bFlag=aNC.HasEdge();
        if (bFlag) {
          break;
        }
      }
      if (bFlag) {
        continue;
      }
      //continue;
    }
    //
    const BOPDS_VectorOfPoint& aPoints=aFF.Points();
    aNbPoints=aPoints.Extent();
    if (aNbPoints) {
      continue;
    }
    //
    if (!myDS->HasFaceInfo(nF1) || !myDS->HasFaceInfo(nF2) ) {
      continue;
    }
    //
    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)));
    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 (!aMSST.IsBound(aF2)) {
        BOPTools_Set aST2(aAllocator);
        aMSST.Bind(aF2, aST2);
        BOPTools_Set& aST=aMSST.ChangeFind(aF2);
        aST.AddEdges(aF2);
      }
      //
      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);
          //
          aMSST.Bind(aF2y, aST2);
          BOPTools_Set& aST=aMSST.ChangeFind(aF2y);
          aST.AddEdges(aF2y);
        }
        //
        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);
          }
        }
      }
    }  
  } // for (i=0; i<aNbFFs; ++i) {
  //
  // 2. Make blocks
  MakeBlocksCnx(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.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);
      }
    }
  }
  //
  aItMF.Initialize(aMF);
  for (; aItMF.More(); aItMF.Next()){
    const TopoDS_Shape& aF = aItMF.Value();
    //
    BOPCol_ListOfShape aLS;
    aLS.Append(aF);
    mySplits.Bind(aF, aLS);
  }
  //-----------------------------------------------------scope t
  aMSST.Clear();
  aMBlocks.Clear();
  aDMSLS.Clear();
  aAllocator.Nullify();
}
//=======================================================================
// function: FillImagesFaces1
// purpose: 
//=======================================================================
  void BOPAlgo_Builder::FillImagesFaces1()
{
  Standard_Integer i, aNbS, iSense;
  TopoDS_Face aFSD;
  BOPCol_ListOfInteger aLIAV;
  BOPCol_ListOfShape aLFIm;
  BOPCol_ListIteratorOfListOfShape aItLS;
  //
  aNbS=myDS->NbSourceShapes();
  for (i=0; i<aNbS; ++i) {
    const BOPDS_ShapeInfo& aSI=myDS->ShapeInfo(i);
    if (aSI.ShapeType()!=TopAbs_FACE) {
      continue;
    }
    //
    const TopoDS_Face& aF=(*(TopoDS_Face*)(&aSI.Shape()));
    //
    if (!mySplits.IsBound(aF)) {
      continue;
    }
    //
    aLIAV.Clear();
    myDS->AloneVertices(i, aLIAV);
    aLFIm.Clear();
    //
    const BOPCol_ListOfShape& aLSp=mySplits.Find(aF);
    aItLS.Initialize(aLSp);
    for (; aItLS.More(); aItLS.Next()) {
      const TopoDS_Face& aFSp=(*(TopoDS_Face*)(&aItLS.Value()));
      if (!myShapesSD.IsBound(aFSp)) {
        aLFIm.Append(aFSp);
      }
      else {
        aFSD=(*(TopoDS_Face*)(&myShapesSD.Find(aFSp)));
        iSense=BOPTools_AlgoTools::Sense(aFSp, aFSD);
        if (iSense<0) {
          aFSD.Reverse();
        }
        aLFIm.Append(aFSD);
      }
    }
    //
    FillInternalVertices(aLFIm, aLIAV);
    //
    myImages.Bind(aF, aLFIm); 
    //
    //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;
      }
    }
  }
}
//=======================================================================
//function : MakeBlocksCnx
//purpose  : 
//=======================================================================
void MakeBlocksCnx(const BOPCol_IndexedDataMapOfShapeListOfShape& aMILI,
                   BOPCol_DataMapOfIntegerListOfShape& aMBlocks,
                   Handle(NCollection_IncAllocator)& 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);
    while(1) {
      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_IncAllocator)& 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  : 
//=======================================================================
Standard_Boolean HasPaveBlocksOnIn(const BOPDS_FaceInfo& aFI1,
                                   const BOPDS_FaceInfo& aFI2)
{
  Standard_Boolean bRet;
  BOPDS_MapIteratorOfMapOfPaveBlock aItMPB;
  //
  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);
    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);
    if (bRet) {
      return bRet;
    }
  }
  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
*/
Commit	Line	Data
4e57c75e	1	// Created by: Peter KURNEV
	2	// Copyright (c) 2010-2012 OPEN CASCADE SAS
	3	// Copyright (c) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
	4	// Copyright (c) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, CEDRAT,
	5	// EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
	6	//
	7	// The content of this file is subject to the Open CASCADE Technology Public
	8	// License Version 6.5 (the "License"). You may not use the content of this file
	9	// except in compliance with the License. Please obtain a copy of the License
	10	// at http://www.opencascade.org and read it completely before using this file.
	11	//
	12	// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
	13	// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
	14	//
	15	// The Original Code and all software distributed under the License is
	16	// distributed on an "AS IS" basis, without warranty of any kind, and the
	17	// Initial Developer hereby disclaims all such warranties, including without
	18	// limitation, any warranties of merchantability, fitness for a particular
	19	// purpose or non-infringement. Please see the License for the specific terms
	20	// and conditions governing the rights and limitations under the License.
	21
	22	#include <BOPAlgo_Builder.ixx>
	23
	24	#include <NCollection_IncAllocator.hxx>
	25
	26	#include <TopoDS_Shape.hxx>
	27	#include <TopoDS_Face.hxx>
	28	#include <TopoDS_Edge.hxx>
	29	#include <TopoDS_Vertex.hxx>
	30	#include <TopoDS_Compound.hxx>
	31
	32	#include <BRep_Tool.hxx>
	33	#include <BRep_Builder.hxx>
	34
	35	#include <TopExp_Explorer.hxx>
	36
	37	#include <BOPCol_ListOfShape.hxx>
	38	#include <BOPCol_ListOfInteger.hxx>
	39	#include <BOPCol_MapOfInteger.hxx>
	40	#include <BOPCol_DataMapOfIntegerListOfShape.hxx>
	41	#include <BOPCol_DataMapOfShapeShape.hxx>
	42
	43	#include <BOPInt_Context.hxx>
	44
	45	#include <BOPDS_PaveBlock.hxx>
	46	#include <BOPDS_ShapeInfo.hxx>
	47	#include <BOPDS_DS.hxx>
	48	#include <BOPDS_FaceInfo.hxx>
	49	#include <BOPDS_MapOfPaveBlock.hxx>
	50	#include <BOPDS_VectorOfInterfFF.hxx>
	51	#include <BOPDS_Interf.hxx>
	52	#include <BOPDS_VectorOfCurve.hxx>
	53	#include <BOPDS_VectorOfPoint.hxx>
	54
	55	#include <BOPTools.hxx>
	56	#include <BOPTools_AlgoTools.hxx>
	57	#include <BOPTools_AlgoTools3D.hxx>
	58	#include <BOPAlgo_BuilderFace.hxx>
	59	#include <BOPTools_CoupleOfShape.hxx>
	60	#include <BOPTools_ListOfCoupleOfShape.hxx>
	61	#include <BOPTools_MapOfSet.hxx>
	62	#include <BOPTools_DataMapOfShapeSet.hxx>
	63
	64	static
65	Standard_Boolean HasPaveBlocksOnIn(const BOPDS_FaceInfo& aFI1,
66	const BOPDS_FaceInfo& aFI2);
67	static
68	void FillMap(const TopoDS_Shape& aS1,
69	const TopoDS_Shape& aS2,
70	BOPCol_IndexedDataMapOfShapeListOfShape& aDMSLS,
71	Handle(NCollection_IncAllocator)& aAllocator);
72	static
73	void MakeBlocksCnx(const BOPCol_IndexedDataMapOfShapeListOfShape& aMILI,
74	BOPCol_DataMapOfIntegerListOfShape& aMBlocks,
75	Handle(NCollection_IncAllocator)& aAllocator);
76
77	//=======================================================================
78	//function : FillImagesFaces
79	//purpose :
80	//=======================================================================
81	void BOPAlgo_Builder::FillImagesFaces()
82	{
83	myErrorStatus=0;
84	//
85	BuildSplitFaces();
86	FillSameDomainFaces();
87	FillImagesFaces1();
88	}
89	//=======================================================================
90	//function : BuildSplitFaces
91	//purpose :
92	//=======================================================================
93	void BOPAlgo_Builder::BuildSplitFaces()
94	{
95	Standard_Boolean bHasFaceInfo, bIsClosed, bIsDegenerated, bToReverse;
96	Standard_Integer i, j, aNbS, aNbPBIn, aNbPBOn, aNbPBSc, aNbAV, nSp;
97	TopoDS_Face aFF, aFSD;
98	TopoDS_Edge aSp, aEE;
99	TopAbs_Orientation anOriF, anOriE;
100	TopExp_Explorer aExp;
101	BOPCol_ListIteratorOfListOfShape aIt;
102	BOPCol_ListOfInteger aLIAV;
103	BOPCol_MapOfShape aMFence;
104	Handle(NCollection_IncAllocator) aAllocator;
105	BOPCol_ListOfShape aLFIm(myAllocator);
106	BOPCol_MapIteratorOfMapOfShape aItMS;
107	//
108	myErrorStatus=0;
109	//
110	//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~scope f
111	aAllocator=new NCollection_IncAllocator();
112	//
113	BOPCol_ListOfShape aLE(aAllocator);
114	BOPCol_MapOfShape aMDE(100, aAllocator);
115	//
116	aNbS=myDS->NbSourceShapes();
117	for (i=0; i<aNbS; ++i) {
118	const BOPDS_ShapeInfo& aSI=myDS->ShapeInfo(i);
119	if (aSI.ShapeType()!=TopAbs_FACE) {
120	continue;
121	}
122	//
123	const TopoDS_Face& aF=((TopoDS_Face)(&aSI.Shape()));
124	//
125	bHasFaceInfo=myDS->HasFaceInfo(i);
126	if(!bHasFaceInfo) {
127	continue;
128	}
129	//
130	// aLFIm will contain images of aF
131	aLFIm.Clear();
132	//
133	const BOPDS_FaceInfo& aFI=myDS->FaceInfo(i);
134	//
135	const BOPDS_IndexedMapOfPaveBlock& aMPBIn=aFI.PaveBlocksIn();
136	const BOPDS_IndexedMapOfPaveBlock& aMPBOn=aFI.PaveBlocksOn();
137	const BOPDS_IndexedMapOfPaveBlock& aMPBSc=aFI.PaveBlocksSc();
138	aLIAV.Clear();
139	myDS->AloneVertices(i, aLIAV);
140
141	aNbPBIn=aMPBIn.Extent();
142	aNbPBOn=aMPBOn.Extent();
143	aNbPBSc=aMPBSc.Extent();
144	aNbAV=aLIAV.Extent();
145	if (!aNbPBIn && !aNbPBOn && !aNbPBSc && !aNbAV) { // not compete
146	continue;
147	}
148	//
149	aMFence.Clear();
150	//
151	anOriF=aF.Orientation();
152	aFF=aF;
153	aFF.Orientation(TopAbs_FORWARD);
154	//
155
156	//
157	// 1. Fill the egdes set for the face aFF -> LE
158	aLE.Clear();
159	//
160	//
161	// 1.1 Bounding edges
162	aExp.Init(aFF, TopAbs_EDGE);
163	for (; aExp.More(); aExp.Next()) {
164	const TopoDS_Edge& aE=((TopoDS_Edge)(&aExp.Current()));
165	anOriE=aE.Orientation();
166	bIsDegenerated=BRep_Tool::Degenerated(aE);
167	bIsClosed=BRep_Tool::IsClosed(aE, aF);
168	//
169	if (!myImages.IsBound(aE)) {
170	if (anOriE==TopAbs_INTERNAL) {
171	aEE=aE;
172	aEE.Orientation(TopAbs_FORWARD);
173	aLE.Append(aEE);
174	aEE.Orientation(TopAbs_REVERSED);
175	aLE.Append(aEE);
176	}
177	else {
178	aLE.Append(aE);
179	}
180	}
181	else {//else 1
182	const BOPCol_ListOfShape& aLIE=myImages.Find(aE);
183	aIt.Initialize(aLIE);
184	for (; aIt.More(); aIt.Next()) {
185	aSp=((TopoDS_Edge)(&aIt.Value()));
186	if (bIsDegenerated) {
187	aSp.Orientation(anOriE);
188	aLE.Append(aSp);
189	continue;
190	}
191	//
192	if (anOriE==TopAbs_INTERNAL) {
193	aSp.Orientation(TopAbs_FORWARD);
194	aLE.Append(aSp);
195	aSp.Orientation(TopAbs_REVERSED);
196	aLE.Append(aSp);
197	continue;
198	}
199	//
200	if (bIsClosed) {
201	if (aMFence.Add(aSp)) {
202	if (!BRep_Tool::IsClosed(aSp, aF)){
203	BOPTools_AlgoTools3D::DoSplitSEAMOnFace(aSp, aF);
204	}
205	//
206	aSp.Orientation(TopAbs_FORWARD);
207	aLE.Append(aSp);
208	aSp.Orientation(TopAbs_REVERSED);
209	aLE.Append(aSp);
210	}// if (aMFence.Add(aSp))
211	continue;
212	}// if (bIsClosed){
213	//
214	aSp.Orientation(anOriE);
215	bToReverse=BOPTools_AlgoTools::IsSplitToReverse(aSp, aE, myContext);
216	if (bToReverse) {
217	aSp.Reverse();
218	}
219	aLE.Append(aSp);
220	}// for (; aIt.More(); aIt.Next()) {
221	}// else 1
222	}// for (; aExp.More(); aExp.Next()) {
223	//
224	//
225	// 1.2 In edges
226	for (j=1; j<=aNbPBIn; ++j) {
227	const Handle(BOPDS_PaveBlock)& aPB=aMPBIn(j);
228	nSp=aPB->Edge();
229	aSp=((TopoDS_Edge)(&myDS->Shape(nSp)));
230	//
231	aSp.Orientation(TopAbs_FORWARD);
232	aLE.Append(aSp);
233	aSp.Orientation(TopAbs_REVERSED);
234	aLE.Append(aSp);
235	}
236	//
237	//
238	// 1.3 Section edges
239	for (j=1; j<=aNbPBSc; ++j) {
240	const Handle(BOPDS_PaveBlock)& aPB=aMPBSc(j);
241	nSp=aPB->Edge();
242	aSp=((TopoDS_Edge)(&myDS->Shape(nSp)));
243	//
244	aSp.Orientation(TopAbs_FORWARD);
245	aLE.Append(aSp);
246	aSp.Orientation(TopAbs_REVERSED);
247	aLE.Append(aSp);
248	}
249	//
250	// 3 Build split faces
251	BOPAlgo_BuilderFace aBF(aAllocator);
252	//
253	aBF.SetFace(aFF);
254	//aBF.SetContext(myContext);
255	//
256	// <-DEB ft
257	//
258	aBF.SetShapes(aLE);
259	//
260	aBF.Perform();
261	//
262	const BOPCol_ListOfShape& aLFR=aBF.Areas();
263	aIt.Initialize(aLFR);
264	for (; aIt.More(); aIt.Next()) {
265	TopoDS_Shape& aFR=aIt.ChangeValue();
266	if (anOriF==TopAbs_REVERSED) {
267	aFR.Orientation(TopAbs_REVERSED);
268	}
269	//aFR.Orientation(anOriF);
270	aLFIm.Append(aFR);
4e57c75e	271	}
	272	//
	273	mySplits.Bind(aF, aLFIm);
	274	}// for (i=0; i<aNbS; ++i) {
	275	//
	276	aAllocator.Nullify();
	277	//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~scope t
	278	}
	279	//=======================================================================
	280	//function : FillSameDomainFaces
	281	//purpose :
	282	//=======================================================================
	283	void BOPAlgo_Builder::FillSameDomainFaces()
	284	{
	285	Standard_Boolean bFlag;
	286	Standard_Integer i, aNbFFs, aNbCurves, aNbPoints, nF1, nF2, aNbS;
	287	Standard_Integer j;
	288	Handle(NCollection_IncAllocator) aAllocator;
	289	BOPCol_ListIteratorOfListOfShape aItF1, aItF2;
	290	BOPTools_ListOfCoupleOfShape aLCS;
	291	BOPCol_ListIteratorOfListOfShape aItLS;
c209782c	292	BOPCol_MapOfShape aMF;
c209782c	293	BOPCol_MapIteratorOfMapOfShape aItMF;
4e57c75e	294	//
	295	myErrorStatus=0;
	296	//
	297	const BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
	298	//
	299	aNbFFs=aFFs.Extent();
	300	if (!aNbFFs) {
	301	return;
	302	}
	303	//-----------------------------------------------------scope f
	304	aAllocator=new NCollection_IncAllocator();
	305	BOPCol_IndexedDataMapOfShapeListOfShape aDMSLS(100, aAllocator);
	306	BOPCol_DataMapOfIntegerListOfShape aMBlocks(100, aAllocator);
	307	BOPTools_DataMapOfShapeSet aMSST(100, aAllocator);
	308	//
	309	BOPCol_ListOfShape aLFIm;
	310	//
	311	for (i=0; i<aNbFFs; ++i) {
	312	const BOPDS_InterfFF& aFF=aFFs(i);
	313	aFF.Indices(nF1, nF2);
	314	//
	315	const BOPDS_VectorOfCurve& aCurves=aFF.Curves();
	316	aNbCurves=aCurves.Extent();
	317	if (aNbCurves) {
	318	//
	319	bFlag=Standard_False;
	320	for (j=0; j<aNbCurves; ++j) {
	321	const BOPDS_Curve& aNC=aCurves.Value(j);
	322	bFlag=aNC.HasEdge();
	323	if (bFlag) {
	324	break;
	325	}
	326	}
	327	if (bFlag) {
	328	continue;
	329	}
	330	//continue;
	331	}
	332	//
	333	const BOPDS_VectorOfPoint& aPoints=aFF.Points();
	334	aNbPoints=aPoints.Extent();
	335	if (aNbPoints) {
	336	continue;
	337	}
	338	//
	339	if (!myDS->HasFaceInfo(nF1) \|\| !myDS->HasFaceInfo(nF2) ) {
	340	continue;
	341	}
	342	//
	343	const BOPDS_FaceInfo& aFI1=myDS->FaceInfo(nF1);
	344	const BOPDS_FaceInfo& aFI2=myDS->FaceInfo(nF2);
	345	bFlag=HasPaveBlocksOnIn(aFI1, aFI2);
4e57c75e	346	//
	347	const TopoDS_Face& aF1=((TopoDS_Face)(&myDS->Shape(nF1)));
	348	const TopoDS_Face& aF2=((TopoDS_Face)(&myDS->Shape(nF2)));
c209782c	349	bFlag=bFlag && (mySplits.IsBound(aF1) && mySplits.IsBound(aF2));
c209782c	350	//
4e57c75e	351	if (!bFlag) {
c209782c	352	//case when the faces have shared bounds
	353	if (!aMSST.IsBound(aF1)) {
	354	BOPTools_Set aST1(aAllocator);
	355	aMSST.Bind(aF1, aST1);
	356	BOPTools_Set& aST=aMSST.ChangeFind(aF1);
	357	aST.AddEdges(aF1);
	358	}
	359	//
	360	if (!aMSST.IsBound(aF2)) {
	361	BOPTools_Set aST2(aAllocator);
	362	aMSST.Bind(aF2, aST2);
	363	BOPTools_Set& aST=aMSST.ChangeFind(aF2);
	364	aST.AddEdges(aF2);
	365	}
	366	//
	367	const BOPTools_Set& aST1=aMSST.Find(aF1);
	368	const BOPTools_Set& aST2=aMSST.Find(aF2);
	369	if (aST1.IsEqual(aST2)) {
	370	bFlag=BOPTools_AlgoTools::AreFacesSameDomain(aF1, aF2, myContext);
	371	if (bFlag) {
	372	FillMap(aF1, aF2, aDMSLS, aAllocator);
	373	aMF.Add(aF1);
	374	aMF.Add(aF2);
	375	}
	376	}
4e57c75e	377	continue;
	378	}
	379	//
	380	const BOPCol_ListOfShape& aLF1=mySplits.Find(aF1);
	381	const BOPCol_ListOfShape& aLF2=mySplits.Find(aF2);
	382	//
	383	aItF1.Initialize(aLF1);
	384	for (; aItF1.More(); aItF1.Next()) {
	385	const TopoDS_Face& aF1x=((TopoDS_Face)(&aItF1.Value()));
	386	if (!aMSST.IsBound(aF1x)) {
	387	BOPTools_Set aST1(aAllocator);
	388	//
	389	aMSST.Bind(aF1x, aST1);
	390	BOPTools_Set& aST=aMSST.ChangeFind(aF1x);
	391	aST.AddEdges(aF1x);
	392	}
	393	//
	394	aItF2.Initialize(aLF2);
	395	for (; aItF2.More(); aItF2.Next()) {
	396	const TopoDS_Face& aF2y=((TopoDS_Face)(&aItF2.Value()));
	397	if (!aMSST.IsBound(aF2y)) {
	398	BOPTools_Set aST2(aAllocator);
	399	//
	400	aMSST.Bind(aF2y, aST2);
	401	BOPTools_Set& aST=aMSST.ChangeFind(aF2y);
	402	aST.AddEdges(aF2y);
	403	}
	404	//
	405	const BOPTools_Set& aST1=aMSST.Find(aF1x);
	406	const BOPTools_Set& aST2=aMSST.Find(aF2y);
	407	//
	408	if (aST1.IsEqual(aST2)) {
	409	bFlag=BOPTools_AlgoTools::AreFacesSameDomain(aF1x, aF2y, myContext);
	410	if (bFlag) {
	411	FillMap(aF1x, aF2y, aDMSLS, aAllocator);
	412	}
	413	}
	414	}
	415	}
	416	} // for (i=0; i<aNbFFs; ++i) {
	417	//
	418	// 2. Make blocks
	419	MakeBlocksCnx(aDMSLS, aMBlocks, aAllocator);
	420	//
	421	// 3. Fill same domain faces map -> aMSDF
	422	aNbS = aMBlocks.Extent();
	423	for (i=0; i<aNbS; ++i) {
	424	const BOPCol_ListOfShape& aLSD=aMBlocks.Find(i);
	425	if (aLSD.Extent()) {
	426	const TopoDS_Shape& aFSD1=aLSD.First();
	427	aItLS.Initialize(aLSD);
	428	for (; aItLS.More(); aItLS.Next()) {
	429	const TopoDS_Shape& aFSD=aItLS.Value();
	430	myShapesSD.Bind(aFSD, aFSD1);
	431	}
	432	}
	433	}
	434	//
c209782c	435	aItMF.Initialize(aMF);
	436	for (; aItMF.More(); aItMF.Next()){
	437	const TopoDS_Shape& aF = aItMF.Value();
	438	//
	439	BOPCol_ListOfShape aLS;
	440	aLS.Append(aF);
	441	mySplits.Bind(aF, aLS);
	442	}
4e57c75e	443	//-----------------------------------------------------scope t
	444	aMSST.Clear();
	445	aMBlocks.Clear();
	446	aDMSLS.Clear();
	447	aAllocator.Nullify();
	448	}
	449	//=======================================================================
	450	// function: FillImagesFaces1
	451	// purpose:
	452	//=======================================================================
	453	void BOPAlgo_Builder::FillImagesFaces1()
	454	{
	455	Standard_Integer i, aNbS, iSense;
	456	TopoDS_Face aFSD;
	457	BOPCol_ListOfInteger aLIAV;
	458	BOPCol_ListOfShape aLFIm;
	459	BOPCol_ListIteratorOfListOfShape aItLS;
	460	//
	461	aNbS=myDS->NbSourceShapes();
	462	for (i=0; i<aNbS; ++i) {
	463	const BOPDS_ShapeInfo& aSI=myDS->ShapeInfo(i);
	464	if (aSI.ShapeType()!=TopAbs_FACE) {
	465	continue;
	466	}
	467	//
	468	const TopoDS_Face& aF=((TopoDS_Face)(&aSI.Shape()));
	469	//
	470	if (!mySplits.IsBound(aF)) {
	471	continue;
	472	}
	473	//
	474	aLIAV.Clear();
	475	myDS->AloneVertices(i, aLIAV);
	476	aLFIm.Clear();
	477	//
	478	const BOPCol_ListOfShape& aLSp=mySplits.Find(aF);
	479	aItLS.Initialize(aLSp);
	480	for (; aItLS.More(); aItLS.Next()) {
	481	const TopoDS_Face& aFSp=((TopoDS_Face)(&aItLS.Value()));
	482	if (!myShapesSD.IsBound(aFSp)) {
	483	aLFIm.Append(aFSp);
	484	}
	485	else {
	486	aFSD=((TopoDS_Face)(&myShapesSD.Find(aFSp)));
	487	iSense=BOPTools_AlgoTools::Sense(aFSp, aFSD);
	488	if (iSense<0) {
	489	aFSD.Reverse();
	490	}
	491	aLFIm.Append(aFSD);
	492	}
	493	}
	494	//
	495	FillInternalVertices(aLFIm, aLIAV);
	496	//
	497	myImages.Bind(aF, aLFIm);
c209782c	498	//
	499	//fill myOrigins
	500	aItLS.Initialize(aLFIm);
	501	for (; aItLS.More(); aItLS.Next()) {
	502	const TopoDS_Face& aFSp=((TopoDS_Face)(&aItLS.Value()));
	503	myOrigins.Bind(aFSp, aF);
	504	}
4e57c75e	505	}// for (i=0; i<aNbS; ++i) {
	506	}
	507	//=======================================================================
	508	// function: FillInternalVertices
	509	// purpose:
	510	//=======================================================================
	511	void BOPAlgo_Builder::FillInternalVertices(BOPCol_ListOfShape& aLFIm,
	512	BOPCol_ListOfInteger& aLIAV)
	513	{
	514	Standard_Integer nV, iFlag;
	515	Standard_Real aU1, aU2;
	516	TopoDS_Vertex aV;
	517	BRep_Builder aBB;
	518	BOPCol_ListIteratorOfListOfInteger aItV;
	519	BOPCol_ListIteratorOfListOfShape aItF;
	520	//
	521	aItV.Initialize(aLIAV);
	522	for (; aItV.More(); aItV.Next()) {
	523	nV=aItV.Value();
	524	aV=((TopoDS_Vertex)(&myDS->Shape(nV)));
	525	aV.Orientation(TopAbs_INTERNAL);
	526	//
	527	aItF.Initialize(aLFIm);
	528	for (; aItF.More(); aItF.Next()) {
	529	TopoDS_Face& aF=((TopoDS_Face)(&aItF.Value()));
	530	iFlag=myContext->ComputeVF(aV, aF, aU1, aU2);
	531	if (!iFlag) {
	532	aBB.Add(aF, aV);
	533	break;
	534	}
	535	}
	536	}
	537	}
	538	//=======================================================================
	539	//function : MakeBlocksCnx
	540	//purpose :
	541	//=======================================================================
	542	void MakeBlocksCnx(const BOPCol_IndexedDataMapOfShapeListOfShape& aMILI,
	543	BOPCol_DataMapOfIntegerListOfShape& aMBlocks,
	544	Handle(NCollection_IncAllocator)& aAllocator)
	545	{
	546	Standard_Integer aNbV, aNbVS, aNbVP, aNbEC, k, i, j;
	547	BOPCol_ListIteratorOfListOfShape aItLI;
	548	//
	549	BOPCol_MapOfShape aMVS(100, aAllocator);
	550	BOPCol_IndexedMapOfShape aMEC(100, aAllocator);
	551	BOPCol_IndexedMapOfShape aMVP(100, aAllocator);
	552	BOPCol_IndexedMapOfShape aMVAdd(100, aAllocator);
	553	//
	554	aNbV=aMILI.Extent();
	555	//
	556	for (k=0,i=1; i<=aNbV; ++i) {
	557	aNbVS=aMVS.Extent();
	558	if (aNbVS==aNbV) {
	559	break;
	560	}
	561	//
	562	const TopoDS_Shape& nV=aMILI.FindKey(i);
	563	if (aMVS.Contains(nV)){
	564	continue;
	565	}
	566	aMVS.Add(nV);
	567	//
	568	aMEC.Clear();
569	aMVP.Clear();
570	aMVAdd.Clear();
571	//
572	aMVP.Add(nV);
573	while(1) {
574	aNbVP=aMVP.Extent();
575	for (j=1; j<=aNbVP; ++j) {
576	const TopoDS_Shape& nVP=aMVP(j);
577	const BOPCol_ListOfShape& aLV=aMILI.FindFromKey(nVP);
578	aItLI.Initialize(aLV);
579	for (; aItLI.More(); aItLI.Next()) {
580	const TopoDS_Shape& nVx=aItLI.Value();
581	if (aMEC.Contains(nVx)) {
582	continue;
583	}
584	//
585	aMVS.Add(nVx);
586	aMEC.Add(nVx);
587	aMVAdd.Add(nVx);
588	}
589	}
590	//
591	aNbVP=aMVAdd.Extent();
592	if (!aNbVP) {
593	break; // from while(1)
594	}
595	//
596	aMVP.Clear();
597	for (j=1; j<=aNbVP; ++j) {
598	aMVP.Add(aMVAdd(j));
599	}
600	aMVAdd.Clear();
601	}//while(1) {
602	//
603	BOPCol_ListOfShape aLIx(aAllocator);
604	//
605	aNbEC = aMEC.Extent();
606	for (j=1; j<=aNbEC; ++j) {
607	const TopoDS_Shape& nVx=aMEC(j);
608	aLIx.Append(nVx);
609	}
610	//
611	aMBlocks.Bind(k, aLIx);
612	++k;
613	}//for (k=0,i=1; i<=aNbV; ++i)
614	aMVAdd.Clear();
615	aMVP.Clear();
616	aMEC.Clear();
617	aMVS.Clear();
618	}
619
620	//=======================================================================
621	//function : FillMap
622	//purpose :
623	//=======================================================================
624	void FillMap(const TopoDS_Shape& aS1,
625	const TopoDS_Shape& aS2,
626	BOPCol_IndexedDataMapOfShapeListOfShape& aDMSLS,
627	Handle(NCollection_IncAllocator)& aAllocator)
628	{
629	if (aDMSLS.Contains(aS1)) {
630	BOPCol_ListOfShape& aLS=aDMSLS.ChangeFromKey(aS1);
631	aLS.Append(aS2);
632	}
633	else {
634	BOPCol_ListOfShape aLS(aAllocator);
635	aLS.Append(aS2);
636	aDMSLS.Add(aS1, aLS);
637	}
638	//
639	if (aDMSLS.Contains(aS2)) {
640	BOPCol_ListOfShape& aLS=aDMSLS.ChangeFromKey(aS2);
641	aLS.Append(aS1);
642	}
643	else {
644	BOPCol_ListOfShape aLS(aAllocator);
645	aLS.Append(aS1);
646	aDMSLS.Add(aS2, aLS);
647	}
648	}
649	//=======================================================================
650	//function :HasPaveBlocksOnIn
651	//purpose :
652	//=======================================================================
653	Standard_Boolean HasPaveBlocksOnIn(const BOPDS_FaceInfo& aFI1,
654	const BOPDS_FaceInfo& aFI2)
655	{
656	Standard_Boolean bRet;
657	BOPDS_MapIteratorOfMapOfPaveBlock aItMPB;
658	//
659	bRet=Standard_False;
660	const BOPDS_IndexedMapOfPaveBlock& aMPBOn1=aFI1.PaveBlocksOn();
661	const BOPDS_IndexedMapOfPaveBlock& aMPBIn1=aFI1.PaveBlocksIn();
662	//
663	const BOPDS_IndexedMapOfPaveBlock& aMPBOn2=aFI2.PaveBlocksOn();
664	aItMPB.Initialize(aMPBOn2);
665	for (; aItMPB.More(); aItMPB.Next()) {
666	const Handle(BOPDS_PaveBlock)& aPB=aItMPB.Value();
667	bRet=aMPBOn1.Contains(aPB) \|\| aMPBIn1.Contains(aPB);
668	if (bRet) {
669	return bRet;
670	}
671	}
672	//
673	const BOPDS_IndexedMapOfPaveBlock& aMPBIn2=aFI2.PaveBlocksIn();
674	aItMPB.Initialize(aMPBIn2);
675	for (; aItMPB.More(); aItMPB.Next()) {
676	const Handle(BOPDS_PaveBlock)& aPB=aItMPB.Value();
677	bRet=aMPBOn1.Contains(aPB) \|\| aMPBIn1.Contains(aPB);
678	if (bRet) {
679	return bRet;
680	}
681	}
682	return bRet;
683	}
684
685	/*
686	//DEBf
687	{
688	TopoDS_Compound aCx;
689	BRep_Builder aBBx;
690	BOPCol_ListIteratorOfListOfShape aItx;
691	//
692	aBBx.MakeCompound(aCx);
693	aBBx.Add(aCx, aFF);
694	aItx.Initialize(aLE);
695	for (; aItx.More(); aItx.Next()) {
696	const TopoDS_Shape& aEx=aItx.Value();
697	aBBx.Add(aCx, aEx);
698	}
699	int a=0;
700	}
701	//DEBt
702	*/