0024733: Subshape IDs change between two executions of a same script
authorpkv <pkv@opencascade.com>
Wed, 19 Mar 2014 03:02:28 +0000 (07:02 +0400)
committerbugmaster <bugmaster@opencascade.com>
Thu, 20 Mar 2014 10:04:52 +0000 (14:04 +0400)
Changes:
1. class BOPTools_Set
   - method:
void BOPTools_Set::AddEdges(const TopoDS_Shape& aS)
has been removed as redundant

2. class BOPTools_Set
   - method:
Standard_Boolean BOPTools_Set::IsEqual  (const BOPTools_Set& theOther)const
has been modified to take into account Locations of the shapes

3. class BOPAlgo_Builder
   - method:
void BOPAlgo_Builder::FillSameDomainFaces()
has been modified in accordance with the modifications done in II.1.

src/BOPAlgo/BOPAlgo_Builder_2.cxx
src/BOPTools/BOPTools_Set.cdl
src/BOPTools/BOPTools_Set.cxx
src/BOPTools/BOPTools_Set.lxx [deleted file]

index 8426a7d..778c693 100644 (file)
@@ -151,8 +151,6 @@ void BOPAlgo_Builder::BuildSplitFaces()
     aFF=aF;
     aFF.Orientation(TopAbs_FORWARD);
     //
-    
-    //
     // 1. Fill the egdes set for the face aFF -> LE
     aLE.Clear();
     //
@@ -300,7 +298,7 @@ void BOPAlgo_Builder::FillSameDomainFaces()
   BOPCol_MapOfShape aMFence;
   BOPAlgo_IndexedDataMapOfSetInteger aIDMSS;
   BOPAlgo_VectorOfVectorOfShape aVVS;
-//
+  //
   myErrorStatus=0;
   //
   const BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
@@ -353,63 +351,63 @@ void BOPAlgo_Builder::FillSameDomainFaces()
     //
     if (bFlag) {
       for (k=0; k<2; ++k) {
-       const TopoDS_Shape& aF=(!k) ? aF1 : aF2;
-       const BOPCol_ListOfShape& aLF=mySplits.Find(aF);
-       //
-       aItF.Initialize(aLF);
-       for (; aItF.More(); aItF.Next()) {
-         const TopoDS_Shape& aFx=aItF.Value();
-         //
-         if (aMFence.Add(aFx)) {
-           BOPTools_Set aSTx;
-           //
-           aSTx.AddEdges(aFx);
-           //
-           if (!aIDMSS.Contains(aSTx)) {
-             BOPAlgo_VectorOfShape& aVS=aVVS.Append1(); 
-             aVS.Append(aFx);
-             //
-             j=aVVS.Extent()-1;
-             aIDMSS.Add (aSTx, j);
-           }
-           else {
-             j=aIDMSS.ChangeFromKey(aSTx);
-             BOPAlgo_VectorOfShape& aVS=aVVS(j);
-             aVS.Append(aFx);
-           }
-         }
-       }
+        const TopoDS_Shape& aF=(!k) ? aF1 : aF2;
+        const BOPCol_ListOfShape& aLF=mySplits.Find(aF);
+        //
+        aItF.Initialize(aLF);
+        for (; aItF.More(); aItF.Next()) {
+          const TopoDS_Shape& aFx=aItF.Value();
+          //
+          if (aMFence.Add(aFx)) {
+            BOPTools_Set aSTx;
+            //
+            aSTx.Add(aFx, TopAbs_EDGE);
+            //
+            if (!aIDMSS.Contains(aSTx)) {
+              BOPAlgo_VectorOfShape& aVS=aVVS.Append1(); 
+              aVS.Append(aFx);
+              //
+              j=aVVS.Extent()-1;
+              aIDMSS.Add (aSTx, j);
+            }
+            else {
+              j=aIDMSS.ChangeFromKey(aSTx);
+              BOPAlgo_VectorOfShape& aVS=aVVS(j);
+              aVS.Append(aFx);
+            }
+          }
+        }
       }
     }// if (bFlag) {
     else {// if (!bFlag) 
       BOPTools_Set aST1, aST2;
       //
-      aST1.AddEdges(aF1);
-      aST2.AddEdges(aF2);
+      aST1.Add(aF1, TopAbs_EDGE);
+      aST2.Add(aF2, TopAbs_EDGE);
       //
       if (aST1.IsEqual(aST2)) {
-       if (!aIDMSS.Contains(aST1)) {
-         BOPAlgo_VectorOfShape& aVS=aVVS.Append1(); 
-         if (aMFence.Add(aF1)) {
-           aVS.Append(aF1);
-         }
-         if (aMFence.Add(aF2)) {
-           aVS.Append(aF2);
-         }
-         //
-         k=aVVS.Extent()-1;
-         aIDMSS.Add (aST1, k);
-       }
-       else {
-         k=aIDMSS.ChangeFromKey(aST1);
-         BOPAlgo_VectorOfShape& aVS=aVVS(k);
-         if (aMFence.Add(aF1)) {
-           aVS.Append(aF1);
-         }
-         if (aMFence.Add(aF2)) {
-           aVS.Append(aF2);
-         }
-       }
+        if (!aIDMSS.Contains(aST1)) {
+          BOPAlgo_VectorOfShape& aVS=aVVS.Append1(); 
+          if (aMFence.Add(aF1)) {
+            aVS.Append(aF1);
+          }
+          if (aMFence.Add(aF2)) {
+            aVS.Append(aF2);
+          }
+          //
+          k=aVVS.Extent()-1;
+          aIDMSS.Add (aST1, k);
+        }
+        else {
+          k=aIDMSS.ChangeFromKey(aST1);
+          BOPAlgo_VectorOfShape& aVS=aVVS(k);
+          if (aMFence.Add(aF1)) {
+            aVS.Append(aF1);
+          }
+          if (aMFence.Add(aF2)) {
+            aVS.Append(aF2);
+          }
+        }
       }//if (aST1.IsEqual(aST2)) {
     }// else {// if (!bFlag) 
     //
