fix for the bug v3.0

diff --git a/src/BOP/BOP_ShellSplitter.cxx b/src/BOP/BOP_ShellSplitter.cxx
index 86c09b7259b6955d9a0f5a8e36ca3e222e947b20..63657f3b74fa50d57e9cbe33683b97c766cecbdd 100755 (executable)
--- a/src/BOP/BOP_ShellSplitter.cxx
+++ b/src/BOP/BOP_ShellSplitter.cxx
@@ -204,7 +204,28 @@ static
   //
   // 3. Post-pro the result aShape
   //    and filling the myShapes field .
-  TopExp_Explorer aShellExp(aShape, TopAbs_SHELL);
+  //modified by NIZNHY-PKV Tue Sep 18 12:06:25 2012f
+  Standard_Integer aNbSh; 
+  TopExp_Explorer aShellExp;
+  //
+  aShellExp.Init(aShape, TopAbs_SHELL);
+  for (aNbSh=0; aShellExp.More(); aShellExp.Next(), ++aNbSh) {
+    const TopoDS_Shape& aSh=aShellExp.Current();
+  }
+  //
+  if (aNbSh==1) {
+    Standard_Boolean bIsClosed;
+    //
+    bIsClosed=BRep_Tool::IsClosed(aShell);
+    if (bIsClosed) {
+      myShapes.Append(myFaces);
+      myIsDone=Standard_True;
+      return;
+    }
+  }
+  //modified by NIZNHY-PKV Tue Sep 18 12:06:26 2012t
+  //
+  aShellExp.Init(aShape, TopAbs_SHELL);
   for (; aShellExp.More(); aShellExp.Next()) {
     const TopoDS_Shape& aSh= aShellExp.Current();
 
@@ -221,7 +242,7 @@ static
       myShapes.Append(aLF);
     }
   }
-  
+  //
   myIsDone=Standard_True;
 }
 

diff --git a/src/BOPTools/BOPTools_PaveFiller.cdl b/src/BOPTools/BOPTools_PaveFiller.cdl
index 8d03afad5afea6357c840066dadde21a46734b9f..25b2cf4167efe28d32c10e7880f22c400f50c204 100755 (executable)
--- a/src/BOPTools/BOPTools_PaveFiller.cdl
+++ b/src/BOPTools/BOPTools_PaveFiller.cdl
@@ -516,7 +516,6 @@ is
        --- Try to put 3D-point <aP> (parameter aT)  on the curve <aBC> 
        --- 
  
---modified by NIZNHY-PKV Thu Oct 20 07:17:11 2011f 
     PutClosingPaveOnCurve (me:out; 
                    aBC :out Curve from BOPTools;        
                    aFF :out SSInterference from BOPTools)  
@@ -525,7 +524,6 @@ is
        --- Put paves on the curve <aBC> in case when <aBC>   
         --  is closed 3D-curve  
        ---      
---modified by NIZNHY-PKV Thu Oct 20 07:17:11 2011t      
 
     FindPave            (me:out; 
                    aP  :Pnt from  gp;  
@@ -596,6 +594,25 @@ is
             aTolExt : out Real from Standard) 
        returns Boolean from Standard                
        is  protected;               
+ 
+    --modified by NIZNHY-PKV Tue Aug 28 09:45:00 2012ft 
+    TreatTechnoVertices(me:out;  
+                   aFF:out SSInterference from BOPTools) 
+       is protected;    
+        
+    SplitPaveBlock(me:out;   
+           aPB: PaveBlock from BOPTools;  
+           nVT: Integer from Standard; 
+           aPB1:out PaveBlock from BOPTools; 
+           aPB2:out PaveBlock from BOPTools) 
+       is protected;   
+ 
+    CheckCoincidence(me:out;   
+           aPB1: PaveBlock from BOPTools;  
+           aPB2: PaveBlock from BOPTools) 
+       returns Boolean from Standard 
+       is protected;   
+    --modified by NIZNHY-PKV Mon Jul 09 13:15:55 2012t
 
 fields 
  

