imn/auto-reorder_of_nodes_ver2

src/SMESHGUI/SMESHGUI_AddMeshElementDlg.cxx

@@ -413,14 +413,26 @@ SMESHGUI_AddMeshElementDlg::SMESHGUI_AddMeshElementDlg( SMESHGUI*          theMo
 
   Reverse = (myElementType == SMDSAbs_Face || myElementType == SMDSAbs_Volume ) ? new QCheckBox(tr("SMESH_REVERSE"), GroupC1) : 0;
 
+  AutomaticPresentation = (myGeomType == SMDSEntity_Quadrangle || myGeomType == SMDSEntity_Polygon ||
+                           myGeomType == SMDSEntity_Pyramid    || myGeomType == SMDSEntity_Hexa    ||
+                           myGeomType == SMDSEntity_Penta      || myGeomType == SMDSEntity_Hexagonal_Prism ) ? new QCheckBox(tr("SMESH_AUTOMATIC_PRESENTATION"), GroupC1) : 0;
+  if ( AutomaticPresentation ) {
+    GetNextPresentationButton = new QPushButton(tr("SMESH_BUT_GET_NEXT_SHAPE"), GroupC1);
+    GetNextPresentationButton->setAutoDefault(false);
+  }
   DiameterSpinBox = ( myGeomType == SMDSEntity_Ball ) ? new SMESHGUI_SpinBox(GroupC1) : 0;
   QLabel* diameterLabel = DiameterSpinBox ? new QLabel( tr("BALL_DIAMETER"),GroupC1) : 0;
 
   GroupC1Layout->addWidget(TextLabelC1A1,    0, 0);
   GroupC1Layout->addWidget(SelectButtonC1A1, 0, 1);
   GroupC1Layout->addWidget(LineEditC1A1,     0, 2);
+  if ( AutomaticPresentation ) {
+    AutomaticPresentation->setChecked(true);
+    GroupC1Layout->addWidget(AutomaticPresentation, 1, 0, 1, 2);
+    GroupC1Layout->addWidget(GetNextPresentationButton, 1, 2, 1, 1);
+  }
   if ( Reverse ) {
-    GroupC1Layout->addWidget(Reverse, 1, 0, 1, 3);
+    GroupC1Layout->addWidget(Reverse, 2, 0, 1, 3);
   }
   if ( DiameterSpinBox ) {
     GroupC1Layout->addWidget(diameterLabel,   1, 0);
@@ -506,22 +518,25 @@ void SMESHGUI_AddMeshElementDlg::Init()
   myActor = 0;
 
   /* signals and slots connections */
-  connect(buttonOk,        SIGNAL(clicked()),                     SLOT(ClickOnOk()));
+  connect(buttonOk,                SIGNAL(clicked()),                     SLOT(ClickOnOk()));
-  connect(buttonCancel,    SIGNAL(clicked()),                     SLOT(reject()));
+  connect(buttonCancel,            SIGNAL(clicked()),                     SLOT(reject()));
-  connect(buttonApply,     SIGNAL(clicked()),                     SLOT(ClickOnApply()));
+  connect(buttonApply,             SIGNAL(clicked()),                     SLOT(ClickOnApply()));
-  connect(buttonHelp,      SIGNAL(clicked()),                     SLOT(ClickOnHelp()));
+  connect(buttonHelp,              SIGNAL(clicked()),                     SLOT(ClickOnHelp()));
 
-  connect(SelectButtonC1A1,SIGNAL(clicked()),                     SLOT(SetEditCurrentArgument()));
+  connect(SelectButtonC1A1,        SIGNAL(clicked()),                     SLOT(SetEditCurrentArgument()));
-  connect(LineEditC1A1,    SIGNAL(textChanged(const QString&)),   SLOT(onTextChange(const QString&)));
+  connect(LineEditC1A1,            SIGNAL(textChanged(const QString&)),   SLOT(onTextChange(const QString&)));
-  connect(mySMESHGUI,      SIGNAL(SignalDeactivateActiveDialog()),SLOT(DeactivateActiveDialog()));
+  connect(mySMESHGUI,              SIGNAL(SignalDeactivateActiveDialog()),SLOT(DeactivateActiveDialog()));
-  connect(mySelectionMgr,  SIGNAL(currentSelectionChanged()),     SLOT(SelectionIntoArgument()));
+  connect(mySelectionMgr,          SIGNAL(currentSelectionChanged()),     SLOT(SelectionIntoArgument()));
   /* to close dialog if study frame change */
-  connect(mySMESHGUI,      SIGNAL(SignalStudyFrameChanged()),     SLOT(reject()));
+  connect(mySMESHGUI,              SIGNAL(SignalStudyFrameChanged()),     SLOT(reject()));
-  connect(mySMESHGUI,      SIGNAL(SignalCloseAllDialogs()),       SLOT(reject()));    
+  connect(mySMESHGUI,              SIGNAL(SignalCloseAllDialogs()),       SLOT(reject()));
 
   if (Reverse)
-    connect(Reverse,       SIGNAL(stateChanged(int)),             SLOT(CheckBox(int)));
+    connect(Reverse,               SIGNAL(stateChanged(int)),             SLOT(CheckBox(int)));
-
+  if (AutomaticPresentation) {
+    connect(AutomaticPresentation, SIGNAL(stateChanged(int)),             SLOT(SelectionIntoArgument()));
+    connect(GetNextPresentationButton, SIGNAL(clicked()),                 SLOT(GetNextShapePresentation()));
+  }
   // set selection mode
   SMESH::SetPointRepresentation(true);
 
@@ -649,6 +664,8 @@ void SMESHGUI_AddMeshElementDlg::ClickOnApply()
     
     buttonOk->setEnabled(false);
     buttonApply->setEnabled(false);
+    if ( AutomaticPresentation )
+      GetNextPresentationButton->setEnabled(false);
 
     myEditCurrentArgument->setText("");
 
@@ -721,6 +738,8 @@ void SMESHGUI_AddMeshElementDlg::onTextChange (const QString& theNewText)
 
   buttonOk->setEnabled(false);
   buttonApply->setEnabled(false);
+  if ( AutomaticPresentation )
+    GetNextPresentationButton->setEnabled(false);
 
   mySimulation->SetVisibility(false);
 
@@ -762,6 +781,8 @@ void SMESHGUI_AddMeshElementDlg::onTextChange (const QString& theNewText)
   if(myNbOkNodes) {
     buttonOk->setEnabled(true);
     buttonApply->setEnabled(true);
+    if ( AutomaticPresentation && AutomaticPresentation->isChecked() )
+      GetNextPresentationButton->setEnabled(true);
     displaySimulation();
   }
 
@@ -781,6 +802,7 @@ void SMESHGUI_AddMeshElementDlg::SelectionIntoArgument()
   myActor = 0;
 
   myBusy = true;
+  QString anOldEditArgument = myEditCurrentArgument->text();
   myEditCurrentArgument->setText("");
   myBusy = false;
 
@@ -789,6 +811,8 @@ void SMESHGUI_AddMeshElementDlg::SelectionIntoArgument()
 
   buttonOk->setEnabled(false);
   buttonApply->setEnabled(false);
+  if ( AutomaticPresentation )
+    GetNextPresentationButton->setEnabled(false);
 
   mySimulation->SetVisibility(false);
   //  SMESH::SetPointRepresentation(true);
@@ -832,14 +856,34 @@ void SMESHGUI_AddMeshElementDlg::SelectionIntoArgument()
 
   // get selected nodes
   QString aString = "";
-  int nbNodes = SMESH::GetNameOfSelectedNodes(mySelector,myActor->getIO(),aString);
+  int nbNodes = 0;
-  myBusy = true;
+  while ( aString == "" || anOldEditArgument == aString ) {
-  myEditCurrentArgument->setText(aString);
+    if ( AutomaticPresentation && AutomaticPresentation->isChecked() ) {
-  myBusy = false;
+      nbNodes = SMESH::GetNameOfSelectedSortedNodes( myGeomType , mySelector, myActor, myShift, aString );
-  if (myIsPoly && myElementType == SMDSAbs_Face && nbNodes >= 3 ) {
+    }
-    myNbNodes = nbNodes;
+    else
-  } else if (myNbNodes != nbNodes && myNbNodes != 1) {
+      nbNodes = SMESH::GetNameOfSelectedNodes( mySelector, myActor->getIO(), aString );
-    return;
+    if ( aString!= "" && myNbNodes == nbNodes && anOldEditArgument == aString && AutomaticPresentation && AutomaticPresentation->isChecked()) {
+      myShift++;
+      if ( myShift > nbNodes ) {
+        myEditCurrentArgument->setText(aString);
+        myShift = 0;
+        break;
+      }
+      continue;
+    }
+    myBusy = true;
+    myEditCurrentArgument->setText(aString);
+    myBusy = false;
+    if (myIsPoly && myElementType == SMDSAbs_Face && nbNodes >= 3 )
+      myNbNodes = nbNodes;
+    else if (myNbNodes != nbNodes && myNbNodes != 1) {
+      myShift = 0;
+      return;
+    }
+    if ( !AutomaticPresentation || !AutomaticPresentation->isChecked() ||
+       ( myIsPoly && nbNodes < 3 ) )
+      break;
   }
 
   // OK
@@ -847,6 +891,8 @@ void SMESHGUI_AddMeshElementDlg::SelectionIntoArgument()
 
   buttonOk->setEnabled(true);
   buttonApply->setEnabled(true);
+  if ( AutomaticPresentation && AutomaticPresentation->isChecked() )
+    GetNextPresentationButton->setEnabled(true);
 
   displaySimulation();
 }
@@ -896,6 +942,16 @@ void SMESHGUI_AddMeshElementDlg::SetEditCurrentArgument()
   SelectionIntoArgument();
 }
 
+//=================================================================================
+// function : GetNextShapePresentation()
+// purpose  :
+//=================================================================================
+void SMESHGUI_AddMeshElementDlg::GetNextShapePresentation()
+{
+  myShift++;
+  SetEditCurrentArgument();
+}
+
 //=================================================================================
 // function : DeactivateActiveDialog()
 // purpose  :

src/SMESHGUI/SMESHGUI_AddMeshElementDlg.h

@@ -90,6 +90,7 @@ private:
   int                         myElementType;
   int                         myNbNodes;
   bool                        myIsPoly;
+  int                         myShift;
   
   SMESH::SMESH_Mesh_var       myMesh;
   SMESH_Actor*                myActor;
@@ -110,8 +111,10 @@ private:
   QGroupBox*                  GroupC1;
   QLabel*                     TextLabelC1A1;
   QPushButton*                SelectButtonC1A1;
+  QPushButton*                GetNextPresentationButton;
   QLineEdit*                  LineEditC1A1;
   QCheckBox*                  Reverse;
+  QCheckBox*                  AutomaticPresentation;
   SMESHGUI_SpinBox*           DiameterSpinBox;
   
   QString                     myHelpFileName;
@@ -124,6 +127,7 @@ private slots:
   void                        ClickOnOk();
   void                        ClickOnApply();
   void                        ClickOnHelp();
+  void                        GetNextShapePresentation();
   void                        SetEditCurrentArgument();
   void                        SelectionIntoArgument();
   void                        DeactivateActiveDialog();

src/SMESHGUI/SMESHGUI_VTKUtils.cxx

@@ -76,6 +76,14 @@
 // OCCT includes
 #include <TColStd_IndexedMapOfInteger.hxx>
 #include <Standard_ErrorHandler.hxx>
+#include <ProjLib.hxx>
+#include <gp_Pln.hxx>
+#include <gp_Lin.hxx>
+#include <gce_MakePln.hxx>
+#include <gce_MakeLin.hxx>
+#include <GeomAPI_IntCS.hxx>
+#include <Geom_Line.hxx>
+#include <Geom_Plane.hxx>
 
 namespace SMESH
 {
@@ -1112,6 +1120,135 @@ namespace SMESH
 
 
   //----------------------------------------------------------------------------
+  int GetNameOfSelectedSortedNodes( SMDSAbs_EntityType theElementType,
+                                    SVTK_Selector* theSelector,
+                                    SMESH_Actor* theActor,
+                                    int theShift,
+                                    QString& theName)
+  {
+    theName = "";
+    TColStd_IndexedMapOfInteger aMapIndex;
+    Handle(SALOME_InteractiveObject) anIO = theActor->getIO();
+    theSelector->GetIndex(anIO, aMapIndex);
+
+    SMDS_Mesh* aMesh = 0;
+    if (theActor)
+      aMesh = theActor->GetObject()->GetMesh();
+
+    std::vector<SMESH_TNodeXYZ> aVectorOfNode;
+    std::list<int> aListOfId;
+    int aSize = aMapIndex.Extent();
+    for( int i = 1 ; i <= aSize; i++) {
+      SMESH_TNodeXYZ aCurNode = aMesh->FindNode( aMapIndex(i) );
+      aVectorOfNode.push_back( aCurNode );
+      aListOfId.push_back( aCurNode._node->GetID() );
+    }
+    SMESH_TNodeXYZ aFirstNode;
+    if ( aSize > 0 )
+      aFirstNode = aVectorOfNode[0];
+    int myNbNodes = 0;
+    std::list<int> aResultListId;
+    switch ( theElementType ) {
+      case SMDSEntity_0D:
+        myNbNodes = 1;
+        break;
+      case SMDSEntity_Ball:
+        myNbNodes = 1;
+        break;
+      case SMDSEntity_Edge:
+      case SMDSEntity_Quad_Edge:
+        myNbNodes = 2;
+        break;
+      case SMDSEntity_Triangle:
+      case SMDSEntity_Quad_Triangle:
+      case SMDSEntity_BiQuad_Triangle:
+        myNbNodes = 3;
+        break;
+      case SMDSEntity_Quadrangle:
+      case SMDSEntity_Quad_Quadrangle:
+      case SMDSEntity_BiQuad_Quadrangle:
+        myNbNodes = 4;
+        if ( myNbNodes <= aSize ) {
+          aVectorOfNode.resize( myNbNodes );
+          aVectorOfNode[0] = aVectorOfNode[theShift % myNbNodes];
+          aVectorOfNode[theShift % myNbNodes] = aFirstNode;
+          GetSortedNodesOnPolygon( aVectorOfNode, aResultListId );
+        }
+        break;
+      case SMDSEntity_Polygon:
+        myNbNodes = 0;
+        if ( aSize > 0 ) {
+          aVectorOfNode[0] = aVectorOfNode[theShift % aVectorOfNode.size()];
+          aVectorOfNode[theShift % aVectorOfNode.size()] = aFirstNode;
+        }
+        GetSortedNodesOnPolygon( aVectorOfNode, aResultListId );
+        break;
+      case SMDSEntity_Tetra:
+      case SMDSEntity_Quad_Tetra:
+        myNbNodes = 4;
+        break;
+      case SMDSEntity_Pyramid:
+      case SMDSEntity_Quad_Pyramid:
+        myNbNodes = 5;
+        if ( myNbNodes <= aSize ) {
+          aVectorOfNode.resize( myNbNodes );
+          aVectorOfNode[0] = aVectorOfNode[theShift % myNbNodes];
+          aVectorOfNode[theShift % myNbNodes] = aFirstNode;
+          GetSortedNodesOnPyramid( aVectorOfNode, aResultListId );
+        }
+        break;
+      case SMDSEntity_Hexa:
+      case SMDSEntity_Quad_Hexa:
+      case SMDSEntity_TriQuad_Hexa:
+        myNbNodes = 8;
+        if ( myNbNodes <= aSize ) {
+          aVectorOfNode.resize( myNbNodes );
+          aVectorOfNode[0] = aVectorOfNode[theShift % myNbNodes];
+          aVectorOfNode[theShift % myNbNodes] = aFirstNode;
+          GetSortedNodesOnPrism( aVectorOfNode, aResultListId );
+        }
+        break;
+      case SMDSEntity_Penta:
+      case SMDSEntity_Quad_Penta:
+        myNbNodes = 6;
+        if ( myNbNodes <= aSize ) {
+          aVectorOfNode.resize( myNbNodes );
+          aVectorOfNode[0] = aVectorOfNode[theShift % myNbNodes];
+          aVectorOfNode[theShift % myNbNodes] = aFirstNode;
+          GetSortedNodesOnPrism( aVectorOfNode, aResultListId );
+        }
+        break;
+      case SMDSEntity_Hexagonal_Prism:
+        myNbNodes = 12;
+        if ( myNbNodes <= aSize ) {
+          aVectorOfNode.resize( myNbNodes );
+          aVectorOfNode[0] = aVectorOfNode[theShift % myNbNodes];
+          aVectorOfNode[theShift % myNbNodes] = aFirstNode;
+          GetSortedNodesOnPrism( aVectorOfNode, aResultListId );
+        }
+        break;
+      default:
+        myNbNodes = 2;
+      }
+    if( myNbNodes > 0 ) {
+      if ( myNbNodes <= 3 || myNbNodes > aSize || theElementType == SMDSEntity_Tetra )
+        aResultListId = aListOfId;
+      if ( myNbNodes < aSize ) {
+        if ( aResultListId.size() == 0 )
+          return 0;
+        aVectorOfNode.resize( myNbNodes );
+        aResultListId.resize( myNbNodes );
+      }
+    }
+    std::list<int>::iterator anIter = aResultListId.begin();
+
+    for( ; anIter != aResultListId.end(); anIter++ ) {
+      theName += QString(" %1").arg( *anIter );
+    }
+    if ( myNbNodes <= 3 || myNbNodes > aSize || theElementType == SMDSEntity_Tetra )
+      return aSize;
+    return aVectorOfNode.size();
+  }
   int GetNameOfSelectedNodes(SVTK_Selector* theSelector,
                              const Handle(SALOME_InteractiveObject)& theIO,
                              QString& theName)
@@ -1407,9 +1544,590 @@ namespace SMESH
     DistanceToPosition( theBounds, theNormal, theDist, theOrigin );
     return true;
   }
+  bool CreatePlaneOnThreePoints( const gp_Pnt& thePoint1,
+                                 const gp_Pnt& thePoint2,
+                                 const gp_Pnt& thePoint3,
+                                 gp_Pln& thePlane )
+  {
+    gp_Vec aVec1, aVec2;
+    aVec1 = gp_Vec( thePoint1, thePoint2 );
+    aVec2 = gp_Vec( thePoint1, thePoint3 );
+    double anAngle = aVec1.Angle( aVec2 );
+    bool isOnStraight = ( anAngle != 0 && anAngle != M_PI );
+    if ( isOnStraight ) {
+      gce_MakePln aMakePln (thePoint1, thePoint2, thePoint3);
+      if ( aMakePln.IsDone() ) {
+        thePlane = aMakePln.Value();
+      }
+    }
+    return isOnStraight;
+  }
 
+  void FindNbLowestPoint( std::list<gp_Pnt2d> theList, gp_Pnt2d& theNode )
+  {
+    std::list<gp_Pnt2d>::iterator anIter = theList.begin();
+    gp_Pnt2d aNode = gp_Pnt2d ( (*anIter).X(), (*anIter).Y());
+    for( ; anIter != theList.end(); anIter++ ) {
+      if ( (*anIter).Y() < aNode.Y() || ( (*anIter).Y() == aNode.Y() && (*anIter).X() < aNode.X() ) )
+        aNode = *anIter;
+    }
+    theNode = aNode;
+  }
+
+  static bool CompareNodeOfAngleAndDist (const TNodeOfAngleAndDist& first, const TNodeOfAngleAndDist& second )
+  {
+    if ( first.second.second == 0 )
+      return true;
+    if ( second.second.second == 0 )
+      return false;
+    if ( first.second.first == 0 && second.second.first == 0 )
+      if ( first.second.second > second.second.second )
+        return false;
+      else
+        return true;
+    if ( first.second.first < second.second.first ||
+       ( first.second.first == second.second.first && first.second.second >= second.second.second ) )
+      return true;
+    return false;
+  }
+
+  static bool CompareNodeOfDist (const TNodeOfAngleAndDist& first, const TNodeOfAngleAndDist& second )
+  {
+    if ( first.second.second < second.second.second )
+      return true;
+    return false;
+  }
+
+  static bool CompareDistOfPlane ( const TNodeOfDistToPlaneAndDist& first, const TNodeOfDistToPlaneAndDist& second )
+  {
+    if ( first.second.first == 0 && second.second.first != 0 )
+      return true;
+    if ( first.second.first != 0 && second.second.first == 0 )
+      return false;
+    if ( first.second.first < second.second.first ||
+       (  first.second.first != 0 && second.second.first != 0 &&
+          first.second.first == second.second.first && first.second.second > second.second.second ) )
+      return true;
+    return false;
+  }
+
+  static bool CompareDistOfPlaneById ( const TIdOfDistToPlaneAndDist& first, const TIdOfDistToPlaneAndDist& second )
+  {
+    if ( first.second.first == 0 && second.second.first != 0 )
+      return true;
+    if ( first.second.first != 0 && second.second.first == 0 )
+      return false;
+    if ( first.second.first < second.second.first ||
+       (  first.second.first != 0 && second.second.first != 0 &&
+          first.second.first == second.second.first && first.second.second > second.second.second ) )
+      return true;
+    return false;
+  }
+
+  static bool CompareDistForCorrectPlane ( const TNodeOfDist& first, const TNodeOfDist& second )
+  {
+    if ( first.second < second.second ) return true;
+    return false;
+  }
+
+  bool IsNotPlaneIntersection( std::vector<SMESH_TNodeXYZ>& theVector, const gp_Pln& thePlane )
+  {
+    double A, B, C, D, aCur;
+    thePlane.Coefficients(A, B, C, D);
+    int aPlus = -1;
+    for ( int i = 0 ; i < (int)theVector.size(); ++i ) {
+      aCur = A * theVector[i]._xyz[0] + B * theVector[i]._xyz[1] + C * theVector[i]._xyz[2] + D;
+      if ( aCur == 0 )
+        continue;
+      if ( aPlus == -1 && aCur != 0 )
+        aPlus = ( aCur < 0 ) ? 0 : 1;
+      if ( aPlus > -1 && aPlus != ( aCur < 0 ) ? 0 : 1 )
+        return false;
+    }
+    return true;
+  }
+
+  bool GetNextCombination ( std::vector<int>& theVector1, std::vector<int>& theVector2, int theNbPoint )
+  {
+   int aSize = (int)theVector1.size();
+   for ( int i = aSize - 1; i >= 0; --i ) {
+     if ( theVector1[i] < theNbPoint - aSize + i ) {
+       ++theVector1[i];
+       for ( int j = i + 1; j < aSize; ++j )
+         theVector1[j] = theVector1[j-1] + 1;
+       int it = 0;
+       int it2 = 0;
+       bool isVec;
+       for ( int k = 0; k < theNbPoint; ++k ) {
+         isVec = false;
+         if( it < aSize ) {
+           if( k == theVector1[it] ) {
+             isVec = true;
+             ++it;
+           }
+         }
+         if ( isVec )
+           continue;
+         theVector2[it2] = k;
+         it2++;
+         if ( it2 == (int)theVector2.size() )
+           break;
+       }
+       return true;
+     }
+   }
+     return false;
+  }
+
+  bool Get2BasePlane( std::vector<SMESH_TNodeXYZ>& theVector,
+                      std::vector<SMESH_TNodeXYZ>& thePlane1,
+                      std::vector<SMESH_TNodeXYZ>& thePlane2 )
+  {
+    int aSize = (int)theVector.size() / 2;
+    if ( aSize < 3 || (int)theVector.size() % 2 != 0 )
+      return false;
+    int anArr1[3];
+    int anArr2[2 * aSize - 3];
+    for (int i = 0; i < 3 ; i++) {
+      anArr1[i] = i;
+    }
+    for (int i = 0; i < 2 * aSize - 3 ; i++) {
+      anArr2[i] = i + 3;
+    }
+    int aNbSwapFirstPoint = 0;
+    while ( thePlane1.empty() && thePlane2.empty() && aNbSwapFirstPoint < aSize * 2 ) {
+      std::vector<int> anIndexPlane1( anArr1, anArr1 + 3 );
+      std::vector<int> anIndexPlane2( anArr2, anArr2 + 2 * aSize - 3);
+      int aNbCombination = 0;
+      double aMax = 0;
+      double aSumMin = -1;
+      int aMaxCombination = 0;
+      thePlane1.clear();
+      thePlane2.clear();
+      for (int i = 1; i < 2 * aSize - 1; i++ ) {
+        aMaxCombination += i;
+      }
+      while ( aNbCombination < aMaxCombination ) {
+        gp_Pln aPlane;
+        double aSumMinDist1 = 0;
+        double aSumMinDist2 = 0;
+        std::vector<SMESH_TNodeXYZ> aVectorOfPoint;
+        for(int i = 0; i < 2 * aSize - 3; i++) {
+          aVectorOfPoint.push_back(theVector[anIndexPlane2[i]]);
+        }
+        bool isCorrectPlane = false;
+        bool isCreatePlane = CreatePlaneOnThreePoints( gp_Pnt(theVector[anIndexPlane1[0]]._xyz[0], theVector[anIndexPlane1[0]]._xyz[1], theVector[anIndexPlane1[0]]._xyz[2]),
+            gp_Pnt(theVector[anIndexPlane1[1]]._xyz[0], theVector[anIndexPlane1[1]]._xyz[1], theVector[anIndexPlane1[1]]._xyz[2]),
+            gp_Pnt(theVector[anIndexPlane1[2]]._xyz[0], theVector[anIndexPlane1[2]]._xyz[1], theVector[anIndexPlane1[2]]._xyz[2]),
+            aPlane );
+        if ( isCreatePlane ) {
+          isCorrectPlane = IsNotPlaneIntersection( aVectorOfPoint, aPlane );
+        }
+        if ( !isCorrectPlane ) {
+          GetNextCombination( anIndexPlane1, anIndexPlane2, 2*aSize );
+          aNbCombination++;
+          continue;
+        }
+        std::vector<int> anIndexCorrectPlane1;
+        std::vector<int> anIndexCorrectPlane2;
+        if ( aSize == 3 ) {
+          for (int i = 0; i < aSize ; i++) {
+            anIndexCorrectPlane1.push_back( anIndexPlane1[i] );
+            anIndexCorrectPlane2.push_back( anIndexPlane2[i] );
+          }
+        }
+        if ( aSize >= 4 ) {
+          std::list<TIdOfDistToPlaneAndDist> aListBaseOfPoint;
+          TIdOfDistToPlaneAndDist aCurDistOfPlane;
+          for (int i = 0; i < 2 * aSize - 3; i++ ) {
+            aCurDistOfPlane.second.first = aPlane.Distance( gp_Pnt( theVector[anIndexPlane2[i]]._xyz[0], theVector[anIndexPlane2[i]]._xyz[1], theVector[anIndexPlane2[i]]._xyz[2] ));
+            if ( aCurDistOfPlane.second.first == 0 )
+              aCurDistOfPlane.second.second = 0;
+            else {
+              double aCurDist = 0;
+              for (int j = 0; j < 3; j++) {
+                aCurDist += pow( theVector[anIndexPlane1[j]]._xyz[0] - theVector[anIndexPlane2[i]]._xyz[0], 2.0 ) +
+                    pow( theVector[anIndexPlane1[j]]._xyz[1] - theVector[anIndexPlane2[i]]._xyz[1], 2.0 ) +
+                    pow( theVector[anIndexPlane1[j]]._xyz[2] - theVector[anIndexPlane2[i]]._xyz[2], 2.0 );
+              }
+              aCurDistOfPlane.second.second = aCurDist;
+            }
+            aCurDistOfPlane.first = anIndexPlane2[i];
+            aListBaseOfPoint.push_back( aCurDistOfPlane );
+          }
+          aListBaseOfPoint.sort( CompareDistOfPlaneById );
+          std::list<TIdOfDistToPlaneAndDist>::iterator anIterDist = aListBaseOfPoint.begin();
+          for (int i = 0; i < 3; i++) {
+            anIndexCorrectPlane1.push_back( anIndexPlane1[i] );
+          }
+          for (int i = 0; i < aSize - 3; i++, anIterDist++) {
+            anIndexCorrectPlane1.push_back((*anIterDist).first);
+          }
+          for (int i = 0; i < 2 * aSize - 3 ; i++) {
+            anIterDist = aListBaseOfPoint.begin();
+            bool isFinded = false;
+            for (int j = 0; j < aSize - 3; j++, anIterDist++) {
+              if ( anIndexPlane2[i] == (*anIterDist).first ) {
+                isFinded = true;
+                break;
+              }
+            }
+            if ( !isFinded )
+              anIndexCorrectPlane2.push_back( anIndexPlane2[i] );
+          }
+        }
+        double aCurDist1, aCurDist2, aMinDist1, aMinDist2, aSumDist1, aSumDist2, aSumDistBase1, aSumDistBase2;
+        bool isCorrect2Base = true;
+        aSumDist1 = aSumDistBase1 = aSumDist2 = aSumDistBase2 = 0;
+        for( int i = 0 ; i < aSize ; i++ ) {
+          aMinDist1 = 0;
+          aMinDist2 = 0;
+          for(int j = 0 ; j < aSize ; j++ ) {
+            aCurDist1 = pow( theVector[anIndexCorrectPlane1[i]]._xyz[0] - theVector[anIndexCorrectPlane2[j]]._xyz[0], 2.0 ) +
+                pow( theVector[anIndexCorrectPlane1[i]]._xyz[1] - theVector[anIndexCorrectPlane2[j]]._xyz[1], 2.0 ) +
+                pow( theVector[anIndexCorrectPlane1[i]]._xyz[2] - theVector[anIndexCorrectPlane2[j]]._xyz[2], 2.0 );
+            aCurDist2 = pow( theVector[anIndexCorrectPlane1[j]]._xyz[0] - theVector[anIndexCorrectPlane2[i]]._xyz[0], 2.0 ) +
+                pow( theVector[anIndexCorrectPlane1[j]]._xyz[1] - theVector[anIndexCorrectPlane2[i]]._xyz[1], 2.0 ) +
+                pow( theVector[anIndexCorrectPlane1[j]]._xyz[2] - theVector[anIndexCorrectPlane2[i]]._xyz[2], 2.0 );
+            aSumDistBase1 += pow( theVector[anIndexCorrectPlane1[i]]._xyz[0] - theVector[anIndexCorrectPlane1[j]]._xyz[0], 2.0 ) +
+                pow( theVector[anIndexCorrectPlane1[i]]._xyz[1] - theVector[anIndexCorrectPlane1[j]]._xyz[1], 2.0 ) +
+                pow( theVector[anIndexCorrectPlane1[i]]._xyz[2] - theVector[anIndexCorrectPlane1[j]]._xyz[2], 2.0 );
+            aSumDistBase2 += pow( theVector[anIndexCorrectPlane2[i]]._xyz[0] - theVector[anIndexCorrectPlane2[j]]._xyz[0], 2.0 ) +
+                pow( theVector[anIndexCorrectPlane2[i]]._xyz[1] - theVector[anIndexCorrectPlane2[j]]._xyz[1], 2.0 ) +
+                pow( theVector[anIndexCorrectPlane2[i]]._xyz[2] - theVector[anIndexCorrectPlane2[j]]._xyz[2], 2.0 );
+            if ( aCurDist1 < aMinDist1 || aMinDist1 == 0)
+              aMinDist1 = aCurDist1;
+            if ( aCurDist2 < aMinDist2 || aMinDist2 == 0)
+              aMinDist2 = aCurDist2;
+            aSumDist1 += aCurDist1;
+            aSumDist2 += aCurDist2;
+          }
+          aSumMinDist1 += aMinDist1;
+          aSumDist1 -= aMinDist1;
+          aSumMinDist2 += aMinDist2;
+          aSumDist2 -= aMinDist2;
+        }
+        isCorrect2Base = ( aSumDistBase1 + aSumDistBase2 <= aSumDist1 + aSumDist2 );
+        if ( isCorrect2Base && ( aSumMinDist1 == aSumMinDist2 || ( aSumMinDist1 + aSumMinDist2 )  > aMax || aMax == 0 ||
+            ( (aSumMinDist1 + aSumMinDist2 ) == aMax && ( (aSumDist1 + aSumDist2 - aSumDistBase1 - aSumDistBase2) < aSumMin || aSumMin == -1 ) ) ) ) {
+          aMax = aSumMinDist1 + aSumMinDist2;
+          aSumMin = aSumDist1 + aSumDist2 - aSumDistBase1 - aSumDistBase2;
+          thePlane1.clear();
+          thePlane2.clear();
+          for(int i = 0; i < aSize; i++) {
+            thePlane1.push_back(theVector[anIndexCorrectPlane1[i]]);
+            thePlane2.push_back(theVector[anIndexCorrectPlane2[i]]);
+          }
+        }
+        if ( aSumMinDist1 == aSumMinDist2 )
+          break;
+        if ( !GetNextCombination( anIndexPlane1, anIndexPlane2, 2 * aSize) )
+          break;
+        aNbCombination++;
+      }
+      if ( thePlane1.empty() && thePlane2.empty() ) {
+        aNbSwapFirstPoint++;
+        SMESH_TNodeXYZ aPoint;
+        aPoint = theVector[0];
+        theVector[0] = theVector[aNbSwapFirstPoint];
+        theVector[aNbSwapFirstPoint] = aPoint;
+      }
+    }
+    if ( thePlane1.empty() && thePlane2.empty() )
+      return false;
+    return true;
+  }
+
+  bool GetCorrectSequenceOfId( std::vector<SMESH_TNodeXYZ>& theVector )
+  {
+    std::list<gp_Pnt2d> aListProjection;
+    gp_Pnt2d aCurPoint;
+    int aSize = (int)theVector.size();
+    if ( aSize < 3 )
+      return false;
+    gp_Pln aPlane;
+    bool isCreatePlane = false;
+    for (int i = 0; i < aSize - 1; i++ ) {
+      isCreatePlane = CreatePlaneOnThreePoints( gp_Pnt( theVector[i]._xyz[0], theVector[i]._xyz[1], theVector[i]._xyz[2] ),
+                                                gp_Pnt( theVector[i+1]._xyz[0], theVector[i+1]._xyz[1], theVector[i+1]._xyz[2] ),
+                                                gp_Pnt( theVector[i+2]._xyz[0], theVector[i+2]._xyz[1], theVector[i+2]._xyz[2] ), aPlane );
+      if ( isCreatePlane)
+        break;
+    }
+    if ( !isCreatePlane )
+      return false;
+    for ( int i = 0; i < aSize; i++) {
+      aCurPoint = ProjLib::Project( aPlane, gp_Pnt( theVector[i]._xyz[0], theVector[i]._xyz[1], theVector[i]._xyz[2] ));
+      aListProjection.push_back( aCurPoint );
+    }
+    std::list<TNodeOfAngleAndDist> aListIdOfAngleAndDist;
+    TNodeOfAngleAndDist aCurIdOfAngleAndDist;
+    FindNbLowestPoint( aListProjection, aCurPoint);
+    std::list<gp_Pnt2d>::iterator anIter2d = aListProjection.begin();
+    gp_Vec2d aCurVec;
+    gp_Vec2d aAxisVec = gp_Vec2d( 1, 0 );
+    for( int i = 0 ; anIter2d != aListProjection.end(); anIter2d++, i++) {
+      aCurVec = gp_Vec2d( (*anIter2d).X() - aCurPoint.X(), (*anIter2d).Y() - aCurPoint.Y() );
+      aCurIdOfAngleAndDist.first = theVector[i];
+      if ( (*anIter2d).X() == aCurPoint.X() && (*anIter2d).Y() == aCurPoint.Y() )
+        aCurIdOfAngleAndDist.second.first = 0;
+      else {
+        double anAngle = aAxisVec.Angle( aCurVec );
+        double anRoundAngle = anAngle * 100000;
+        int anIntAngle = anRoundAngle + 0.5;
+        anRoundAngle = (double) anIntAngle / 100000;
+        aCurIdOfAngleAndDist.second.first = anRoundAngle;
+      }
+      aCurIdOfAngleAndDist.second.second = pow( (*anIter2d).X() - aCurPoint.X(), 2.0 ) +
+                                           pow( (*anIter2d).Y() - aCurPoint.Y(), 2.0 ) +
+                                           pow( aPlane.Distance( gp_Pnt( theVector[i]._xyz[0], theVector[i]._xyz[1], theVector[i]._xyz[2] )), 2.0 );
+      aListIdOfAngleAndDist.push_back( aCurIdOfAngleAndDist );
+    }
+    aListIdOfAngleAndDist.sort( CompareNodeOfAngleAndDist );
+    std::list<TNodeOfAngleAndDist>::iterator anIter = aListIdOfAngleAndDist.begin();
+    std::list<TNodeOfAngleAndDist> aListResult;
+    double anAngle = 0;
+    bool isSort = true;
+    for(int i = 0 ; anIter != aListIdOfAngleAndDist.end(); anIter++, i++) {
+      if ( anAngle == (*anIter).second.first && anAngle != 0 ) {
+        isSort = false;
+        break;
+      }
+      if ( ( anAngle > (*anIter).second.first && anAngle != 0 ) || i > 1)
+        break;
+      if ( (*anIter).second.first > 0 )
+        anAngle = (*anIter).second.first;
+    }
+    if ( !isSort ) {
+      anIter = aListIdOfAngleAndDist.begin();
+      for( ; anIter != aListIdOfAngleAndDist.end(); anIter++) {
+        if ( anAngle == (*anIter).second.first)
+          aListResult.push_back( *anIter );
+        else if ( anAngle < (*anIter).second.first)
+          break;
+      }
+    }
+    else
+      anAngle = 0;
+    aListResult.sort(CompareNodeOfDist);
+    anIter = aListIdOfAngleAndDist.begin();
+    theVector.clear();
+    for( ; anIter != aListIdOfAngleAndDist.end(); anIter++) {
+      if ( !isSort && anAngle == (*anIter).second.first ){
+        for( std::list<TNodeOfAngleAndDist>::iterator anIter2 = aListResult.begin() ; anIter2 != aListResult.end(); anIter2++) {
+          theVector.push_back((*anIter2).first);
+        }
+        isSort = true;
+      }
+      if ( isSort && anAngle != 0 && anAngle == (*anIter).second.first )
+        continue;
+      theVector.push_back((*anIter).first);
+    }
+
+    return true;
+}
+
+  void GetCorrectSequenceTwoPlaneOfId( std::vector<SMESH_TNodeXYZ>& thePlane1, std::vector<SMESH_TNodeXYZ>& thePlane2, std::list<int>& theResultListId )
+  {
+    int anIndex1, anIndex2, aShift = 0;
+    double aCurSum;
+    std::pair<int, double> aShiftOfDist;
+    int aSize = (int)thePlane1.size();
+    aShiftOfDist.first = aShiftOfDist.second = 0;
+    int anArr1[3];
+    int anArr2[aSize - 3];
+    for (int i = 0; i < 3 ; i++) {
+      anArr1[i] = i;
+    }
+    for (int i = 0; i < aSize - 3 ; i++) {
+      anArr2[i] = i + 3;
+    }
+    std::vector<int> anIndexPlane1( anArr1, anArr1 + 3 );
+    std::vector<int> anIndexPlane2( anArr2, anArr2 + aSize - 3);
+    std::vector<int> anIndexCorrectPlane;
+    std::vector<SMESH_TNodeXYZ> theNewPlane;
+    std::vector<SMESH_TNodeXYZ> theCorrectPlane;
+
+    GetCorrectSequenceOfId ( thePlane1 );
+
+    while( true ) {
+      anIndexCorrectPlane.clear();
+      std::vector<SMESH_TNodeXYZ> theNewPlane;
+      for (int i = 0; i < 3; i++) {
+        anIndexCorrectPlane.push_back( anIndexPlane1[i] );
+      }
+      for (int i = 0; i < aSize - 3; i++) {
+        anIndexCorrectPlane.push_back( anIndexPlane2[i] );
+      }
+      for (int i = 0; i < aSize; i++) {
+        theNewPlane.push_back( thePlane2[anIndexCorrectPlane[i]] );
+      }
+      aShift = 0;
+      if ( GetCorrectSequenceOfId ( theNewPlane ) )
+      {
+        std::vector<double> aVectorSum;
+        while ( aShift != 2 * aSize ) {
+          anIndex1 = 0;
+          aCurSum = 0;
+          ( aShift < aSize ) ? anIndex2 = 0 : anIndex2 = aSize - 1;
+          while ( ( aShift < aSize && anIndex2 < aSize ) || ( aShift >= aSize && anIndex2 >= 0 ) ) {
+            aCurSum += pow( thePlane1[anIndex1]._xyz[0] - theNewPlane[ ( anIndex2 + aShift ) % aSize ]._xyz[0], 2.0 ) +
+                       pow( thePlane1[anIndex1]._xyz[1] - theNewPlane[ ( anIndex2 + aShift ) % aSize ]._xyz[1], 2.0 ) +
+                       pow( thePlane1[anIndex1]._xyz[2] - theNewPlane[ ( anIndex2 + aShift ) % aSize ]._xyz[2], 2.0 );
+            ( aShift < aSize ) ? anIndex2++ : anIndex2--;
+            anIndex1++;
+          }
+          aVectorSum.push_back( aCurSum );
+          aShift++;
+        }
+        double aCurSumMin = 0;
+        std::pair<int, double> aCurShiftOfDist;
+        aCurShiftOfDist.first = aCurShiftOfDist.second = 0;
+        for ( int i = 0; i < (int)aVectorSum.size(); i++ ) {
+          if ( aVectorSum[i] < aCurShiftOfDist.second || aCurShiftOfDist.second == 0 ) {
+            aCurShiftOfDist.first = i;
+            aCurShiftOfDist.second = aVectorSum[i];
+          }
+        }
+        if ( aCurShiftOfDist.second <= aShiftOfDist.second || aShiftOfDist.second == 0){
+          aShiftOfDist = aCurShiftOfDist;
+          theCorrectPlane = theNewPlane;
+        }
+      }
+      if ( !GetNextCombination( anIndexPlane1, anIndexPlane2, aSize) )
+        break;
+    }
+    thePlane2 = theCorrectPlane;
+    aShift = aShiftOfDist.first;
+    anIndex1 = 0;
+    theResultListId.clear();
+    ( aShift < aSize ) ? anIndex2 = 0 : anIndex2 = aSize - 1;
+    while ( anIndex1 != aSize ) {
+      theResultListId.push_back(thePlane1[anIndex1]._node->GetID());
+      anIndex1++;
+    }
+    while ( ( aShift < aSize && anIndex2 < aSize ) || ( aShift >= aSize && anIndex2 >= 0 ) ) {
+      theResultListId.push_back( thePlane2[( anIndex2 + aShift ) % aSize]._node->GetID() );
+      ( aShift < aSize ) ? anIndex2++ : anIndex2--;
+    }
+  }
+
+  void GetSortedNodesOnPolygon( std::vector<SMESH_TNodeXYZ>& theVectorOfNode, std::list<int>& theResultListId )
+  {
+    GetCorrectSequenceOfId ( theVectorOfNode );
+    for (int i = 0; i < theVectorOfNode.size(); i++) {
+      theResultListId.push_back( theVectorOfNode[i]._node->GetID() );
+    }
+  }
+
+  void GetSortedNodesOnPrism( std::vector<SMESH_TNodeXYZ>& theVectorOfNode, std::list<int>& theResultListId )
+  {
+    int aSize = (int)theVectorOfNode.size();
+    if ( aSize < 6 && aSize % 2 == 0)
+      return;
+    std::vector<SMESH_TNodeXYZ> aPlane1, aPlane2;
+    if ( Get2BasePlane( theVectorOfNode, aPlane1, aPlane2 ) ) {
+      GetCorrectSequenceTwoPlaneOfId( aPlane1, aPlane2, theResultListId);
+    }
+  }
+
+  void GetSortedNodesOnPyramid( std::vector<SMESH_TNodeXYZ>& theVectorOfNode, std::list<int>& theResultListId )
+  {
+    int aSize = (int)theVectorOfNode.size();
+    if ( aSize < 5 )
+      return;
+    gp_Pln aPlane;
+    bool isCreatePlane, isCorrectPlane;
+    int aNumPlane = 0;
+    double aMax = 0;
+    while ( aNumPlane != aSize ) {
+      isCreatePlane = CreatePlaneOnThreePoints( gp_Pnt( theVectorOfNode[aNumPlane]._xyz[0], theVectorOfNode[aNumPlane]._xyz[1], theVectorOfNode[aNumPlane]._xyz[2] ),
+                                                gp_Pnt( theVectorOfNode[(aNumPlane + 1) % aSize]._xyz[0], theVectorOfNode[(aNumPlane + 1) % aSize]._xyz[1], theVectorOfNode[(aNumPlane + 1) % aSize]._xyz[2] ),
+                                                gp_Pnt( theVectorOfNode[(aNumPlane + 2) % aSize]._xyz[0], theVectorOfNode[(aNumPlane + 2) % aSize]._xyz[1], theVectorOfNode[(aNumPlane + 2) % aSize]._xyz[2] ), aPlane );
+      isCorrectPlane = false;
+      std::vector<SMESH_TNodeXYZ> aVectorOfPoint;
+      if ( isCreatePlane ) {
+        for(int j = 0; j < aSize - 3; j++) {
+          aVectorOfPoint.push_back(theVectorOfNode[(aNumPlane + j + 3) % aSize]);
+        }
+        isCorrectPlane = IsNotPlaneIntersection( aVectorOfPoint, aPlane );
+      }
+      if ( !isCorrectPlane ) {
+       aNumPlane++;
+       continue;
+      }
+      std::vector<SMESH_TNodeXYZ> aVectorBaseOfPoint;
+      std::list<TNodeOfDistToPlaneAndDist> aListBaseOfPoint;
+      TNodeOfDistToPlaneAndDist aCurDistOfPlane;
+      aListBaseOfPoint.clear();
+      for (int i = 0; i < aSize; i++ ) {
+        aCurDistOfPlane.second.first = aPlane.Distance( gp_Pnt( theVectorOfNode[i]._xyz[0], theVectorOfNode[i]._xyz[1], theVectorOfNode[i]._xyz[2] ));
+        if ( aCurDistOfPlane.second.first == 0 )
+          aCurDistOfPlane.second.second = 0;
+        else {
+          double aCurDist = 0;
+          for (int j = 0; j < 3; j++) {
+            aCurDist += pow( theVectorOfNode[(aNumPlane + j) % aSize]._xyz[0] - theVectorOfNode[i]._xyz[0], 2.0 ) +
+                        pow( theVectorOfNode[(aNumPlane + j) % aSize]._xyz[1] - theVectorOfNode[i]._xyz[1], 2.0 ) +
+                        pow( theVectorOfNode[(aNumPlane + j) % aSize]._xyz[2] - theVectorOfNode[i]._xyz[2], 2.0 );
+          }
+          aCurDistOfPlane.second.second = aCurDist;
+        }
+        aCurDistOfPlane.first = theVectorOfNode[i];
+        aListBaseOfPoint.push_back( aCurDistOfPlane );
+      }
+      aListBaseOfPoint.sort( CompareDistOfPlane );
+      std::list<TNodeOfDistToPlaneAndDist>::iterator anIterDist = aListBaseOfPoint.begin();
+      for (; anIterDist != aListBaseOfPoint.end(); anIterDist++ ) {
+        aVectorBaseOfPoint.push_back((*anIterDist).first);
+      }
+      SMESH_TNodeXYZ aTopNode = aVectorBaseOfPoint.back();
+      aVectorBaseOfPoint.resize( aVectorBaseOfPoint.size() - 1);
+      double aCur = 0;
+      double aSum = 0;
+      std::list<TNodeOfDist> aListBaseCorrect;
+      for (int i = 0; i < aSize - 1; i++) {
+        aCur =  pow( aVectorBaseOfPoint[i]._xyz[0] - aTopNode._xyz[0], 2.0 ) +
+                pow( aVectorBaseOfPoint[i]._xyz[1] - aTopNode._xyz[1], 2.0 ) +
+                pow( aVectorBaseOfPoint[i]._xyz[2] - aTopNode._xyz[2], 2.0 );
+        aListBaseCorrect.push_back(std::make_pair(aVectorBaseOfPoint[i], aCur) );
+      }
+      bool isCorrectTop = true;
+      for (int i = 0; i < aSize - 1; i++) {
+        isCreatePlane = CreatePlaneOnThreePoints( gp_Pnt( aVectorBaseOfPoint[i]._xyz[0], aVectorBaseOfPoint[i]._xyz[1], aVectorBaseOfPoint[i]._xyz[2] ),
+                                                  gp_Pnt( aVectorBaseOfPoint[(i+1) % (aSize - 1)]._xyz[0], aVectorBaseOfPoint[(i+1) % (aSize - 1)]._xyz[1], aVectorBaseOfPoint[(i+1) % (aSize - 1)]._xyz[2] ),
+                                                  gp_Pnt( aVectorBaseOfPoint[(i+2) % (aSize - 1)]._xyz[0], aVectorBaseOfPoint[(i+2) % (aSize - 1)]._xyz[1], aVectorBaseOfPoint[(i+2) % (aSize - 1)]._xyz[2] ), aPlane );
+        if ( isCreatePlane ) {
+          aCur = aPlane.Distance( gp_Pnt( aTopNode._xyz[0], aTopNode._xyz[1], aTopNode._xyz[2] ));
+          if ( aCur == 0 ) {
+            isCorrectTop = false;
+            continue;
+          }
+          aSum += aCur;
+        }
+      }
+      aNumPlane++;
+      if ( ( isCorrectTop || aSum == 0 ) && ( aMax == 0 || aSum > aMax ) ) {
+        aListBaseCorrect.sort(CompareDistForCorrectPlane);
+        aVectorBaseOfPoint.clear();
+        std::list<TNodeOfDist>::iterator anIter = aListBaseCorrect.begin();
+        for ( ; anIter != aListBaseCorrect.end(); anIter++) {
+          aVectorBaseOfPoint.push_back((*anIter).first);
+        }
+        GetCorrectSequenceOfId( aVectorBaseOfPoint );
+        aMax = aSum;
+        theResultListId.clear();
+        for (int i = 0; i < aVectorBaseOfPoint.size(); i++) {
+          theResultListId.push_back( aVectorBaseOfPoint[i]._node->GetID() );
+        }
+        theResultListId.push_back( aTopNode._node->GetID() );
+        if ( aSum == 0 )
+          break;
+      }
+    }
+  }
   bool ComputeBounds( std::list<vtkActor*> theActorList,
-                      double theBounds[6])
+      double theBounds[6])
   {
     bool anIsOk = false;
     theBounds[0] = theBounds[2] = theBounds[4] = VTK_DOUBLE_MAX;

src/SMESHGUI/SMESHGUI_VTKUtils.h

@@ -29,8 +29,11 @@
 
 // SMESH includes
 #include "SMESH_SMESHGUI.hxx"
+#include "SMESH_TypeDefs.hxx"
+#include "SMDS_MeshNode.hxx"
 
 #include "SMESHGUI_Utils.h"
+
 #include <SMESH_Object.h>
 
 // SALOME KERNEL includes
@@ -58,7 +61,15 @@ class SMESH_Actor;
 class SALOME_Actor;
 
 class vtkActor;
-
+class SMDS_Mesh;
+class SMDS_MeshNode;
+class gp_Pln;
+class gp_Lin;
+class gp_Dir;
+class gp_Pnt2d;
+class gp_Vec2d;
+class Handle(Geom_Line);
+class Handle(Geom_Plane);
 namespace SMESH
 {
   //----------------------------------------------------------------------------
@@ -161,6 +172,12 @@ SMESHGUI_EXPORT
 
   //----------------------------------------------------------------------------
 SMESHGUI_EXPORT  
+  int GetNameOfSelectedSortedNodes( SMDSAbs_EntityType,
+                                    SVTK_Selector*,
+                                    SMESH_Actor*,
+                                    int,
+                                    QString& );
+SMESHGUI_EXPORT
   int GetNameOfSelectedNodes( SVTK_Selector*,
                               const Handle(SALOME_InteractiveObject)&,
                               QString& );
@@ -214,6 +231,44 @@ SMESHGUI_EXPORT
                            double theDirection[3],
                            double thePos[3],
                            double& theDist );
+  typedef std::pair<SMESH_TNodeXYZ, double> TNodeOfDist;
+  typedef std::pair<SMESH_TNodeXYZ, std::pair<double, double> > TNodeOfAngleAndDist, TNodeOfDistToPlaneAndDist;
+  typedef std::pair<int, std::pair<double, double> > TIdOfDistToPlaneAndDist;
+  bool CreatePlaneOnThreePoints( const gp_Pnt& thePoint1,
+                                 const gp_Pnt& thePoint2,
+                                 const gp_Pnt& thePoint3,
+                                 gp_Pln& thePlane );
+
+  void FindNbLowestPoint( std::list<gp_Pnt2d> theList, gp_Pnt2d& theNode );
+  bool IsNotPlaneIntersection( std::vector<SMESH_TNodeXYZ>& theVector,
+                               const gp_Pln& thePlane );
+  bool GetCorrectSequenceOfId( std::vector<SMESH_TNodeXYZ>& theVector );
+  void GetCorrectSequenceTwoPlaneOfId( std::vector<SMESH_TNodeXYZ>& thePlane1,
+                                       std::vector<SMESH_TNodeXYZ>& thePlane2,
+                                       std::list<int>& theResultListId );
+  void GetSortedNodesOnPolygon( std::vector<SMESH_TNodeXYZ>& theVectorOfNode,
+                                std::list<int>& theResultListId );
+  void GetSortedNodesOnPyramid( std::vector<SMESH_TNodeXYZ>& theVectorOfNode,
+                                std::list<int>& theResultListId );
+  void GetSortedNodesOnPrism( std::vector<SMESH_TNodeXYZ>& theVectorOfNode,
+                              std::list<int>& theResultListId );
+  bool Get2BasePlane( std::vector<SMESH_TNodeXYZ>& theVector,
+                      std::vector<SMESH_TNodeXYZ>& thePlane1,
+                      std::vector<SMESH_TNodeXYZ>& thePlane2);
+  bool GetNextCombination ( std::vector<int> & theVector1,
+                            std::vector<int> & theVector2,
+                            int theNbPoint );
+  static bool CompareNodeOfAngleAndDist ( const TNodeOfAngleAndDist& first,
+                                          const TNodeOfAngleAndDist& second );
+  static bool CompareNodeOfDist ( const TNodeOfAngleAndDist& first,
+                                  const TNodeOfAngleAndDist& second );
+  static bool CompareDistOfPlane ( const TNodeOfDistToPlaneAndDist& first,
+                                   const TNodeOfDistToPlaneAndDist& second );
+  static bool CompareDistOfPlaneById ( const TIdOfDistToPlaneAndDist& first,
+                                       const TIdOfDistToPlaneAndDist& second );
+  static bool CompareDistForCorrectPlane ( const TNodeOfDist& first,
+                                           const TNodeOfDist& second );
+
  SMESHGUI_EXPORT
    void RemoveVisualObjectWithActors( const char* theEntry, bool fromAllViews = false );
 };