@@ -433,10 +431,10 @@ void BOPAlgo_Builder::FillSameDomainFaces()
     for (j=0; j<aNbF1; ++j) {
       const TopoDS_Shape& aFj=aVS(j);
       for (k=j+1; k<aNbF; ++k) {
-       const TopoDS_Shape& aFk=aVS(k);
-       BOPAlgo_PairOfShapeBoolean& aPSB=aVPSB.Append1();
-       aPSB.Shape1()=aFj;
-       aPSB.Shape2()=aFk;
+        const TopoDS_Shape& aFk=aVS(k);
+        BOPAlgo_PairOfShapeBoolean& aPSB=aVPSB.Append1();
+        aPSB.Shape1()=aFj;
+        aPSB.Shape2()=aFk;
       }
     }
   }
@@ -479,9 +477,9 @@ void BOPAlgo_Builder::FillSameDomainFaces()
       // If the face has no splits but are SD face,
       // it is considered as splitted face
       if (!mySplits.IsBound(aFSD)) {
-       BOPCol_ListOfShape aLS;
-       aLS.Append(aFSD);
-       mySplits.Bind(aFSD, aLS);
+        BOPCol_ListOfShape aLS;
+        aLS.Append(aFSD);
+        mySplits.Bind(aFSD, aLS);
       }
     }
   }
@@ -552,7 +550,7 @@ void BOPAlgo_Builder::FillImagesFaces1()
 // purpose: 
 //=======================================================================
 void BOPAlgo_Builder::FillInternalVertices(BOPCol_ListOfShape& aLFIm,
-                                          BOPCol_ListOfInteger& aLIAV)
+                                           BOPCol_ListOfInteger& aLIAV)
 {
   Standard_Integer nV, iFlag;
   Standard_Real aU1, aU2;
index 76747f1..9e4e5c6 100644 (file)
@@ -14,7 +14,7 @@
 
 class Set from BOPTools 
 
-       ---Purpose: 
+ ---Purpose: 
 
 uses  
     ShapeEnum from TopAbs,
@@ -26,52 +26,39 @@ uses
 
 is 
     Create 
-       returns Set from BOPTools;  
-    ---C++: alias "virtual ~BOPTools_Set();"  
-    ---C++: inline 
+     returns Set from BOPTools;  
+    ---C++: alias "Standard_EXPORT virtual ~BOPTools_Set();"  
+    
+    Create (theAllocator: BaseAllocator from BOPCol) 
+        returns Set from BOPTools; 
     
-    Create (theAllocator: BaseAllocator from BOPCol)
-       returns Set from BOPTools; 
-    ---C++: inline
-     
     Assign(me:out;  
-           Other : Set from BOPTools) 
-       returns Set from BOPTools; 
+            Other : Set from BOPTools) 
+        returns Set from BOPTools; 
     ---C++: alias operator =
     ---C++: return &   