diff --git a/src/BOPTools/BOPTools_PaveFiller_3.cxx b/src/BOPTools/BOPTools_PaveFiller_3.cxx
index e81ba3fbf5d6e0cb9b5c2db4d74612156790541a..09c32d8508b5b4f44e5b9167cf0665f597d120e7 100755 (executable)
--- a/src/BOPTools/BOPTools_PaveFiller_3.cxx
+++ b/src/BOPTools/BOPTools_PaveFiller_3.cxx
@@ -538,6 +538,20 @@ static
        if (aMap.Contains(nV1) && aMap.Contains(nV2)) {
          //
          const BOPTools_ListOfPaveBlock& aLPBExisting=aFFi.PaveBlocks();
+         //
+         //modified by NIZNHY-PKV Tue Sep 18 11:59:35 2012f
+         iCheckIntermediatePoint=1;
+         BOPTools_ListIteratorOfListOfPaveBlock anItLPB(aLPBExisting);
+         for (; anItLPB.More(); anItLPB.Next()) {
+           const BOPTools_PaveBlock& aPBR=anItLPB.Value();
+           iCheckIntermediatePoint=
+             CheckIntermediatePoint(aPBNew, aPBR, aTolR3D);
+           if (!iCheckIntermediatePoint) {
+             break;
+           }
+         }
+         bIsPaveBlock=(iCheckIntermediatePoint==0);
+         /*
          bIsPaveBlock=IsPaveBlock(nV1, nV2, aLPBExisting);
          //
          iCheckIntermediatePoint=1;
@@ -554,6 +568,8 @@ static
            }
            bIsPaveBlock=bIsPaveBlock && !iCheckIntermediatePoint;
          }
+         */
+         //modified by NIZNHY-PKV Tue Sep 18 12:00:02 2012t
          //
          if (bIsPaveBlock) {
            continue;
@@ -1741,6 +1757,9 @@ static
       }
     }
     //wkar OCC334 t
+    //modified by NIZNHY-PKV Tue Sep 18 12:01:23 2012f
+    TreatTechnoVertices(aFFi);
+    //modified by NIZNHY-PKV Tue Sep 18 12:01:28 2012t
   }
 }
 //=======================================================================

