0024733: Subshape IDs change between two executions of a same script

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

@@ -150,8 +150,6 @@ void BOPAlgo_Builder::BuildSplitFaces()
     anOriF=aF.Orientation();
     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 TopoDS_Shape& aF=(!k) ? aF1 : aF2;
-	const BOPCol_ListOfShape& aLF=mySplits.Find(aF);
+        const BOPCol_ListOfShape& aLF=mySplits.Find(aF);
-	//
+        //
-	aItF.Initialize(aLF);
+        aItF.Initialize(aLF);
-	for (; aItF.More(); aItF.Next()) {
+        for (; aItF.More(); aItF.Next()) {
-	  const TopoDS_Shape& aFx=aItF.Value();
+          const TopoDS_Shape& aFx=aItF.Value();
-	  //
+          //
-	  if (aMFence.Add(aFx)) {
+          if (aMFence.Add(aFx)) {
-	    BOPTools_Set aSTx;
+            BOPTools_Set aSTx;
-	    //
+            //
-	    aSTx.AddEdges(aFx);
+            aSTx.Add(aFx, TopAbs_EDGE);
-	    //
+            //
-	    if (!aIDMSS.Contains(aSTx)) {
+            if (!aIDMSS.Contains(aSTx)) {
-	      BOPAlgo_VectorOfShape& aVS=aVVS.Append1(); 
+              BOPAlgo_VectorOfShape& aVS=aVVS.Append1(); 
-	      aVS.Append(aFx);
+              aVS.Append(aFx);
-	      //
+              //
-	      j=aVVS.Extent()-1;
+              j=aVVS.Extent()-1;
-	      aIDMSS.Add (aSTx, j);
+              aIDMSS.Add (aSTx, j);
-	    }
+            }
-	    else {
+            else {
-	      j=aIDMSS.ChangeFromKey(aSTx);
+              j=aIDMSS.ChangeFromKey(aSTx);
-	      BOPAlgo_VectorOfShape& aVS=aVVS(j);
+              BOPAlgo_VectorOfShape& aVS=aVVS(j);
-	      aVS.Append(aFx);
+              aVS.Append(aFx);
-	    }
+            }
-	  }
+          }
-	}
+        }
       }
     }// if (bFlag) {
     else {// if (!bFlag) 
       BOPTools_Set aST1, aST2;
       //
-      aST1.AddEdges(aF1);
+      aST1.Add(aF1, TopAbs_EDGE);
-      aST2.AddEdges(aF2);
+      aST2.Add(aF2, TopAbs_EDGE);
       //
       if (aST1.IsEqual(aST2)) {
-	if (!aIDMSS.Contains(aST1)) {
+        if (!aIDMSS.Contains(aST1)) {
-	  BOPAlgo_VectorOfShape& aVS=aVVS.Append1(); 
+          BOPAlgo_VectorOfShape& aVS=aVVS.Append1(); 
-	  if (aMFence.Add(aF1)) {
+          if (aMFence.Add(aF1)) {
-	    aVS.Append(aF1);
+            aVS.Append(aF1);
-	  }
+          }
-	  if (aMFence.Add(aF2)) {
+          if (aMFence.Add(aF2)) {
-	    aVS.Append(aF2);
+            aVS.Append(aF2);
-	  }
+          }
-	  //
+          //
-	  k=aVVS.Extent()-1;
+          k=aVVS.Extent()-1;
-	  aIDMSS.Add (aST1, k);
+          aIDMSS.Add (aST1, k);
-	}
+        }
-	else {
+        else {
-	  k=aIDMSS.ChangeFromKey(aST1);
+          k=aIDMSS.ChangeFromKey(aST1);
-	  BOPAlgo_VectorOfShape& aVS=aVVS(k);
+          BOPAlgo_VectorOfShape& aVS=aVVS(k);
-	  if (aMFence.Add(aF1)) {
+          if (aMFence.Add(aF1)) {
-	    aVS.Append(aF1);
+            aVS.Append(aF1);
-	  }
+          }
-	  if (aMFence.Add(aF2)) {
+          if (aMFence.Add(aF2)) {
-	    aVS.Append(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);
+        const TopoDS_Shape& aFk=aVS(k);
-	BOPAlgo_PairOfShapeBoolean& aPSB=aVPSB.Append1();
+        BOPAlgo_PairOfShapeBoolean& aPSB=aVPSB.Append1();
-	aPSB.Shape1()=aFj;
+        aPSB.Shape1()=aFj;
-	aPSB.Shape2()=aFk;
+        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;
+        BOPCol_ListOfShape aLS;
-	aLS.Append(aFSD);
+        aLS.Append(aFSD);
-	mySplits.Bind(aFSD, aLS);
+        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;

src/BOPTools/BOPTools_Set.cdl

@@ -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;  
+     returns Set from BOPTools;  
-    ---C++: alias "virtual ~BOPTools_Set();"  
+    ---C++: alias "Standard_EXPORT virtual ~BOPTools_Set();"  
-    ---C++: inline 
     
     Create (theAllocator: BaseAllocator from BOPCol) 
-    	returns Set from BOPTools; 
+        returns Set from BOPTools; 
-    ---C++: inline
     
     Assign(me:out;  
-    	    Other : Set from BOPTools) 
+            Other : Set from BOPTools) 
-    	returns Set from BOPTools; 
+        returns Set from BOPTools; 
     ---C++: alias operator =
     ---C++: return &   
-    ---C++: inline 
     
     Clear(me:out) 
-    	is protected; 
+        is protected; 
-    ---C++: inline
     
     Shape(me) 
-    	 returns Shape from TopoDS; 
+        returns Shape from TopoDS; 
     ---C++: return const & 
-    ---C++: inline 
     
     Add(me:out; 
-    	    theS:Shape from TopoDS; 
+            theS:Shape from TopoDS; 
-    	    theType: ShapeEnum from TopAbs);  
+            theType: ShapeEnum from TopAbs);  
-    ---C++: inline 
-     
-    AddEdges(me:out; 
-    	    theS:Shape from TopoDS);  
-    ---C++: inline 
     
     NbShapes(me) 
-    	    returns Integer from Standard; 
+        returns Integer from Standard; 
-    ---C++: inline 
     
     IsEqual(me; 
-    	    aOther:Set from BOPTools) 
+            aOther:Set from BOPTools) 
-	returns Boolean from Standard;   
+        returns Boolean from Standard;   
-    ---C++: inline 
     
     HashCode(me; 
-	    Upper : Integer  from Standard)  
+            Upper : Integer  from Standard)  
-    	returns Integer from Standard;   	 
+        returns Integer from Standard;     
-    ---C++: inline 
     
 fields   
     myAllocator : BaseAllocator from BOPCol is protected; 

src/BOPTools/BOPTools_Set.cxx

@@ -13,3 +13,198 @@
 // 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;
+}

src/BOPTools/BOPTools_Set.lxx

@@ -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)
-}