-    ---C++: inline 
     
     Clear(me:out) 
-       is protected; 
-    ---C++: inline
-     
+        is protected; 
+    
     Shape(me) 
-        returns Shape from TopoDS; 
+        returns Shape from TopoDS; 
     ---C++: return const & 
-    ---C++: inline 
-     
+    
     Add(me:out; 
-           theS:Shape from TopoDS; 
-           theType: ShapeEnum from TopAbs);  
-    ---C++: inline 
-     
-    AddEdges(me:out; 
-           theS:Shape from TopoDS);  
-    ---C++: inline 
-     
+            theS:Shape from TopoDS; 
+            theType: ShapeEnum from TopAbs);  
+    
     NbShapes(me) 
-           returns Integer from Standard; 
-    ---C++: inline 
-     
+        returns Integer from Standard; 
+    
     IsEqual(me; 
-           aOther:Set from BOPTools) 
-       returns Boolean from Standard;   
-    ---C++: inline 
-     
+            aOther:Set from BOPTools) 
+        returns Boolean from Standard;   
+    
     HashCode(me; 
-           Upper : Integer  from Standard)  
-       returns Integer from Standard;           
-    ---C++: inline 
+            Upper : Integer  from Standard)  
+        returns Integer from Standard;     
     
 fields   
     myAllocator : BaseAllocator from BOPCol is protected; 
index 3e555f1..8cd2576 100644 (file)
 // commercial license or contractual agreement.
 
 #include <BOPTools_Set.ixx>
