Use TIDSortedNodeSet instead of set< const SMDS_MeshNode*> when looking for coinciden...

+typedef std::set< const SMDS_MeshNode*,    TIDCompare >      TIDSortedNodeSet;

diff --git a/src/SMESH/SMESH_MeshEditor.cxx b/src/SMESH/SMESH_MeshEditor.cxx
index a4772e2da9273d6e071ebc523da2f5b40f515b8d..4280daa27a16ceb2137f6fe6ab58e52fc7e92f44 100644 (file)
--- a/src/SMESH/SMESH_MeshEditor.cxx
+++ b/src/SMESH/SMESH_MeshEditor.cxx
@@ -5883,24 +5883,21 @@ SMESH_MeshEditor::generateGroups(const SMESH_SequenceOfElemPtr& nodeGens,
  */
 //================================================================================
 
-void SMESH_MeshEditor::FindCoincidentNodes (set<const SMDS_MeshNode*> & theNodes,
-                                            const double                theTolerance,
-                                            TListOfListOfNodes &        theGroupsOfNodes)
+void SMESH_MeshEditor::FindCoincidentNodes (TIDSortedNodeSet &   theNodes,
+                                            const double         theTolerance,
+                                            TListOfListOfNodes & theGroupsOfNodes)
 {
   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
 
-  set<const SMDS_MeshNode*> nodes;
   if ( theNodes.empty() )
   { // get all nodes in the mesh
-    SMDS_NodeIteratorPtr nIt = GetMeshDS()->nodesIterator();
+    SMDS_NodeIteratorPtr nIt = GetMeshDS()->nodesIterator(/*idInceasingOrder=*/true);
     while ( nIt->more() )
-      nodes.insert( nodes.end(),nIt->next());
+      theNodes.insert( theNodes.end(),nIt->next());
   }
-  else
-    nodes=theNodes;
 
-  SMESH_OctreeNode::FindCoincidentNodes ( nodes, &theGroupsOfNodes, theTolerance);
+  SMESH_OctreeNode::FindCoincidentNodes ( theNodes, &theGroupsOfNodes, theTolerance);
 }
 
 
@@ -5920,9 +5917,9 @@ struct SMESH_NodeSearcherImpl: public SMESH_NodeSearcher
   {
     myMesh = ( SMESHDS_Mesh* ) theMesh;
 
-    set<const SMDS_MeshNode*> nodes;
+    TIDSortedNodeSet nodes;
     if ( theMesh ) {
-      SMDS_NodeIteratorPtr nIt = theMesh->nodesIterator();
+      SMDS_NodeIteratorPtr nIt = theMesh->nodesIterator(/*idInceasingOrder=*/true);
       while ( nIt->more() )
         nodes.insert( nodes.end(), nIt->next() );
     }

diff --git a/src/SMESH/SMESH_MeshEditor.hxx b/src/SMESH/SMESH_MeshEditor.hxx
index 10f5be34a7aeeb09e856646c41d5cc1916b0050a..3855080f38a74472f166c3fd3c20bad6043f1405 100644 (file)
--- a/src/SMESH/SMESH_MeshEditor.hxx
+++ b/src/SMESH/SMESH_MeshEditor.hxx
@@ -60,6 +60,7 @@ typedef std::map<const SMDS_MeshNode*, const SMDS_MeshNode*> TNodeNodeMap;
 
 //!< Set of elements sorted by ID, to be used to assure predictability of edition
 typedef std::set< const SMDS_MeshElement*, TIDCompare >      TIDSortedElemSet;
+typedef std::set< const SMDS_MeshNode*,    TIDCompare >      TIDSortedNodeSet;
 
 typedef pair< const SMDS_MeshNode*, const SMDS_MeshNode* >   NLink;
 
@@ -408,9 +409,9 @@ public:
 
   typedef std::list< std::list< const SMDS_MeshNode* > > TListOfListOfNodes;
 
-  void FindCoincidentNodes (std::set<const SMDS_MeshNode*> & theNodes,
-                            const double                     theTolerance,
-                            TListOfListOfNodes &             theGroupsOfNodes);
+  void FindCoincidentNodes (TIDSortedNodeSet &   theNodes,
+                            const double         theTolerance,
+                            TListOfListOfNodes & theGroupsOfNodes);
   // Return list of group of nodes close to each other within theTolerance.
   // Search among theNodes or in the whole mesh if theNodes is empty.
 

diff --git a/src/SMESH/SMESH_OctreeNode.cxx b/src/SMESH/SMESH_OctreeNode.cxx
index 37a7d4f1bac9505bd33cf0f45a3f2a08f1ea8a9a..7cfe10d1125448f18e4c5e12ff5fed4a33e6a038 100644 (file)
--- a/src/SMESH/SMESH_OctreeNode.cxx
+++ b/src/SMESH/SMESH_OctreeNode.cxx
@@ -29,7 +29,6 @@
 //
 #include "SMESH_OctreeNode.hxx"
 
-#include "SMDS_MeshNode.hxx"
 #include "SMDS_SetIterator.hxx"
 #include <gp_Pnt.hxx>
 
@@ -44,7 +43,7 @@ using namespace std;
  * \param minBoxSize - Minimal size of the Octree Box
  */
 //================================================================
-SMESH_OctreeNode::SMESH_OctreeNode (const set<const SMDS_MeshNode*> & theNodes, const int maxLevel,
+SMESH_OctreeNode::SMESH_OctreeNode (const TIDSortedNodeSet & theNodes, const int maxLevel,
                                     const int maxNbNodes , const double minBoxSize )
   :SMESH_Octree( new SMESH_Octree::Limit( maxLevel,minBoxSize)),
   myMaxNbNodes(maxNbNodes),
@@ -86,7 +85,7 @@ SMESH_Octree* SMESH_OctreeNode::allocateOctreeChild() const
 Bnd_B3d* SMESH_OctreeNode::buildRootBox()
 {
   Bnd_B3d* box = new Bnd_B3d;
-  set<const SMDS_MeshNode*>::iterator it = myNodes.begin();
+  TIDSortedNodeSet::iterator it = myNodes.begin();
   for (; it != myNodes.end(); it++) {
     const SMDS_MeshNode* n1 = *it;
     gp_XYZ p1( n1->X(), n1->Y(), n1->Z() );
@@ -129,7 +128,7 @@ void SMESH_OctreeNode::buildChildrenData()
   gp_XYZ max = getBox().CornerMax();
   gp_XYZ mid = (min + max)/2.;
 
-  set<const SMDS_MeshNode*>::iterator it = myNodes.begin();
+  TIDSortedNodeSet::iterator it = myNodes.begin();
   while (it != myNodes.end())
   {
     const SMDS_MeshNode* n1 = *it;
@@ -214,7 +213,7 @@ bool SMESH_OctreeNode::NodesAround(const SMDS_MeshNode *              node,
     {
       double minDist = precision * precision;
       gp_Pnt p1 ( node->X(), node->Y(), node->Z() );
-      set<const SMDS_MeshNode*>::iterator nIt = myNodes.begin();
+      TIDSortedNodeSet::iterator nIt = myNodes.begin();
       for ( ; nIt != myNodes.end(); ++nIt )
       {
         gp_Pnt p2 ( (*nIt)->X(), (*nIt)->Y(), (*nIt)->Z() );
@@ -243,7 +242,7 @@ bool SMESH_OctreeNode::NodesAround(const SMDS_MeshNode *              node,
  * \param maxNbNodes - maximum Nodes in a Leaf of the SMESH_OctreeNode constructed, default value is 5
  */
 //=============================
-void SMESH_OctreeNode::FindCoincidentNodes (set<const SMDS_MeshNode*>& theSetOfNodes,
+void SMESH_OctreeNode::FindCoincidentNodes (TIDSortedNodeSet& theSetOfNodes,
                                             list< list< const SMDS_MeshNode*> >* theGroupsOfNodes,
                                             const double theTolerance,
                                             const int maxLevel,
@@ -263,11 +262,11 @@ void SMESH_OctreeNode::FindCoincidentNodes (set<const SMDS_MeshNode*>& theSetOfN
  * \param theGroupsOfNodes - list of nodes closed to each other returned
  */
 //=============================
-void SMESH_OctreeNode::FindCoincidentNodes ( set<const SMDS_MeshNode*>* theSetOfNodes,
+void SMESH_OctreeNode::FindCoincidentNodes ( TIDSortedNodeSet* theSetOfNodes,
                                              const double               theTolerance,
                                              list< list< const SMDS_MeshNode*> >* theGroupsOfNodes)
 {
-  set<const SMDS_MeshNode*>::iterator it1 = theSetOfNodes->begin();
+  TIDSortedNodeSet::iterator it1 = theSetOfNodes->begin();
   list<const SMDS_MeshNode*>::iterator it2;
 
   while (it1 != theSetOfNodes->end())
@@ -316,7 +315,7 @@ void SMESH_OctreeNode::FindCoincidentNodes ( set<const SMDS_MeshNode*>* theSetOf
  */
 //======================================================================================
 void SMESH_OctreeNode::FindCoincidentNodes (const SMDS_MeshNode * Node,
-                                            set<const SMDS_MeshNode*>* SetOfNodes,
+                                            TIDSortedNodeSet* SetOfNodes,
                                             list<const SMDS_MeshNode*>* Result,
                                             const double precision)
 {
@@ -329,8 +328,8 @@ void SMESH_OctreeNode::FindCoincidentNodes (const SMDS_MeshNode * Node,
     {
       gp_Pnt p1 (Node->X(), Node->Y(), Node->Z());
 
-      set<const SMDS_MeshNode*> myNodesCopy = myNodes;
-      set<const SMDS_MeshNode*>::iterator it = myNodesCopy.begin();
+      TIDSortedNodeSet myNodesCopy = myNodes;
+      TIDSortedNodeSet::iterator it = myNodesCopy.begin();
       double tol2 = precision * precision;
       bool squareBool;
 
@@ -383,7 +382,7 @@ void SMESH_OctreeNode::UpdateByMoveNode( const SMDS_MeshNode* node, const gp_Pnt
 {
   if ( isLeaf() )
   {
-    set<const SMDS_MeshNode*>::iterator pNode = myNodes.find( node );
+    TIDSortedNodeSet::iterator pNode = myNodes.find( node );
     bool nodeInMe = ( pNode != myNodes.end() );
 
     SMDS_MeshNode pointNode( toPnt.X(), toPnt.Y(), toPnt.Z() );
@@ -430,6 +429,6 @@ SMESH_OctreeNodeIteratorPtr SMESH_OctreeNode::GetChildrenIterator()
 SMDS_NodeIteratorPtr SMESH_OctreeNode::GetNodeIterator()
 {
   return SMDS_NodeIteratorPtr
-    ( new SMDS_SetIterator< SMDS_pNode, set< SMDS_pNode >::const_iterator >
+    ( new SMDS_SetIterator< SMDS_pNode, TIDSortedNodeSet::const_iterator >
       ( myNodes.begin(), myNodes.size() ? myNodes.end() : myNodes.begin()));
 }

diff --git a/src/SMESH/SMESH_OctreeNode.hxx b/src/SMESH/SMESH_OctreeNode.hxx
index f5e3fbf52ccdfa7ca19e230f0f0cc7aa64bcbfce..951d2bc1444fb29787ea3df6386a7833840978e1 100644 (file)
--- a/src/SMESH/SMESH_OctreeNode.hxx
+++ b/src/SMESH/SMESH_OctreeNode.hxx
@@ -31,6 +31,7 @@
 #define _SMESH_OCTREENODE_HXX_
 
 #include "SMESH_Octree.hxx"
+#include "SMDS_MeshNode.hxx"
 
 #include <list>
 #include <set>
@@ -42,15 +43,16 @@
 class SMDS_MeshNode;
 class SMESH_OctreeNode;
 
-typedef SMDS_Iterator<SMESH_OctreeNode*>            SMESH_OctreeNodeIterator;
-typedef boost::shared_ptr<SMESH_OctreeNodeIterator> SMESH_OctreeNodeIteratorPtr;
+typedef SMDS_Iterator<SMESH_OctreeNode*>              SMESH_OctreeNodeIterator;
+typedef boost::shared_ptr<SMESH_OctreeNodeIterator>   SMESH_OctreeNodeIteratorPtr;
+typedef std::set< const SMDS_MeshNode*, TIDCompare >  TIDSortedNodeSet;
 
 class SMESH_OctreeNode : public SMESH_Octree {
 
 public:
 
   // Constructor
-  SMESH_OctreeNode (const std::set<const SMDS_MeshNode*>& theNodes, const int maxLevel = 8,
+  SMESH_OctreeNode (const TIDSortedNodeSet& theNodes, const int maxLevel = 8,
                     const int maxNbNodes = 5, const double minBoxSize = 0.);
 
 //=============================
@@ -64,9 +66,9 @@ public:
   virtual const bool isInside(const SMDS_MeshNode * Node, const double precision = 0.);
 
   // Return in Result a list of Nodes potentials to be near Node
-  void               NodesAround(const SMDS_MeshNode * Node,
+  void               NodesAround(const SMDS_MeshNode *            Node,
                                  std::list<const SMDS_MeshNode*>* Result,
-                                 const double precision = 0.);
+                                 const double                     precision = 0.);
 
   // Return in dist2Nodes nodes mapped to their square distance from Node
   bool               NodesAround(const SMDS_MeshNode *                   Node,
@@ -75,13 +77,13 @@ public:
 
   // Return in theGroupsOfNodes a list of group of nodes close to each other within theTolerance
   // Search for all the nodes in nodes
-  void               FindCoincidentNodes ( std::set<const SMDS_MeshNode*>* nodes,
+  void               FindCoincidentNodes ( TIDSortedNodeSet*           nodes,
                                            const double                theTolerance,
                                            std::list< std::list< const SMDS_MeshNode*> >* theGroupsOfNodes);
 
   // Static method that return in theGroupsOfNodes a list of group of nodes close to each other within
   // theTolerance search for all the nodes in nodes
-  static void        FindCoincidentNodes ( std::set<const SMDS_MeshNode*>& nodes,
+  static void        FindCoincidentNodes ( TIDSortedNodeSet&                              nodes,
                                            std::list< std::list< const SMDS_MeshNode*> >* theGroupsOfNodes,
                                            const double theTolerance = 0.00001,
                                            const int maxLevel = -1,
@@ -117,16 +119,16 @@ protected:
   virtual SMESH_Octree* allocateOctreeChild() const;
 
   // Return in result a list of nodes closed to Node and remove it from SetOfNodes
-  void                  FindCoincidentNodes( const SMDS_MeshNode * Node,
-                                             std::set<const SMDS_MeshNode*>* SetOfNodes,
+  void                  FindCoincidentNodes( const SMDS_MeshNode *            Node,
+                                             TIDSortedNodeSet*                SetOfNodes,
                                              std::list<const SMDS_MeshNode*>* Result,
-                                             const double precision);
+                                             const double                     precision);
 
   // The max number of nodes a leaf box can contain
-  int                              myMaxNbNodes;
+  int                myMaxNbNodes;
 
   // The set of nodes inside the box of the Octree (Empty if Octree is not a leaf)
-  std::set<const SMDS_MeshNode*>   myNodes;
+  TIDSortedNodeSet   myNodes;
 
 };