src/SMESHGUI/SMESH_msg_en.ts

@@ -1321,6 +1321,10 @@ Please enter correct values and try again</translation>
         <source>SMESH_AUTO_DIM</source>
         <translation>Automatically define space dimension</translation>
     </message>
+    <message>
+        <source>SMESH_AUTOMATIC_PRESENTATION</source>
+        <translation>Random input ID</translation>
+    </message>
     <message>
         <source>SMESH_REQUIRED_GROUPS</source>
         <translation>Create groups of required entities</translation>
@@ -1417,6 +1421,10 @@ Please enter correct values and try again</translation>
         <source>SMESH_BUT_APPLY_AND_CLOSE</source>
         <translation>A&amp;pply and Close</translation>
     </message>
+    <message>
+        <source>SMESH_BUT_GET_NEXT_SHAPE</source>
+        <translation>Get next shape</translation>
+    </message>
     <message>
         <source>SMESH_BUT_REMOVE</source>
         <translation>&amp;Remove</translation>

src/SMESHGUI/SMESH_msg_fr.ts

@@ -1321,6 +1321,10 @@ Merci de les corriger, puis essayez de nouveau</translation>
         <source>SMESH_AUTO_DIM</source>
         <translation>Définition automatique des dimensions spatiales</translation>
     </message>