+#include <TopoDS_Shape.hxx>
+#include <TopExp_Explorer.hxx>
+#include <TopoDS_Edge.hxx>
+#include <BRep_Tool.hxx>
+#include <BOPCol_MapOfShape.hxx>
+
+static 
+  Standard_Integer NormalizedIds(const Standard_Integer aId,
+                                 const Standard_Integer aDiv);
+
+//=======================================================================
+//function : 
+//purpose  : 
+//=======================================================================
+BOPTools_Set::BOPTools_Set() 
+:
+  myAllocator(NCollection_BaseAllocator::CommonBaseAllocator()),
+  myShapes(myAllocator)
+{
+  myNbShapes=0;
+  mySum=0;
+  myUpper=432123;
+}
+//=======================================================================
+//function : 
+//purpose  : 
+//=======================================================================
+BOPTools_Set::BOPTools_Set
+  (const Handle(NCollection_BaseAllocator)& theAllocator) 
+:
+  myAllocator(theAllocator),
+  myShapes(myAllocator)
+{ 
+  myNbShapes=0;
+  mySum=0;  
+  myUpper=432123;
+}
+//=======================================================================
+//function :~ 
+//purpose  : 
+//=======================================================================
+BOPTools_Set::~BOPTools_Set()
+{
+  Clear();
+}
+//=======================================================================
+//function : Clear
+//purpose  : 
+//=======================================================================
+void BOPTools_Set::Clear()
+{ 
+  myNbShapes=0;
+  mySum=0;
+  myShapes.Clear();
+}
+//=======================================================================
+//function : NbShapes
+//purpose  : 
+//=======================================================================
+Standard_Integer BOPTools_Set::NbShapes()const
+{
+  return myNbShapes;
+}
+//=======================================================================
+//function :Assign
+//purpose  : 
+//=======================================================================
+BOPTools_Set& BOPTools_Set::Assign(const BOPTools_Set& theOther)
+{ 
+  BOPCol_ListIteratorOfListOfShape aIt;
+  //
+  myShape=theOther.myShape;
+  myNbShapes=theOther.myNbShapes;
+  mySum=theOther.mySum;
+  myUpper=theOther.myUpper;
+  myAllocator=theOther.myAllocator;
+  //
+  myShapes.Clear();
+  aIt.Initialize(theOther.myShapes);
+  for (; aIt.More(); aIt.Next()) {
+    const TopoDS_Shape& aSx=aIt.Value();
+    myShapes.Append(aSx);
+  }
+  return *this;
+}
+//=======================================================================
+//function : Shape
+//purpose  : 
+//=======================================================================
+const TopoDS_Shape& BOPTools_Set::Shape()const
+{
+  return myShape;
+}
+//=======================================================================
+//function : HashCode
+//purpose  : 
+//=======================================================================
+Standard_Integer BOPTools_Set::HashCode
+  (const Standard_Integer theUpper)const
+{
+  return ::HashCode(mySum, theUpper);
+}
+//=======================================================================
+//function : IsEqual
+//purpose  : 
+//=======================================================================
+Standard_Boolean BOPTools_Set::IsEqual
+  (const BOPTools_Set& theOther)const
+{
+  Standard_Boolean bRet;
+  //
+  bRet=Standard_False;
+  //
+  if (theOther.myNbShapes!=myNbShapes) {
+    return bRet;
+  }
+  //
+  BOPCol_MapOfShape aM1;
+  BOPCol_ListIteratorOfListOfShape aIt;
+  //
+  aIt.Initialize(myShapes);
+  for (; aIt.More(); aIt.Next()) {
+    const TopoDS_Shape& aSx1=aIt.Value();
+    aM1.Add(aSx1);
+  }
+  //
+  aIt.Initialize(theOther.myShapes);
+  for (; aIt.More(); aIt.Next()) {
+    const TopoDS_Shape& aSx2=aIt.Value();
+    if (!aM1.Contains(aSx2)) {
+      return bRet;
+    }
+  }
+  //
+  return !bRet;
+}
+//=======================================================================
+//function : Add
+//purpose  : 
+//=======================================================================
+void BOPTools_Set::Add(const TopoDS_Shape& theS,
+                       const TopAbs_ShapeEnum theType)
+{
+  Standard_Integer aId, aIdN;
+  TopExp_Explorer aExp;
+  //
+  myShape=theS;
+  myShapes.Clear();
+  myNbShapes=0;
+  mySum=0;
+  //
+  aExp.Init(theS, theType);
+  for (; aExp.More(); aExp.Next()) {
+    const TopoDS_Shape& aSx=aExp.Current();
+    if (theType==TopAbs_EDGE) {
+      const TopoDS_Edge& aEx=*((TopoDS_Edge*)&aSx);
+      if (BRep_Tool::Degenerated(aEx)) {
+        continue;
+      }
+    }
+    myShapes.Append(aSx);
+  }
+  //
+  myNbShapes=myShapes.Extent();
+  if (!myNbShapes) {
+    return;
+  }
+  // 
+  BOPCol_ListIteratorOfListOfShape aIt;
+  //
+  aIt.Initialize(myShapes);
+  for (; aIt.More(); aIt.Next()) {
+    const TopoDS_Shape& aSx=aIt.Value();
+    aId=aSx.HashCode(myUpper);
+    aIdN=NormalizedIds(aId, myNbShapes);
+    mySum+=aIdN;
+  }
+}
+//=======================================================================
+// function: NormalizedIds
+// purpose : 
+//=======================================================================
+Standard_Integer NormalizedIds(const Standard_Integer aId,
+                               const Standard_Integer aDiv)
+{
+  Standard_Integer aMax, aTresh, aIdRet;
+  //
+  aIdRet=aId;
+  aMax=::IntegerLast();
+  aTresh=aMax/aDiv;
+  if (aId>aTresh) {
+    aIdRet=aId%aTresh;
+  }
+  return aIdRet;
+}
diff --git a/src/BOPTools/BOPTools_Set.lxx b/src/BOPTools/BOPTools_Set.lxx
deleted file mode 100755 (executable)
index 3e7a82a..0000000
+++ /dev/null
@@ -1,325 +0,0 @@
-// Created by: Peter KURNEV
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//#include <BOPTools_Set.ixx>
-
-#include <TopExp_Explorer.hxx>
-#include <BRep_Tool.hxx>
-
-
-static 
-  inline Standard_Boolean operator<(const TopoDS_Shape& theS1,
-                                   const TopoDS_Shape& theS2);
-static 
-  inline void SortShell(const int n, TopoDS_Shape *a); 
-
-static 
-  inline Standard_Integer NormalizedIds(const Standard_Integer aId,
-                                       const Standard_Integer aDiv);
-//=======================================================================
-//function : 
-//purpose  : 
-//=======================================================================
-  inline BOPTools_Set::BOPTools_Set() 
-:
-  myAllocator(NCollection_BaseAllocator::CommonBaseAllocator()),
-  myShapes(myAllocator)
-{
-  myNbShapes=0;
-  mySum=0;
-  myUpper=432123;
-}
-//=======================================================================
-//function : 
-//purpose  : 
-//=======================================================================
-  inline BOPTools_Set::BOPTools_Set(const Handle(NCollection_BaseAllocator)& theAllocator) 
-:
-  myAllocator(theAllocator),
-  myShapes(myAllocator)
-{ 
-  myNbShapes=0;
-  mySum=0;  
-  myUpper=432123;
-}
-//=======================================================================
-//function :~ 
-//purpose  : 
-//=======================================================================
-  inline BOPTools_Set::~BOPTools_Set()
-{
-  Clear();
-}
-//=======================================================================
-//function : Clear
-//purpose  : 
-//=======================================================================
-  inline void BOPTools_Set::Clear()
-{ 
-  myNbShapes=0;
-  mySum=0;
-  myShapes.Clear();
-}
-//=======================================================================
-//function : NbShapes
-//purpose  : 
-//=======================================================================
-  inline Standard_Integer BOPTools_Set::NbShapes()const
-{
-  return myNbShapes;
-}
-//=======================================================================
-//function :Assign
-//purpose  : 
-//=======================================================================
-  inline BOPTools_Set& BOPTools_Set::Assign(const BOPTools_Set& theOther)
-{ 
-  BOPCol_ListIteratorOfListOfShape aIt;
-  //
-  myShape=theOther.myShape;
-  myNbShapes=theOther.myNbShapes;
-  mySum=theOther.mySum;
-  myUpper=theOther.myUpper;
-  myAllocator=theOther.myAllocator;
-  //
-  myShapes.Clear();
-  aIt.Initialize(theOther.myShapes);
-  for (; aIt.More(); aIt.Next()) {
-    const TopoDS_Shape& aSx=aIt.Value();
-    myShapes.Append(aSx);
-  }
-  return *this;
-}
-//=======================================================================
-//function : Shape
-//purpose  : 
-//=======================================================================
-  inline const TopoDS_Shape& BOPTools_Set::Shape()const
-{
-  return myShape;
-}
-//=======================================================================
-//function : Add
-//purpose  : 
-//=======================================================================
-  inline void BOPTools_Set::Add(const TopoDS_Shape& theS,
-                               const TopAbs_ShapeEnum theType)
-{
-  if (theType==TopAbs_EDGE) {
-    AddEdges(theS);
-    return;
-  }
-  //
-  Standard_Integer i, aNb, aId, aIdN;
-  TopoDS_Shape *pShapes;
-  TopExp_Explorer aExp;
-  // 
-  myNbShapes=0;
-  mySum=0;
-  myShape=theS;
-  //
-  aExp.Init(theS, theType);
-  for (aNb=0; aExp.More(); aExp.Next(), ++aNb) {
-  }
-  //
-  if (!aNb) {
-    return;
-  }
-  //
-  myNbShapes=aNb;
-  pShapes=(TopoDS_Shape *)myAllocator->Allocate(aNb*sizeof(TopoDS_Shape));
-  //
-  aExp.ReInit();
-  for (i=0; aExp.More(); aExp.Next(),++i) {
-    const TopoDS_Shape& aSx=aExp.Current();
-    new (pShapes+i) TopoDS_Shape();
-    pShapes[i]=aSx;
-  }
-  //
-  SortShell(aNb, pShapes);
-  //
-  myShapes.Clear();
-  for (i=0; i<aNb; ++i) {
-    const TopoDS_Shape& aSx=pShapes[i];
-    myShapes.Append(aSx);
-    //
-    aId=aSx.HashCode(myUpper);
-    aIdN=NormalizedIds(aId, aNb);
-    mySum+=aIdN;
-  }
-  //
-  for (i=0; i<aNb; ++i) {
-    pShapes[i].~TopoDS_Shape();
-  }
-  myAllocator->Free(pShapes);
-}
-//=======================================================================
-//function : AddEdges
-//purpose  : 
-//=======================================================================
-  inline void BOPTools_Set::AddEdges(const TopoDS_Shape& theS)
-{
-  Standard_Integer i, aNb, aId, aIdN;
-  TopoDS_Shape *pShapes;
-  TopExp_Explorer aExp;
-  // 
-  myNbShapes=0;
-  mySum=0;
-  myShape=theS;
-  //
-  aExp.Init(theS, TopAbs_EDGE);
-  for (aNb=0; aExp.More(); aExp.Next()) {
-    const TopoDS_Edge& aE=(*(TopoDS_Edge*)(&aExp.Current()));
-    if (!BRep_Tool::Degenerated(aE)) {
-      ++aNb;
-    }
-  }
-  //
-  if (!aNb) {
-    return;
-  }
-  //
-  myNbShapes=aNb;
-  pShapes=(TopoDS_Shape *)myAllocator->Allocate(aNb*sizeof(TopoDS_Shape));
-  //
-  i=0;
-  aExp.ReInit();
-  for (; aExp.More(); aExp.Next()) {
-    const TopoDS_Shape& aSx=aExp.Current();
-    const TopoDS_Edge& aE=(*(TopoDS_Edge*)(&aSx));
-    if (!BRep_Tool::Degenerated(aE)) {
-      new (pShapes+i) TopoDS_Shape();
-      pShapes[i]=aSx;
-      ++i;
-    }
-  }
-  //
-  SortShell(aNb, pShapes);
-  //
-  myShapes.Clear();
-  for (i=0; i<aNb; ++i) {
-    const TopoDS_Shape& aSx=pShapes[i];
-    myShapes.Append(aSx);
-    //
-    aId=aSx.HashCode(myUpper);
-    aIdN=NormalizedIds(aId, aNb);
-    mySum+=aIdN;
-  }
-  //
-  for (i=0; i<aNb; ++i) {
-    pShapes[i].~TopoDS_Shape();
-  }
-  myAllocator->Free(pShapes);
-}
-//=======================================================================
-//function : IsEqual
-//purpose  : 
-//=======================================================================
-  inline Standard_Boolean BOPTools_Set::IsEqual(const BOPTools_Set& theOther)const
-{
-  Standard_Boolean bRet;
-  //
-  bRet=Standard_False;
-  //
-  if (theOther.myNbShapes!=myNbShapes) {
-    return bRet;
-  }
-  //
-  BOPCol_ListIteratorOfListOfShape aIt1, aIt2;
-  //
-  aIt1.Initialize(myShapes);
-  aIt2.Initialize(theOther.myShapes);
-  for (; aIt1.More()||aIt2.More(); aIt1.Next(), aIt2.Next()) {
-    const TopoDS_Shape& aSx1=aIt1.Value();
-    const TopoDS_Shape& aSx2=aIt2.Value();
-    if (aSx1.TShape().operator->() != aSx2.TShape().operator->()) {
-      return bRet;
-    }
-  }
-  return !bRet;
-}
-//=======================================================================
-//function : HashCode
-//purpose  : 
-//=======================================================================
-  inline Standard_Integer BOPTools_Set::HashCode(const Standard_Integer theUpper)const
-{
-  return ::HashCode(mySum, theUpper);
-}
-//=======================================================================
-// function: NormalizedIds
-// purpose : 
-//=======================================================================
-Standard_Integer NormalizedIds(const Standard_Integer aId,
-                             const Standard_Integer aDiv)
-{
-  Standard_Integer aMax, aTresh, aIdRet;
-  //
-  aIdRet=aId;
-  aMax=::IntegerLast();
-  aTresh=aMax/aDiv;
-  if (aId>aTresh) {
-    aIdRet=aId%aTresh;
-  }
-  return aIdRet;
-}
-
-//=======================================================================
-//function : operator<
-//purpose  : 
-//=======================================================================
-Standard_Boolean operator<(const TopoDS_Shape& theS1,
-                          const TopoDS_Shape& theS2)
-{
-  Standard_Address aAddr1, aAddr2;
-  //
-  const Handle(TopoDS_TShape)& aTS1=theS1.TShape();
-  aAddr1=aTS1.operator->();
-  //
-  const Handle(TopoDS_TShape)& aTS2=theS2.TShape();
-  aAddr2=aTS2.operator->();
-  //
-  return (aAddr1<aAddr2);
-}
-//=======================================================================
-// function: SortShell
-// purpose : 
-//=======================================================================
-void SortShell(const int n, TopoDS_Shape *a) 
-{
-  int nd, i, j, l, d=1;
-  TopoDS_Shape x;
-  //
-  while(d<=n) {
-    d*=2;
-  }
-  //
-  while (d) {
-    d=(d-1)/2;
-    //
-    nd=n-d;
-    for (i=0; i<nd; ++i) {
-      j=i;
-    m30:;
-      l=j+d;
-      if (a[l] < a[j]){
-       x=a[j];
-       a[j]=a[l];
-       a[l]=x;
-       j-=d;
-       if (j > -1) goto m30;
-      }//if (a[l] < a[j]){
-    }//for (i=0; i<nd; ++i) 
-  }//while (1)
-}