diff --git a/src/BOPTools/BOPTools_PaveFiller_5.cxx b/src/BOPTools/BOPTools_PaveFiller_5.cxx
new file mode 100644 (file)
index 0000000..1619c17
--- /dev/null
+++ b/src/BOPTools/BOPTools_PaveFiller_5.cxx
@@ -0,0 +1,323 @@
+// Created on: 2001-03-13
+// Created by: Peter KURNEV
+// Copyright (c) 2001-2012 OPEN CASCADE SAS
+//
+// 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 <BOPTools_PaveFiller.ixx>
+
+#include <TColStd_ListOfInteger.hxx>
+#include <TColStd_ListIteratorOfListOfInteger.hxx>
+#include <TColStd_IndexedMapOfInteger.hxx>
+
+#include <gp_Pnt.hxx>
+#include <Geom_Curve.hxx>
+
+#include <TopoDS_Edge.hxx>
+#include <BRep_Builder.hxx>
+
+#include <BooleanOperations_ShapesDataStructure.hxx>
+
+#include <IntTools_Curve.hxx>
+#include <IntTools_Tools.hxx>
+
+#include <BOPTools_Tools.hxx>
+#include <BOPTools_SequenceOfCurves.hxx>
+#include <BOPTools_Curve.hxx>
+#include <BOPTools_ListOfPaveBlock.hxx>
+#include <BOPTools_ListIteratorOfListOfPaveBlock.hxx>
+#include <BOPTools_Pave.hxx>
+#include <BOPTools_ListOfCommonBlock.hxx>
+#include <BOPTools_ListIteratorOfListOfCommonBlock.hxx>
+#include <BOPTools_CommonBlock.hxx>
+
+//modified by NIZNHY-PKV Tue Aug 28 09:45:19 2012ft
+//=======================================================================
+//function : TreatTechnoVertices
+//purpose  : 
+//=======================================================================
+void BOPTools_PaveFiller::TreatTechnoVertices(BOPTools_SSInterference& aFFi) 
+{
+  Standard_Boolean bFlag, bSplitted;
+  Standard_Integer nF1, nF2, aBid, j, aNbCurves, aNbVT, aNbLPB, nE, nVT, iFlag;
+  Standard_Integer nF, nE1, nE2, k;
+  Standard_Real aT;
+  TColStd_IndexedMapOfInteger aMVT;
+  
+  TColStd_ListIteratorOfListOfInteger aItLI;
+  BOPTools_Pave aPave;
+  BOPTools_ListOfPaveBlock aLPB, aLPBS;
+  BOPTools_ListIteratorOfListOfPaveBlock aItLPB, aItLPB1;
+  //
+  nF1=aFFi.Index1();
+  nF2=aFFi.Index2();
+  BOPTools_SequenceOfCurves& aBCs=aFFi.Curves();
+  //
+  aNbCurves=aBCs.Length();
+  for (j=1; j<=aNbCurves; j++) {
+    BOPTools_Curve& aBC=aBCs(j);
+    //Handle(Geom_Curve) aC3D= aBC.Curve().Curve(); //DEB
+    TColStd_ListOfInteger& aLVT=aBC.TechnoVertices();
+    aItLI.Initialize(aLVT);
+    for (; aItLI.More(); aItLI.Next()) {
+      nVT=aItLI.Value();
+      aMVT.Add(nVT);
+    }
+  }  
+  //
+  aNbVT=aMVT.Extent();
+  if (!aNbVT) {// nothing to do
+    return; 
+  }
+  //------------------------------
+  //
+  aBid=0;
+  SplitsInFace (aBid, nF1, nF2, aLPB);
+  SplitsInFace (aBid, nF2, nF1, aLPB);
+  SplitsOnFace (aBid, nF1, nF2, aLPB);
+  //
+  aNbLPB=aLPB.Extent();
+  if (!aNbLPB) {// nothing to do 
+    return; 
+  }
+  //
+  for (k=1; k<=aNbVT; ++k) {
+    nVT=aMVT(k);
+    const TopoDS_Vertex& aV=*((TopoDS_Vertex*)&(myDS->Shape(nVT)));
+    //
+    // 1.Collect Pave Blocks (pretenders) to split by nVT => aLPBS
+    aLPBS.Clear();
+    aItLPB.Initialize(aLPB);
+    for (; aItLPB.More(); aItLPB.Next()) {
+      const BOPTools_PaveBlock& aPB=aItLPB.Value();
+      nE=aPB.OriginalEdge();
+      const TopoDS_Edge& aE=*((TopoDS_Edge*)&(myDS->Shape(nE)));
+      //
+      iFlag=myContext->ComputeVE(aV, aE, aT);
+      if (iFlag) {
+       continue;
+      }
+      // 
+      aPave.SetIndex(nVT);
+      aPave.SetParam(aT);
+      //
+      BOPTools_ListOfPaveBlock& aLPBE=mySplitShapesPool(myDS->RefEdge(nE)); 
+      aItLPB1.Initialize(aLPBE);
+      for (; aItLPB1.More(); aItLPB1.Next()) {
+       const BOPTools_PaveBlock& aPBE=aItLPB1.Value();
+       if (aPBE.IsInBlock(aPave)) {
+         aLPBS.Append(aPBE);
+       }
+      }
+    }//for (; aItLPB.More(); aItLPB.Next()) {
+    //
+    // 2.Split Pave Blocks [aLPBS] by the vertex [nVT]
+    BOPTools_ListIteratorOfListOfCommonBlock aItCB1, aItCB2;
+    BOPTools_PaveBlock aPB11, aPB12, aPB21, aPB22, aPB1, aPB2;
+    //
+    aItLPB.Initialize(aLPBS);
+    for (; aItLPB.More(); aItLPB.Next()) { 
+      const BOPTools_PaveBlock& aPBS=aItLPB.Value();
+      nE=aPBS.OriginalEdge();
+      //
+      BOPTools_ListOfCommonBlock& aLCB1=myCommonBlockPool(myDS->RefEdge(nE));
+      aItCB1.Initialize(aLCB1);
+      for (; aItCB1.More(); aItCB1.Next()) {
+       BOPTools_CommonBlock& aCB1=aItCB1.Value();
+       aPB1=aCB1.PaveBlock1(nE);
+       nE1=aPB1.OriginalEdge();
+       //
+       if (aPB1.IsEqual(aPBS)) {
+         //
+         SplitPaveBlock(aPB1, nVT, aPB11, aPB12);
+         //
+         nF=aCB1.Face();
+         if (nF) {
+           BOPTools_CommonBlock aCBa, aCBb;
+           //
+           aLCB1.Remove(aItCB1);
+           //
+           aCBa.SetPaveBlock1(aPB11);
+           aCBa.SetFace(nF);
+           aCBb.SetPaveBlock2(aPB12);
+           aCBb.SetFace(nF);
+           //
+           aLCB1.Append(aCBa);
+           aLCB1.Append(aCBb);
+           //
+           break; 
+         }// if (nF) { 
+         else { // 1
+           BOPTools_CommonBlock aCBa, aCBb;
+           //
+           aPB2=aCB1.PaveBlock2(nE);
+           nE2=aPB2.OriginalEdge();
+           //
+           SplitPaveBlock(aPB2, nVT, aPB21, aPB22);
+           //
+           //aLCB1.Remove(aItCB1);
+           //
+           iFlag=0;
+           BOPTools_ListOfCommonBlock& aLCB2=myCommonBlockPool(myDS->RefEdge(nE2));
+           aItCB2.Initialize(aLCB2);
+           for (; aItCB2.More(); aItCB2.Next()) {
+             BOPTools_CommonBlock& aCB2=aItCB2.Value();
+             BOPTools_PaveBlock& aPBx=aCB2.PaveBlock1(nE2);
+             if (aPBx.IsEqual(aPB2)) {
+               aLCB2.Remove(aItCB2);
+               aLCB1.Remove(aItCB1);
+               //
+               bFlag=CheckCoincidence(aPB11, aPB21);
+               if (bFlag) {
+                 aCBa.SetPaveBlock1(aPB11);
+                 aCBa.SetPaveBlock2(aPB21);
+                 aCBb.SetPaveBlock1(aPB12);
+                 aCBb.SetPaveBlock2(aPB22);
+               }
+               else {
+                 aCBa.SetPaveBlock1(aPB11);
+                 aCBa.SetPaveBlock2(aPB22);
+                 aCBb.SetPaveBlock1(aPB12);
+                 aCBb.SetPaveBlock2(aPB21);
+               }
+               //
+               aLCB1.Append(aCBa);
+               aLCB1.Append(aCBb);
+               aLCB2.Append(aCBa);
+               aLCB2.Append(aCBb);
+               //
+               iFlag=1;
+               break;
+             }//if (aPB1.IsEqual(aPB2)) {
+           }//for (; aItCB2.More(); aItCB2.Next()) {
+         }//else { // 1
+       }//if (aPB1.IsEqual(aPBS)) {
+       if (iFlag) {
+         break;
+       }
+      }//for (; aItCB.More(); aItCB.Next()) {
+    }//for (; aItLPB.More(); aItLPB.Next()) {
+  }//for (k=1; k<=aNbVT; ++k) {
+}
+//=======================================================================
+//function : SplitPaveBlock
+//purpose  : 
+//=======================================================================
+void BOPTools_PaveFiller::SplitPaveBlock(const BOPTools_PaveBlock& aPBE,
+                                        const Standard_Integer nVT,
+                                        BOPTools_PaveBlock& aPB1,
+                                        BOPTools_PaveBlock& aPB2)
+{
+  Standard_Integer nE, iFlag;
+  Standard_Real aT;
+  BOPTools_Pave aPave;
+  BOPTools_ListIteratorOfListOfPaveBlock aItLPB;
+  //
+  const TopoDS_Vertex& aVT=*((TopoDS_Vertex*)&(myDS->Shape(nVT)));
+  //
+  nE=aPBE.OriginalEdge();
+  const TopoDS_Edge& aE=*((TopoDS_Edge*)&(myDS->Shape(nE)));
+  //
+  BOPTools_ListOfPaveBlock& aLPB=mySplitShapesPool(myDS->RefEdge(nE)); 
+  //
+  aItLPB.Initialize(aLPB);
+  for (; aItLPB.More(); aItLPB.Next()) {
+    const BOPTools_PaveBlock& aPB=aItLPB.Value();
+    if (aPB.IsEqual(aPBE)) {
+      aLPB.Remove(aItLPB);
+      break;
+    }
+  }
+  //
+  iFlag=myContext->ComputeVE(aVT, aE, aT);
+  //
+  aPave.SetIndex(nVT);
+  aPave.SetParam(aT);
+  //
+  aPB1.SetOriginalEdge(nE);
+  aPB1.SetPave1(aPBE.Pave1());
+  aPB1.SetPave2(aPave);
+  //
+  aPB2.SetOriginalEdge(nE);
+  aPB2.SetPave1(aPave);
+  aPB2.SetPave2(aPBE.Pave2());
+  //
+  aLPB.Append(aPB1);
+  aLPB.Append(aPB2);
+}
+
+//=======================================================================
+//function : CheckCoincidence
+//purpose  : 
+//=======================================================================
+Standard_Boolean 
+  BOPTools_PaveFiller::CheckCoincidence(const BOPTools_PaveBlock& aPB1,
+                                       const BOPTools_PaveBlock& aPB2)
+                                       
+{
+  Standard_Boolean bRet;
+  Standard_Integer nV11, nV12, nV21, nV22, nE1, nE2, iFlag;
+  Standard_Real aT11, aT12, aT21, aT22, aTM, aTN, aTolE1;
+  gp_Pnt aPM;
+  TopoDS_Vertex aVM;
+  BRep_Builder aBB;
+  //
+  const BOPTools_Pave& aPave11=aPB1.Pave1();
+  nV11=aPave11.Index();
+  aT11=aPave11.Param();
+  // 
+  const BOPTools_Pave& aPave12=aPB1.Pave2();
+  aT12=aPave12.Param();
+  nV12=aPave12.Index();
+  //
+  const BOPTools_Pave& aPave21=aPB2.Pave1();
+  nV21=aPave21.Index();
+  aT21=aPave21.Param();
+  //
+  const BOPTools_Pave& aPave22=aPB2.Pave2();
+  nV22=aPave22.Index();
+  aT22=aPave22.Param();
+  //
+  bRet=((nV11==nV21 && nV12==nV22) || (nV11==nV22 && nV12==nV21));
+  if (!bRet) {
+    return bRet;
+  }
+  //
+  nE1=aPB1.OriginalEdge();
+  const TopoDS_Edge& aE1=*((TopoDS_Edge*)&(myDS->Shape(nE1)));
+  aTolE1=BRep_Tool::Tolerance(aE1);
+  //
+  nE2=aPB2.OriginalEdge();
+  const TopoDS_Edge& aE2=*((TopoDS_Edge*)&(myDS->Shape(nE2)));
+  // 
+  aTM=IntTools_Tools::IntermediatePoint (aT11, aT12);
+  BOPTools_Tools::PointOnEdge(aE1, aTM, aPM);
+  //
+  aBB.MakeVertex (aVM, aPM, aTolE1);
+  //
+  iFlag=myContext->ComputeVE(aVM, aE2, aTN); 
+  if (iFlag) {
+    bRet=!bRet; //False
+  }
+  //
+  if (aT21 <aT22) {
+    bRet=(aTN>aT21 && aTN<aT22);
+  }
+  else {
+    bRet=(aTN>aT22 && aTN<aT21);
+  }
+  return bRet;
+} 

diff --git a/src/BOPTools/FILES b/src/BOPTools/FILES
index 885786e5f449b7eb0b9d1b8ac5ed9eb5f217ca5c..7af92dca131de5262c58a0e7427768a053180119 100755 (executable)
--- a/src/BOPTools/FILES
+++ b/src/BOPTools/FILES
@@ -4,3 +4,4 @@ BOPTools_PaveFiller_1.cxx
 BOPTools_PaveFiller_2.cxx
 BOPTools_PaveFiller_3.cxx
 BOPTools_PaveFiller_4.cxx
+BOPTools_PaveFiller_5.cxx