+    <message>
+        <source>SMESH_AUTOMATIC_PRESENTATION</source>
+        <translation type="unfinished">Random input ID</translation>
+    </message>
     <message>
         <source>SMESH_REQUIRED_GROUPS</source>
         <translation>Créer les groupes des types nécessaires</translation>
@@ -1417,6 +1421,10 @@ Merci de les corriger, puis essayez de nouveau</translation>
         <source>SMESH_BUT_APPLY_AND_CLOSE</source>
         <translation>App&amp;liquer et fermer</translation>
     </message>
+    <message>
+        <source>SMESH_BUT_GET_NEXT_SHAPE</source>
+        <translation type="unfinished">Get next shape</translation>
+    </message>
     <message>
         <source>SMESH_BUT_REMOVE</source>
         <translation>S&amp;upprimer</translation>

src/SMESHGUI/SMESH_msg_ja.ts

@@ -1315,6 +1315,10 @@
       <source>SMESH_AUTO_DIM</source>
       <translation>自動的に空間の寸法を定義します。</translation>
     </message>
+    <message>
+        <source>SMESH_AUTOMATIC_PRESENTATION</source>
+        <translation type="unfinished">Random input ID</translation>
+    </message>
     <message>
       <source>SMESH_REQUIRED_GROUPS</source>
       <translation>必要な種類のグループを作成します。</translation>
@@ -1411,6 +1415,10 @@
       <source>SMESH_BUT_APPLY_AND_CLOSE</source>
       <translation>適用して閉じる(&amp;p)</translation>
     </message>
+    <message>
+        <source>SMESH_BUT_GET_NEXT_SHAPE</source>
+        <translation type="unfinished">Get next shape</translation>
+    </message>
     <message>
       <source>SMESH_BUT_REMOVE</source>
       <translation>削除(&amp;R)</translation>