Salome HOME
GPUSPHGUI: add Offset transformation
authoreap <eap@opencascade.com>
Fri, 9 Feb 2018 19:41:01 +0000 (22:41 +0300)
committereap <eap@opencascade.com>
Fri, 9 Feb 2018 19:41:01 +0000 (22:41 +0300)
54 files changed:
idl/SMESH_MeshEditor.idl
resources/CMakeLists.txt
src/DriverSTL/DriverSTL_W_SMDS_Mesh.cxx
src/SMDS/SMDS_Mesh.hxx
src/SMDS/SMDS_PolygonalFaceOfNodes.hxx
src/SMDS/SMDS_StdIterator.hxx
src/SMESH/SMESH_MeshEditor.cxx
src/SMESH/SMESH_MeshEditor.hxx
src/SMESH/SMESH_MesherHelper.cxx
src/SMESHGUI/CMakeLists.txt
src/SMESHGUI/SMESHGUI.cxx
src/SMESHGUI/SMESHGUI_AddMeshElementDlg.cxx
src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx
src/SMESHGUI/SMESHGUI_CopyMeshDlg.cxx
src/SMESHGUI/SMESHGUI_CreatePolyhedralVolumeDlg.cxx
src/SMESHGUI/SMESHGUI_ExtrusionDlg.cxx
src/SMESHGUI/SMESHGUI_FindElemByPointDlg.cxx
src/SMESHGUI/SMESHGUI_MeshInfo.cxx
src/SMESHGUI/SMESHGUI_MeshPatternDlg.cxx
src/SMESHGUI/SMESHGUI_MultiEditDlg.cxx
src/SMESHGUI/SMESHGUI_OffsetDlg.cxx [new file with mode: 0644]
src/SMESHGUI/SMESHGUI_Operations.h
src/SMESHGUI/SMESHGUI_RemoveElementsDlg.cxx
src/SMESHGUI/SMESHGUI_RemoveNodesDlg.cxx
src/SMESHGUI/SMESHGUI_RotationDlg.cxx
src/SMESHGUI/SMESHGUI_ScaleDlg.cxx
src/SMESHGUI/SMESHGUI_SelectionOp.cxx
src/SMESHGUI/SMESHGUI_SelectionOp.h
src/SMESHGUI/SMESHGUI_SewingDlg.cxx
src/SMESHGUI/SMESHGUI_SingleEditDlg.cxx
src/SMESHGUI/SMESHGUI_SmoothingDlg.cxx
src/SMESHGUI/SMESHGUI_SymmetryDlg.cxx
src/SMESHGUI/SMESHGUI_TranslationDlg.cxx
src/SMESHGUI/SMESH_images.ts
src/SMESHGUI/SMESH_msg_en.ts
src/SMESHGUI/SMESH_msg_fr.ts
src/SMESHGUI/SMESH_msg_ja.ts
src/SMESHUtils/CMakeLists.txt
src/SMESHUtils/SMESH_MAT2d.hxx
src/SMESHUtils/SMESH_MeshAlgos.cxx
src/SMESHUtils/SMESH_MeshAlgos.hxx
src/SMESHUtils/SMESH_TypeDefs.hxx
src/SMESH_I/SMESH_Gen_i.hxx
src/SMESH_I/SMESH_Gen_i_1.cxx
src/SMESH_I/SMESH_MeshEditor_i.cxx
src/SMESH_I/SMESH_MeshEditor_i.hxx
src/SMESH_I/SMESH_PythonDump.hxx
src/SMESH_SWIG/smeshBuilder.py
src/StdMeshers/StdMeshers_Cartesian_3D.cxx
src/StdMeshersGUI/StdMeshersGUI_PropagationHelperWdg.cxx
src/Tools/MacMesh/MacMesh/PublishGroups.py
src/Tools/YamsPlug/doc/Advanced_params.rst
src/Tools/YamsPlug/doc/Mandatory_params.rst
src/Tools/padder/spadderpy/gui/plugindialog.py

index 9e40dcb..d0748ba 100644 (file)
@@ -688,6 +688,13 @@ module SMESH
                                      in string         MeshName)
       raises (SALOME::SALOME_Exception);
 
+    SMESH_Mesh Offset(in SMESH_IDSource theObject,
+                      in double         Value,
+                      in boolean        CopyGroups,
+                      in string         MeshName,
+                      out ListOfGroups  Groups)
+      raises (SALOME::SALOME_Exception);
+
     void FindCoincidentNodes (in  double              Tolerance,
                               out array_of_long_array GroupsOfNodes,
                               in  boolean             SeparateCornersAndMedium)
@@ -874,7 +881,7 @@ module SMESH
      * \param theElements - container of elements to duplicate.
      * \param theGroupName - a name of group to contain the generated elements.
      *                    If a group with such a name already exists, the new elements
-     *                    are added to the existng group, else a new group is created.
+     *                    are added to the existing group, else a new group is created.
      *                    If \a theGroupName is empty, new elements are not added 
      *                    in any group.
      * \return a group where the new elements are added. NULL if theGroupName == "".
index 6db2127..ab8792b 100755 (executable)
@@ -229,6 +229,7 @@ SET(SMESH_RESOURCES_FILES
   mesh_show.png
   mesh_hide.png
   mesh_deflection.png
+  mesh_offset.png
 )
 
 INSTALL(FILES ${SMESH_RESOURCES_FILES} DESTINATION ${SALOME_SMESH_INSTALL_RES_DATA})
index 333c72d..e95d23a 100644 (file)
 #include "SMDS_FaceOfNodes.hxx"
 #include "SMDS_IteratorOnIterators.hxx"
 #include "SMDS_Mesh.hxx"
-#include "SMDS_MeshElement.hxx"
-#include "SMDS_MeshNode.hxx"
 #include "SMDS_PolygonalFaceOfNodes.hxx"
 #include "SMDS_SetIterator.hxx"
 #include "SMDS_VolumeTool.hxx"
 #include "SMESH_File.hxx"
+#include "SMESH_MeshAlgos.hxx"
 #include "SMESH_TypeDefs.hxx"
 
-#include <Standard_ErrorHandler.hxx>
-#include <Standard_Failure.hxx>
-#include <gp_Ax2.hxx>
-
 #include <limits>
 
 
@@ -208,270 +203,6 @@ static gp_XYZ getNormale( const SMDS_MeshNode* n1,
   return n;
 }
 
-namespace
-{
-  /*!
-   * \brief Vertex of a polygon. Together with 2 neighbor Vertices represents a triangle
-   */
-  struct PolyVertex
-  {
-    SMESH_TNodeXYZ _nxyz;
-    gp_XY          _xy;
-    PolyVertex*    _prev;
-    PolyVertex*    _next;
-
-    void SetNodeAndNext( const SMDS_MeshNode* n, PolyVertex& v )
-    {
-      _nxyz.Set( n );
-      _next = &v;
-      v._prev = this;
-    }
-    PolyVertex* Delete()
-    {
-      _prev->_next = _next;
-      _next->_prev = _prev;
-      return _next;
-    }
-    void GetTriaNodes( const SMDS_MeshNode** nodes) const
-    {
-      nodes[0] = _prev->_nxyz._node;
-      nodes[1] =  this->_nxyz._node;
-      nodes[2] = _next->_nxyz._node;
-    }
-
-    inline static double Area( const PolyVertex* v0, const PolyVertex* v1, const PolyVertex* v2 )
-    {
-      gp_XY vPrev = v0->_xy - v1->_xy;
-      gp_XY vNext = v2->_xy - v1->_xy;
-      return vNext ^ vPrev;
-    }
-    double TriaArea() const { return Area( _prev, this, _next ); }
-
-    bool IsInsideTria( const PolyVertex* v )
-    {
-      gp_XY p = _prev->_xy - v->_xy;
-      gp_XY t =  this->_xy - v->_xy;
-      gp_XY n = _next->_xy - v->_xy;
-      const double tol = -1e-12;
-      return (( p ^ t ) >= tol &&
-              ( t ^ n ) >= tol &&
-              ( n ^ p ) >= tol );
-      // return ( Area( _prev, this, v ) > 0 &&
-      //          Area( this, _next, v ) > 0 &&
-      //          Area( _next, _prev, v ) > 0 );
-    }
-  };
-
-  //================================================================================
-  /*!
-   * \brief Triangulate a polygon. Assure correct orientation for concave polygons
-   */
-  //================================================================================
-
-  bool triangulate( std::vector< const SMDS_MeshNode*>& nodes, const size_t nbNodes )
-  {
-    // connect nodes into a ring
-    std::vector< PolyVertex > pv( nbNodes );
-    for ( size_t i = 1; i < nbNodes; ++i )
-      pv[i-1].SetNodeAndNext( nodes[i-1], pv[i] );
-    pv[ nbNodes-1 ].SetNodeAndNext( nodes[ nbNodes-1 ], pv[0] );
-
-    // get a polygon normal
-    gp_XYZ normal(0,0,0), p0,v01,v02;
-    p0  = pv[0]._nxyz;
-    v01 = pv[1]._nxyz - p0;
-    for ( size_t i = 2; i < nbNodes; ++i )
-    {
-      v02 = pv[i]._nxyz - p0;
-      normal += v01 ^ v02;
-      v01 = v02;
-    }
-    // project nodes to the found plane
-    gp_Ax2 axes;
-    try {
-      axes = gp_Ax2( p0, normal, v01 );
-    }
-    catch ( Standard_Failure ) {
-      return false;
-    }
-    for ( size_t i = 0; i < nbNodes; ++i )
-    {
-      gp_XYZ p = pv[i]._nxyz - p0;
-      pv[i]._xy.SetX( axes.XDirection().XYZ() * p );
-      pv[i]._xy.SetY( axes.YDirection().XYZ() * p );
-    }
-
-    // in a loop, find triangles with positive area and having no vertices inside
-    int iN = 0, nbTria = nbNodes - 2;
-    nodes.reserve( nbTria * 3 );
-    const double minArea = 1e-6;
-    PolyVertex* v = &pv[0], *vi;
-    int nbVertices = nbNodes, nbBadTria = 0, isGoodTria;
-    while ( nbBadTria < nbVertices )
-    {
-      if (( isGoodTria = v->TriaArea() > minArea ))
-      {
-        for ( vi = v->_next->_next;
-              vi != v->_prev;
-              vi = vi->_next )
-        {
-          if ( v->IsInsideTria( vi ))
-            break;
-        }
-        isGoodTria = ( vi == v->_prev );
-      }
-      if ( isGoodTria )
-      {
-        v->GetTriaNodes( &nodes[ iN ] );
-        iN += 3;
-        v = v->Delete();
-        if ( --nbVertices == 3 )
-        {
-          // last triangle remains
-          v->GetTriaNodes( &nodes[ iN ] );
-          return true;
-        }
-        nbBadTria = 0;
-      }
-      else
-      {
-        v = v->_next;
-        ++nbBadTria;
-      }
-    }
-
-    // the polygon is invalid; add triangles with positive area
-    nbBadTria = 0;
-    while ( nbBadTria < nbVertices )
-    {
-      isGoodTria = v->TriaArea() > minArea;
-      if ( isGoodTria )
-      {
-        v->GetTriaNodes( &nodes[ iN ] );
-        iN += 3;
-        v = v->Delete();
-        if ( --nbVertices == 3 )
-        {
-          // last triangle remains
-          v->GetTriaNodes( &nodes[ iN ] );
-          return true;
-        }
-        nbBadTria = 0;
-      }
-      else
-      {
-        v = v->_next;
-        ++nbBadTria;
-      }
-    }
-
-    // add all the rest triangles
-    while ( nbVertices >= 3 )
-    {
-      v->GetTriaNodes( &nodes[ iN ] );
-      iN += 3;
-      v = v->Delete();
-      --nbVertices;
-    }
-
-    return true;
-
-  } // triangulate()
-} // namespace
-
-//================================================================================
-/*!
- * \brief Return nb triangles in a decomposed mesh face
- *  \retval int - number of triangles
- */
-//================================================================================
-
-static int getNbTriangles( const SMDS_MeshElement* face)
-{
-  // WARNING: counting triangles must be coherent with getTriangles()
-  switch ( face->GetEntityType() )
-  {
-  case SMDSEntity_BiQuad_Triangle:
-  case SMDSEntity_BiQuad_Quadrangle:
-    return face->NbNodes() - 1;
-  // case SMDSEntity_Triangle:
-  // case SMDSEntity_Quad_Triangle:
-  // case SMDSEntity_Quadrangle:
-  // case SMDSEntity_Quad_Quadrangle:
-  // case SMDSEntity_Polygon:
-  // case SMDSEntity_Quad_Polygon:
-  default:
-    return face->NbNodes() - 2;
-  }
-  return 0;
-}
-
-//================================================================================
-/*!
- * \brief Decompose a mesh face into triangles
- *  \retval int - number of triangles
- */
-//================================================================================
-
-static int getTriangles( const SMDS_MeshElement*             face,
-                         std::vector< const SMDS_MeshNode*>& nodes)
-{
-  // WARNING: decomposing into triangles must be coherent with getNbTriangles()
-  int nbTria, i = 0, nbNodes = face->NbNodes();
-  SMDS_NodeIteratorPtr nIt = face->interlacedNodesIterator();
-  nodes.resize( nbNodes * 3 );
-  nodes[ i++ ] = nIt->next();
-  nodes[ i++ ] = nIt->next();
-
-  const SMDSAbs_EntityType type = face->GetEntityType();
-  switch ( type )
-  {
-  case SMDSEntity_BiQuad_Triangle:
-  case SMDSEntity_BiQuad_Quadrangle:
-    nbTria = ( type == SMDSEntity_BiQuad_Triangle ) ? 6 : 8;
-    nodes[ i++ ] = face->GetNode( nbTria );
-    for ( i = 3; i < 3*(nbTria-1); i += 3 )
-    {
-      nodes[ i+0 ] = nodes[ i-2 ];
-      nodes[ i+1 ] = nIt->next();
-      nodes[ i+2 ] = nodes[ 2 ];
-    }
-    nodes[ i+0 ] = nodes[ i-2 ];
-    nodes[ i+1 ] = nodes[ 0 ];
-    nodes[ i+2 ] = nodes[ 2 ];
-    break;
-  case SMDSEntity_Triangle:
-    nbTria = 1;
-    nodes[ i++ ] = nIt->next();
-    break;
-  default:
-    // case SMDSEntity_Quad_Triangle:
-    // case SMDSEntity_Quadrangle:
-    // case SMDSEntity_Quad_Quadrangle:
-    // case SMDSEntity_Polygon:
-    // case SMDSEntity_Quad_Polygon:
-    nbTria = nbNodes - 2;
-    while ( nIt->more() )
-      nodes[ i++ ] = nIt->next();
-
-    if ( !triangulate( nodes, nbNodes ))
-    {
-      nIt = face->interlacedNodesIterator();
-      nodes[ 0 ] = nIt->next();
-      nodes[ 1 ] = nIt->next();
-      nodes[ 2 ] = nIt->next();
-      for ( i = 3; i < 3*nbTria; i += 3 )
-      {
-        nodes[ i+0 ] = nodes[ 0 ];
-        nodes[ i+1 ] = nodes[ i-1 ];
-        nodes[ i+2 ] = nIt->next();
-      }
-    }
-    break;
-  }
-  return nbTria;
-}
-
 // private methods
 
 Driver_Mesh::Status DriverSTL_W_SMDS_Mesh::writeAscii() const
@@ -492,11 +223,13 @@ Driver_Mesh::Status DriverSTL_W_SMDS_Mesh::writeAscii() const
   char sval[128];
   std::vector< const SMDS_MeshNode* > triaNodes;
 
+  SMESH_MeshAlgos::Triangulate triangulator;
+
   SMDS_ElemIteratorPtr itFaces = getFaces();
   while ( itFaces->more() )
   {
     const SMDS_MeshElement* aFace = itFaces->next();
-    int nbTria = getTriangles( aFace, triaNodes );
+    int nbTria = triangulator.GetTriangles( aFace, triaNodes );
 
     for ( int iT = 0, iN = 0; iT < nbTria; ++iT )
     {
@@ -546,13 +279,15 @@ Driver_Mesh::Status DriverSTL_W_SMDS_Mesh::writeBinary() const
   SMESH_File aFile( myFile );
   aFile.openForWriting();
 
+  SMESH_MeshAlgos::Triangulate triangulator;
+
   // we first count the number of triangles
   int nbTri = myNbVolumeTrias;
   {
     SMDS_FaceIteratorPtr itFaces = myMesh->facesIterator();
     while ( itFaces->more() ) {
       const SMDS_MeshElement* aFace = itFaces->next();
-      nbTri += getNbTriangles( aFace );
+      nbTri += triangulator.GetNbTriangles( aFace );
     }
   }
   std::string sval( LABEL_SIZE, ' ' );
@@ -576,7 +311,7 @@ Driver_Mesh::Status DriverSTL_W_SMDS_Mesh::writeBinary() const
   while ( itFaces->more() )
   {
     const SMDS_MeshElement* aFace = itFaces->next();
-    int nbTria = getTriangles( aFace, triaNodes );
+    int nbTria = triangulator.GetTriangles( aFace, triaNodes );
     
     for ( int iT = 0, iN = 0; iT < nbTria; ++iT )
     {
index 8bce601..00b31a3 100644 (file)
@@ -688,6 +688,7 @@ public:
   virtual void Renumber (const bool isNodes, const int startID = 1, const int deltaID = 1);
   // Renumber all nodes or elements.
   virtual void compactMesh();
+  virtual void CompactMesh() { compactMesh(); }
 
   const SMDS_MeshNode *FindNode(int idnode) const;
   const SMDS_MeshNode *FindNodeVtk(int idnode) const;
index 2fec139..33dd39d 100644 (file)
@@ -67,7 +67,6 @@ class SMDS_EXPORT SMDS_PolygonalFaceOfNodes:public SMDS_MeshFace
  protected:
   virtual SMDS_ElemIteratorPtr elementsIterator (SMDSAbs_ElementType type) const;
 
- private:
   std::vector<const SMDS_MeshNode *> myNodes;
 };
 
index c6502c4..684c61d 100644 (file)
@@ -45,7 +45,7 @@ public:
 
   // constructor to use as return from begin()
   SMDS_StdIterator( PtrSMDSIterator pItr )
-    : _value( pItr->more() ? (VALUE)(pItr->next()) : 0 ), _piterator(pItr)
+    : _value( pItr->more() ? VALUE(pItr->next()) : VALUE(0) ), _piterator(pItr)
   {}
   // constructor to use as return from end()
   SMDS_StdIterator(): _value( 0 )
@@ -58,12 +58,12 @@ public:
   //  Step to the next one
   _Self&
   operator++()
-  { _value = _piterator->more() ? VALUE( _piterator->next()) : 0; return *this; }
+  { _value = _piterator->more() ? VALUE( _piterator->next()) : VALUE(0); return *this; }
 
   //  Step to the next one
   _Self
   operator++(int)
-  { _Self res = *this; _value = _piterator->more() ? VALUE( _piterator->next()) : 0; return res; }
+  { _Self res = *this; _value = _piterator->more() ? VALUE( _piterator->next()) : VALUE(0); return res; }
 
   // Test of end
   bool
index 7b0d86f..b86d7f5 100644 (file)
 using namespace std;
 using namespace SMESH::Controls;
 
-namespace
-{
-  template < class ELEM_SET >
-  SMDS_ElemIteratorPtr elemSetIterator( const ELEM_SET& elements )
-  {
-    typedef SMDS_SetIterator
-      < SMDS_pElement, typename ELEM_SET::const_iterator> TSetIterator;
-    return SMDS_ElemIteratorPtr( new TSetIterator( elements.begin(), elements.end() ));
-  }
-}
-
 //=======================================================================
 //function : SMESH_MeshEditor
 //purpose  :
@@ -147,8 +136,8 @@ SMESHDS_Mesh * SMESH_MeshEditor::GetMeshDS()
 
 void SMESH_MeshEditor::ClearLastCreated()
 {
-  myLastCreatedNodes.Clear();
-  myLastCreatedElems.Clear();
+  SMESHUtils::FreeVector( myLastCreatedElems );
+  SMESHUtils::FreeVector( myLastCreatedNodes );
 }
 
 //================================================================================
@@ -380,7 +369,7 @@ SMESH_MeshEditor::AddElement(const vector<const SMDS_MeshNode*> & node,
 
   default:;
   }
-  if ( e ) myLastCreatedElems.Append( e );
+  if ( e ) myLastCreatedElems.push_back( e );
   return e;
 }
 
@@ -414,8 +403,7 @@ SMDS_MeshElement* SMESH_MeshEditor::AddElement(const vector<int> & nodeIDs,
 int SMESH_MeshEditor::Remove (const list< int >& theIDs,
                               const bool         isNodes )
 {
-  myLastCreatedElems.Clear();
-  myLastCreatedNodes.Clear();
+  ClearLastCreated();
 
   SMESHDS_Mesh* aMesh = GetMeshDS();
   set< SMESH_subMesh *> smmap;
@@ -495,7 +483,7 @@ void SMESH_MeshEditor::Create0DElementsOnAllNodes( const TIDSortedElemSet& eleme
   }
   else
   {
-    elemIt = elemSetIterator( elements );
+    elemIt = SMESHUtils::elemSetIterator( elements );
   }
 
   while ( elemIt->more() )
@@ -508,8 +496,8 @@ void SMESH_MeshEditor::Create0DElementsOnAllNodes( const TIDSortedElemSet& eleme
       SMDS_ElemIteratorPtr it0D = n->GetInverseElementIterator( SMDSAbs_0DElement );
       if ( duplicateElements || !it0D->more() )
       {
-        myLastCreatedElems.Append( GetMeshDS()->Add0DElement( n ));
-        all0DElems.insert( myLastCreatedElems.Last() );
+        myLastCreatedElems.push_back( GetMeshDS()->Add0DElement( n ));
+        all0DElems.insert( myLastCreatedElems.back() );
       }
       while ( it0D->more() )
         all0DElems.insert( it0D->next() );
@@ -525,8 +513,7 @@ void SMESH_MeshEditor::Create0DElementsOnAllNodes( const TIDSortedElemSet& eleme
 
 int SMESH_MeshEditor::FindShape (const SMDS_MeshElement * theElem)
 {
-  myLastCreatedElems.Clear();
-  myLastCreatedNodes.Clear();
+  ClearLastCreated();
 
   SMESHDS_Mesh * aMesh = GetMeshDS();
   if ( aMesh->ShapeToMesh().IsNull() )
@@ -693,8 +680,7 @@ static bool getNodesFromTwoTria(const SMDS_MeshElement * theTria1,
 bool SMESH_MeshEditor::InverseDiag (const SMDS_MeshElement * theTria1,
                                     const SMDS_MeshElement * theTria2 )
 {
-  myLastCreatedElems.Clear();
-  myLastCreatedNodes.Clear();
+  ClearLastCreated();
 
   if (!theTria1 || !theTria2)
     return false;
@@ -894,8 +880,7 @@ static bool findTriangles(const SMDS_MeshNode *    theNode1,
 bool SMESH_MeshEditor::InverseDiag (const SMDS_MeshNode * theNode1,
                                     const SMDS_MeshNode * theNode2)
 {
-  myLastCreatedElems.Clear();
-  myLastCreatedNodes.Clear();
+  ClearLastCreated();
 
   const SMDS_MeshElement *tr1, *tr2;
   if ( !findTriangles( theNode1, theNode2, tr1, tr2 ))
@@ -1015,8 +1000,7 @@ bool getQuadrangleNodes(const SMDS_MeshNode *    theQuadNodes [],
 bool SMESH_MeshEditor::DeleteDiag (const SMDS_MeshNode * theNode1,
                                    const SMDS_MeshNode * theNode2)
 {
-  myLastCreatedElems.Clear();
-  myLastCreatedNodes.Clear();
+  ClearLastCreated();
 
   const SMDS_MeshElement *tr1, *tr2;
   if ( !findTriangles( theNode1, theNode2, tr1, tr2 ))
@@ -1037,13 +1021,13 @@ bool SMESH_MeshEditor::DeleteDiag (const SMDS_MeshNode * theNode1,
 
     const SMDS_MeshElement* newElem = 0;
     newElem = aMesh->AddFace( aNodes[0], aNodes[1], aNodes[2], aNodes[3] );
-    myLastCreatedElems.Append(newElem);
+    myLastCreatedElems.push_back(newElem);
     AddToSameGroups( newElem, tr1, aMesh );
     int aShapeId = tr1->getshapeId();
     if ( aShapeId )
-      {
-        aMesh->SetMeshElementOnShape( newElem, aShapeId );
-      }
+    {
+      aMesh->SetMeshElementOnShape( newElem, aShapeId );
+    }
     aMesh->RemoveElement( tr1 );
     aMesh->RemoveElement( tr2 );
 
@@ -1087,13 +1071,13 @@ bool SMESH_MeshEditor::DeleteDiag (const SMDS_MeshNode * theNode1,
   const SMDS_MeshElement* newElem = 0;
   newElem = aMesh->AddFace( aNodes[0], aNodes[1], aNodes[2], aNodes[3],
                             aNodes[4], aNodes[5], aNodes[6], aNodes[7]);
-  myLastCreatedElems.Append(newElem);
+  myLastCreatedElems.push_back(newElem);
   AddToSameGroups( newElem, tr1, aMesh );
   int aShapeId = tr1->getshapeId();
   if ( aShapeId )
-    {
-      aMesh->SetMeshElementOnShape( newElem, aShapeId );
-    }
+  {
+    aMesh->SetMeshElementOnShape( newElem, aShapeId );
+  }
   aMesh->RemoveElement( tr1 );
   aMesh->RemoveElement( tr2 );
 
@@ -1110,8 +1094,7 @@ bool SMESH_MeshEditor::DeleteDiag (const SMDS_MeshNode * theNode1,
 
 bool SMESH_MeshEditor::Reorient (const SMDS_MeshElement * theElem)
 {
-  myLastCreatedElems.Clear();
-  myLastCreatedNodes.Clear();
+  ClearLastCreated();
 
   if (!theElem)
     return false;
@@ -1316,7 +1299,7 @@ int SMESH_MeshEditor::Reorient2DBy3D (TIDSortedElemSet & theFaces,
   if ( theFaces.empty() )
     faceIt = GetMeshDS()->elementsIterator( SMDSAbs_Face );
   else
-    faceIt = elemSetIterator( theFaces );
+    faceIt = SMESHUtils::elemSetIterator( theFaces );
 
   vector< const SMDS_MeshNode* > faceNodes;
   TIDSortedElemSet checkedVolumes;
@@ -1405,17 +1388,17 @@ static double getBadRate (const SMDS_MeshElement*               theElem,
 bool SMESH_MeshEditor::QuadToTri (TIDSortedElemSet &                   theElems,
                                   SMESH::Controls::NumericalFunctorPtr theCrit)
 {
-  myLastCreatedElems.Clear();
-  myLastCreatedNodes.Clear();
+  ClearLastCreated();
 
   if ( !theCrit.get() )
     return false;
 
-  SMESHDS_Mesh * aMesh = GetMeshDS();
-
+  SMESHDS_Mesh *       aMesh = GetMeshDS();
   Handle(Geom_Surface) surface;
   SMESH_MesherHelper   helper( *GetMesh() );
 
+  myLastCreatedElems.reserve( theElems.size() * 2 );
+
   TIDSortedElemSet::iterator itElem;
   for ( itElem = theElems.begin(); itElem != theElems.end(); itElem++ )
   {
@@ -1484,8 +1467,8 @@ bool SMESH_MeshEditor::QuadToTri (TIDSortedElemSet &                   theElems,
 
     // care of a new element
 
-    myLastCreatedElems.Append(newElem1);
-    myLastCreatedElems.Append(newElem2);
+    myLastCreatedElems.push_back(newElem1);
+    myLastCreatedElems.push_back(newElem2);
     AddToSameGroups( newElem1, elem, aMesh );
     AddToSameGroups( newElem2, elem, aMesh );
 
@@ -1508,15 +1491,15 @@ bool SMESH_MeshEditor::QuadToTri (TIDSortedElemSet &                   theElems,
 
 void SMESH_MeshEditor::QuadTo4Tri (TIDSortedElemSet & theElems)
 {
-  myLastCreatedElems.Clear();
-  myLastCreatedNodes.Clear();
+  ClearLastCreated();
+  myLastCreatedElems.reserve( theElems.size() * 4 );
 
   SMESH_MesherHelper helper( *GetMesh() );
   helper.SetElementsOnShape( true );
 
   SMDS_ElemIteratorPtr faceIt;
   if ( theElems.empty() ) faceIt = GetMeshDS()->elementsIterator(SMDSAbs_Face);
-  else                    faceIt = elemSetIterator( theElems );
+  else                    faceIt = SMESHUtils::elemSetIterator( theElems );
 
   bool   checkUV;
   gp_XY  uv [9]; uv[8] = gp_XY(0,0);
@@ -1600,7 +1583,7 @@ void SMESH_MeshEditor::QuadTo4Tri (TIDSortedElemSet & theElems)
 
       nCentral = helper.AddNode( xyz[8].X(), xyz[8].Y(), xyz[8].Z(), /*id=*/0,
                                  uv[8].X(), uv[8].Y() );
-      myLastCreatedNodes.Append( nCentral );
+      myLastCreatedNodes.push_back( nCentral );
     }
 
     // create 4 triangles
@@ -1618,7 +1601,7 @@ void SMESH_MeshEditor::QuadTo4Tri (TIDSortedElemSet & theElems)
                                                nodes[(i+1)%4],
                                                nCentral );
       ReplaceElemInGroups( tria, quad, GetMeshDS() );
-      myLastCreatedElems.Append( tria );
+      myLastCreatedElems.push_back( tria );
     }
   }
 }
@@ -1631,8 +1614,7 @@ void SMESH_MeshEditor::QuadTo4Tri (TIDSortedElemSet & theElems)
 int SMESH_MeshEditor::BestSplit (const SMDS_MeshElement*              theQuad,
                                  SMESH::Controls::NumericalFunctorPtr theCrit)
 {
-  myLastCreatedElems.Clear();
-  myLastCreatedNodes.Clear();
+  ClearLastCreated();
 
   if (!theCrit.get())
     return -1;
@@ -2299,7 +2281,7 @@ void SMESH_MeshEditor::SplitVolumes (const TFacetOfElem & theElems,
       volTool.GetBaryCenter( bc[0], bc[1], bc[2] );
       SMDS_MeshNode* gcNode = helper.AddNode( bc[0], bc[1], bc[2] );
       nodes.push_back( gcNode );
-      newNodes.Append( gcNode );
+      newNodes.push_back( gcNode );
     }
     if ( !splitMethod._faceBaryNode.empty() )
     {
@@ -2313,7 +2295,7 @@ void SMESH_MeshEditor::SplitVolumes (const TFacetOfElem & theElems,
         if ( !f_n->second )
         {
           volTool.GetFaceBaryCenter( iF_n->first, bc[0], bc[1], bc[2] );
-          newNodes.Append( f_n->second = helper.AddNode( bc[0], bc[1], bc[2] ));
+          newNodes.push_back( f_n->second = helper.AddNode( bc[0], bc[1], bc[2] ));
         }
         nodes.push_back( iF_n->second = f_n->second );
       }
@@ -2324,18 +2306,18 @@ void SMESH_MeshEditor::SplitVolumes (const TFacetOfElem & theElems,
     const int* volConn = splitMethod._connectivity;
     if ( splitMethod._nbCorners == 4 ) // tetra
       for ( int i = 0; i < splitMethod._nbSplits; ++i, volConn += splitMethod._nbCorners )
-        newElems.Append( splitVols[ i ] = helper.AddVolume( nodes[ volConn[0] ],
-                                                            nodes[ volConn[1] ],
-                                                            nodes[ volConn[2] ],
-                                                            nodes[ volConn[3] ]));
+        newElems.push_back( splitVols[ i ] = helper.AddVolume( nodes[ volConn[0] ],
+                                                               nodes[ volConn[1] ],
+                                                               nodes[ volConn[2] ],
+                                                               nodes[ volConn[3] ]));
     else // prisms
       for ( int i = 0; i < splitMethod._nbSplits; ++i, volConn += splitMethod._nbCorners )
-        newElems.Append( splitVols[ i ] = helper.AddVolume( nodes[ volConn[0] ],
-                                                            nodes[ volConn[1] ],
-                                                            nodes[ volConn[2] ],
-                                                            nodes[ volConn[3] ],
-                                                            nodes[ volConn[4] ],
-                                                            nodes[ volConn[5] ]));
+        newElems.push_back( splitVols[ i ] = helper.AddVolume( nodes[ volConn[0] ],
+                                                               nodes[ volConn[1] ],
+                                                               nodes[ volConn[2] ],
+                                                               nodes[ volConn[3] ],
+                                                               nodes[ volConn[4] ],
+                                                               nodes[ volConn[5] ]));
 
     ReplaceElemInGroups( elem, splitVols, GetMeshDS() );
 
@@ -2388,7 +2370,7 @@ void SMESH_MeshEditor::SplitVolumes (const TFacetOfElem & theElems,
               gp_XY uv( 1e100, 1e100 );
               double distXYZ[4];
               if ( !fHelper.CheckNodeUV( TopoDS::Face( s ), baryNode,
-                                        uv, /*tol=*/1e-7, /*force=*/true, distXYZ ) &&
+                                         uv, /*tol=*/1e-7, /*force=*/true, distXYZ ) &&
                    uv.X() < 1e100 )
               {
                 // node is too far from the surface
@@ -2442,7 +2424,7 @@ void SMESH_MeshEditor::SplitVolumes (const TFacetOfElem & theElems,
           if ( !triangles[ i ]) continue;
           if ( fSubMesh )
             fSubMesh->AddElement( triangles[ i ]);
-          newElems.Append( triangles[ i ]);
+          newElems.push_back( triangles[ i ]);
         }
         ReplaceElemInGroups( face, triangles, GetMeshDS() );
         GetMeshDS()->RemoveFreeElement( face, fSubMesh, /*fromGroups=*/false );
@@ -2479,7 +2461,7 @@ void SMESH_MeshEditor::GetHexaFacetsToSplit( TIDSortedElemSet& theHexas,
                                              const gp_Ax1&     theFacetNormal,
                                              TFacetOfElem &    theFacets)
 {
-  #define THIS_METHOD "SMESH_MeshEditor::GetHexaFacetsToSplit(): "
+#define THIS_METHOD "SMESH_MeshEditor::GetHexaFacetsToSplit(): "
 
   // Find a hexa closest to the location of theFacetNormal
 
@@ -2933,11 +2915,10 @@ void SMESH_MeshEditor::ReplaceElemInGroups (const SMDS_MeshElement*
 bool SMESH_MeshEditor::QuadToTri (TIDSortedElemSet & theElems,
                                   const bool         the13Diag)
 {
-  myLastCreatedElems.Clear();
-  myLastCreatedNodes.Clear();
-
-  SMESHDS_Mesh * aMesh = GetMeshDS();
+  ClearLastCreated();
+  myLastCreatedElems.reserve( theElems.size() * 2 );
 
+  SMESHDS_Mesh *       aMesh = GetMeshDS();
   Handle(Geom_Surface) surface;
   SMESH_MesherHelper   helper( *GetMesh() );
 
@@ -2967,8 +2948,8 @@ bool SMESH_MeshEditor::QuadToTri (TIDSortedElemSet & theElems,
         newElem1 = aMesh->AddFace( aNodes[3], aNodes[0], aNodes[1] );
         newElem2 = aMesh->AddFace( aNodes[3], aNodes[1], aNodes[2] );
       }
-      myLastCreatedElems.Append(newElem1);
-      myLastCreatedElems.Append(newElem2);
+      myLastCreatedElems.push_back(newElem1);
+      myLastCreatedElems.push_back(newElem2);
       // put a new triangle on the same shape and add to the same groups
       if ( aShapeId )
       {
@@ -3010,7 +2991,7 @@ bool SMESH_MeshEditor::QuadToTri (TIDSortedElemSet & theElems,
         centrNode = helper.GetCentralNode( aNodes[0], aNodes[1], aNodes[2], aNodes[3],
                                            aNodes[4], aNodes[5], aNodes[6], aNodes[7],
                                            surface.IsNull() );
-        myLastCreatedNodes.Append(centrNode);
+        myLastCreatedNodes.push_back(centrNode);
       }
 
       // create a new element
@@ -3028,8 +3009,8 @@ bool SMESH_MeshEditor::QuadToTri (TIDSortedElemSet & theElems,
         newElem2 = aMesh->AddFace(aNodes[3], aNodes[1], aNodes[2],
                                   centrNode, aNodes[5], aNodes[6] );
       }
-      myLastCreatedElems.Append(newElem1);
-      myLastCreatedElems.Append(newElem2);
+      myLastCreatedElems.push_back(newElem1);
+      myLastCreatedElems.push_back(newElem2);
       // put a new triangle on the same shape and add to the same groups
       if ( aShapeId )
       {
@@ -3153,8 +3134,8 @@ bool SMESH_MeshEditor::TriToQuad (TIDSortedElemSet &                   theElems,
                                   SMESH::Controls::NumericalFunctorPtr theCrit,
                                   const double                         theMaxAngle)
 {
-  myLastCreatedElems.Clear();
-  myLastCreatedNodes.Clear();
+  ClearLastCreated();
+  myLastCreatedElems.reserve( theElems.size() / 2 );
 
   if ( !theCrit.get() )
     return false;
@@ -3338,7 +3319,7 @@ bool SMESH_MeshEditor::TriToQuad (TIDSortedElemSet &                   theElems,
           {
             const SMDS_MeshElement* newElem = 0;
             newElem = aMesh->AddFace(n12[0], n12[1], n12[2], n12[3] );
-            myLastCreatedElems.Append(newElem);
+            myLastCreatedElems.push_back(newElem);
             AddToSameGroups( newElem, tr1, aMesh );
             int aShapeId = tr1->getshapeId();
             if ( aShapeId )
@@ -3369,7 +3350,7 @@ bool SMESH_MeshEditor::TriToQuad (TIDSortedElemSet &                   theElems,
             else
               newElem = aMesh->AddFace(aNodes[0], aNodes[1], aNodes[2], aNodes[3],
                                        aNodes[4], aNodes[5], aNodes[6], aNodes[7]);
-            myLastCreatedElems.Append(newElem);
+            myLastCreatedElems.push_back(newElem);
             AddToSameGroups( newElem, tr1, aMesh );
             int aShapeId = tr1->getshapeId();
             if ( aShapeId )
@@ -3392,7 +3373,7 @@ bool SMESH_MeshEditor::TriToQuad (TIDSortedElemSet &                   theElems,
           if ( tr1->NbNodes() == 3 ) {
             const SMDS_MeshElement* newElem = 0;
             newElem = aMesh->AddFace(n13[0], n13[1], n13[2], n13[3] );
-            myLastCreatedElems.Append(newElem);
+            myLastCreatedElems.push_back(newElem);
             AddToSameGroups( newElem, tr1, aMesh );
             int aShapeId = tr1->getshapeId();
             if ( aShapeId )
@@ -3423,7 +3404,7 @@ bool SMESH_MeshEditor::TriToQuad (TIDSortedElemSet &                   theElems,
             else
               newElem = aMesh->AddFace(aNodes[0], aNodes[1], aNodes[2], aNodes[3],
                                        aNodes[4], aNodes[5], aNodes[6], aNodes[7]);
-            myLastCreatedElems.Append(newElem);
+            myLastCreatedElems.push_back(newElem);
             AddToSameGroups( newElem, tr1, aMesh );
             int aShapeId = tr1->getshapeId();
             if ( aShapeId )
@@ -3451,286 +3432,6 @@ bool SMESH_MeshEditor::TriToQuad (TIDSortedElemSet &                   theElems,
   return true;
 }
 
-
-/*#define DUMPSO(txt) \
-//  cout << txt << endl;
-//=============================================================================
-//
-//
-//
-//=============================================================================
-static void swap( int i1, int i2, int idNodes[], gp_Pnt P[] )
-{
-if ( i1 == i2 )
-return;
-int tmp = idNodes[ i1 ];
-idNodes[ i1 ] = idNodes[ i2 ];
-idNodes[ i2 ] = tmp;
-gp_Pnt Ptmp = P[ i1 ];
-P[ i1 ] = P[ i2 ];
-P[ i2 ] = Ptmp;
-DUMPSO( i1 << "(" << idNodes[ i2 ] << ") <-> " << i2 << "(" << idNodes[ i1 ] << ")");
-}
-
-//=======================================================================
-//function : SortQuadNodes
-//purpose  : Set 4 nodes of a quadrangle face in a good order.
-//           Swap 1<->2 or 2<->3 nodes and correspondingly return
-//           1 or 2 else 0.
-//=======================================================================
-
-int SMESH_MeshEditor::SortQuadNodes (const SMDS_Mesh * theMesh,
-int               idNodes[] )
-{
-  gp_Pnt P[4];
-  int i;
-  for ( i = 0; i < 4; i++ ) {
-    const SMDS_MeshNode *n = theMesh->FindNode( idNodes[i] );
-    if ( !n ) return 0;
-    P[ i ].SetCoord( n->X(), n->Y(), n->Z() );
-  }
-
-  gp_Vec V1(P[0], P[1]);
-  gp_Vec V2(P[0], P[2]);
-  gp_Vec V3(P[0], P[3]);
-
-  gp_Vec Cross1 = V1 ^ V2;
-  gp_Vec Cross2 = V2 ^ V3;
-
-  i = 0;
-  if (Cross1.Dot(Cross2) < 0)
-  {
-    Cross1 = V2 ^ V1;
-    Cross2 = V1 ^ V3;
-
-    if (Cross1.Dot(Cross2) < 0)
-      i = 2;
-    else
-      i = 1;
-    swap ( i, i + 1, idNodes, P );
-
-    //     for ( int ii = 0; ii < 4; ii++ ) {
-    //       const SMDS_MeshNode *n = theMesh->FindNode( idNodes[ii] );
-    //       DUMPSO( ii << "(" << idNodes[ii] <<") : "<<n->X()<<" "<<n->Y()<<" "<<n->Z());
-    //     }
-  }
-  return i;
-}
-
-//=======================================================================
-//function : SortHexaNodes
-//purpose  : Set 8 nodes of a hexahedron in a good order.
-//           Return success status
-//=======================================================================
-
-bool SMESH_MeshEditor::SortHexaNodes (const SMDS_Mesh * theMesh,
-                                      int               idNodes[] )
-{
-  gp_Pnt P[8];
-  int i;
-  DUMPSO( "INPUT: ========================================");
-  for ( i = 0; i < 8; i++ ) {
-    const SMDS_MeshNode *n = theMesh->FindNode( idNodes[i] );
-    if ( !n ) return false;
-    P[ i ].SetCoord( n->X(), n->Y(), n->Z() );
-    DUMPSO( i << "(" << idNodes[i] <<") : "<<n->X()<<" "<<n->Y()<<" "<<n->Z());
-  }
-  DUMPSO( "========================================");
-
-
-  set<int> faceNodes;  // ids of bottom face nodes, to be found
-  set<int> checkedId1; // ids of tried 2-nd nodes
-  Standard_Real leastDist = DBL_MAX; // dist of the 4-th node from 123 plane
-  const Standard_Real tol = 1.e-6;   // tolerance to find nodes in plane
-  int iMin, iLoop1 = 0;
-
-  // Loop to try the 2-nd nodes
-
-  while ( leastDist > DBL_MIN && ++iLoop1 < 8 )
-  {
-    // Find not checked 2-nd node
-    for ( i = 1; i < 8; i++ )
-      if ( checkedId1.find( idNodes[i] ) == checkedId1.end() ) {
-        int id1 = idNodes[i];
-        swap ( 1, i, idNodes, P );
-        checkedId1.insert ( id1 );
-        break;
-      }
-
-    // Find the 3-d node so that 1-2-3 triangle to be on a hexa face,
-    // ie that all but meybe one (id3 which is on the same face) nodes
-    // lay on the same side from the triangle plane.
-
-    bool manyInPlane = false; // more than 4 nodes lay in plane
-    int iLoop2 = 0;
-    while ( ++iLoop2 < 6 ) {
-
-      // get 1-2-3 plane coeffs
-      Standard_Real A, B, C, D;
-      gp_Vec N = gp_Vec (P[0], P[1]).Crossed( gp_Vec (P[0], P[2]) );
-      if ( N.SquareMagnitude() > gp::Resolution() )
-      {
-        gp_Pln pln ( P[0], N );
-        pln.Coefficients( A, B, C, D );
-
-        // find the node (iMin) closest to pln
-        Standard_Real dist[ 8 ], minDist = DBL_MAX;
-        set<int> idInPln;
-        for ( i = 3; i < 8; i++ ) {
-          dist[i] = A * P[i].X() + B * P[i].Y() + C * P[i].Z() + D;
-          if ( fabs( dist[i] ) < minDist ) {
-            minDist = fabs( dist[i] );
-            iMin = i;
-          }
-          if ( fabs( dist[i] ) <= tol )
-            idInPln.insert( idNodes[i] );
-        }
-
-        // there should not be more than 4 nodes in bottom plane
-        if ( idInPln.size() > 1 )
-        {
-          DUMPSO( "### idInPln.size() = " << idInPln.size());
-          // idInPlane does not contain the first 3 nodes
-          if ( manyInPlane || idInPln.size() == 5)
-            return false; // all nodes in one plane
-          manyInPlane = true;
-
-          // set the 1-st node to be not in plane
-          for ( i = 3; i < 8; i++ ) {
-            if ( idInPln.find( idNodes[ i ] ) == idInPln.end() ) {
-              DUMPSO( "### Reset 0-th node");
-              swap( 0, i, idNodes, P );
-              break;
-            }
-          }
-
-          // reset to re-check second nodes
-          leastDist = DBL_MAX;
-          faceNodes.clear();
-          checkedId1.clear();
-          iLoop1 = 0;
-          break; // from iLoop2;
-        }
-
-        // check that the other 4 nodes are on the same side
-        bool sameSide = true;
-        bool isNeg = dist[ iMin == 3 ? 4 : 3 ] <= 0.;
-        for ( i = 3; sameSide && i < 8; i++ ) {
-          if ( i != iMin )
-            sameSide = ( isNeg == dist[i] <= 0.);
-        }
-
-        // keep best solution
-        if ( sameSide && minDist < leastDist ) {
-          leastDist = minDist;
-          faceNodes.clear();
-          faceNodes.insert( idNodes[ 1 ] );
-          faceNodes.insert( idNodes[ 2 ] );
-          faceNodes.insert( idNodes[ iMin ] );
-          DUMPSO( "loop " << iLoop2 << " id2 " << idNodes[ 1 ] << " id3 " << idNodes[ 2 ]
-                  << " leastDist = " << leastDist);
-          if ( leastDist <= DBL_MIN )
-            break;
-        }
-      }
-
-      // set next 3-d node to check
-      int iNext = 2 + iLoop2;
-      if ( iNext < 8 ) {
-        DUMPSO( "Try 2-nd");
-        swap ( 2, iNext, idNodes, P );
-      }
-    } // while ( iLoop2 < 6 )
-  } // iLoop1
-
-  if ( faceNodes.empty() ) return false;
-
-  // Put the faceNodes in proper places
-  for ( i = 4; i < 8; i++ ) {
-    if ( faceNodes.find( idNodes[ i ] ) != faceNodes.end() ) {
-      // find a place to put
-      int iTo = 1;
-      while ( faceNodes.find( idNodes[ iTo ] ) != faceNodes.end() )
-        iTo++;
-      DUMPSO( "Set faceNodes");
-      swap ( iTo, i, idNodes, P );
-    }
-  }
-
-
-  // Set nodes of the found bottom face in good order
-  DUMPSO( " Found bottom face: ");
-  i = SortQuadNodes( theMesh, idNodes );
-  if ( i ) {
-    gp_Pnt Ptmp = P[ i ];
-    P[ i ] = P[ i+1 ];
-    P[ i+1 ] = Ptmp;
-  }
-  //   else
-  //     for ( int ii = 0; ii < 4; ii++ ) {
-  //       const SMDS_MeshNode *n = theMesh->FindNode( idNodes[ii] );
-  //       DUMPSO( ii << "(" << idNodes[ii] <<") : "<<n->X()<<" "<<n->Y()<<" "<<n->Z());
-  //    }
-
-  // Gravity center of the top and bottom faces
-  gp_Pnt aGCb = ( P[0].XYZ() + P[1].XYZ() + P[2].XYZ() + P[3].XYZ() ) / 4.;
-  gp_Pnt aGCt = ( P[4].XYZ() + P[5].XYZ() + P[6].XYZ() + P[7].XYZ() ) / 4.;
-
-  // Get direction from the bottom to the top face
-  gp_Vec upDir ( aGCb, aGCt );
-  Standard_Real upDirSize = upDir.Magnitude();
-  if ( upDirSize <= gp::Resolution() ) return false;
-  upDir / upDirSize;
-
-  // Assure that the bottom face normal points up
-  gp_Vec Nb = gp_Vec (P[0], P[1]).Crossed( gp_Vec (P[0], P[2]) );
-  Nb += gp_Vec (P[0], P[2]).Crossed( gp_Vec (P[0], P[3]) );
-  if ( Nb.Dot( upDir ) < 0 ) {
-    DUMPSO( "Reverse bottom face");
-    swap( 1, 3, idNodes, P );
-  }
-
-  // Find 5-th node - the one closest to the 1-st among the last 4 nodes.
-  Standard_Real minDist = DBL_MAX;
-  for ( i = 4; i < 8; i++ ) {
-    // projection of P[i] to the plane defined by P[0] and upDir
-    gp_Pnt Pp = P[i].Translated( upDir * ( upDir.Dot( gp_Vec( P[i], P[0] ))));
-    Standard_Real sqDist = P[0].SquareDistance( Pp );
-    if ( sqDist < minDist ) {
-      minDist = sqDist;
-      iMin = i;
-    }
-  }
-  DUMPSO( "Set 4-th");
-  swap ( 4, iMin, idNodes, P );
-
-  // Set nodes of the top face in good order
-  DUMPSO( "Sort top face");
-  i = SortQuadNodes( theMesh, &idNodes[4] );
-  if ( i ) {
-    i += 4;
-    gp_Pnt Ptmp = P[ i ];
-    P[ i ] = P[ i+1 ];
-    P[ i+1 ] = Ptmp;
-  }
-
-  // Assure that direction of the top face normal is from the bottom face
-  gp_Vec Nt = gp_Vec (P[4], P[5]).Crossed( gp_Vec (P[4], P[6]) );
-  Nt += gp_Vec (P[4], P[6]).Crossed( gp_Vec (P[4], P[7]) );
-  if ( Nt.Dot( upDir ) < 0 ) {
-    DUMPSO( "Reverse top face");
-    swap( 5, 7, idNodes, P );
-  }
-
-  //   DUMPSO( "OUTPUT: ========================================");
-  //   for ( i = 0; i < 8; i++ ) {
-  //     float *p = ugrid->GetPoint(idNodes[i]);
-  //     DUMPSO( i << "(" << idNodes[i] << ") : " << p[0] << " " << p[1] << " " << p[2]);
-  //   }
-
-  return true;
-}*/
-
 //================================================================================
 /*!
  * \brief Return nodes linked to the given one
@@ -3936,8 +3637,7 @@ void SMESH_MeshEditor::Smooth (TIDSortedElemSet &          theElems,
                                double                      theTgtAspectRatio,
                                const bool                  the2D)
 {
-  myLastCreatedElems.Clear();
-  myLastCreatedNodes.Clear();
+  ClearLastCreated();
 
   if ( theTgtAspectRatio < 1.0 )
     theTgtAspectRatio = 1.0;
@@ -4143,7 +3843,7 @@ void SMESH_MeshEditor::Smooth (TIDSortedElemSet &          theElems,
             // if ( posType != SMDS_TOP_3DSPACE )
             //   dist2 = pNode.SquareDistance( surface->Value( newUV.X(), newUV.Y() ));
             // if ( dist2 < dist1 )
-              uv = newUV;
+            uv = newUV;
           }
         }
         // store UV in the map
@@ -4663,55 +4363,55 @@ void SMESH_MeshEditor::sweepElement(const SMDS_MeshElement*               elem,
         break;
       }
       case SMDSEntity_Triangle: // TRIANGLE --->
-        {
-          if ( nbDouble > 0 ) break;
-          if ( nbSame == 0 )       // ---> pentahedron
-            aNewElem = aMesh->AddVolume (prevNod[ 0 ], prevNod[ 1 ], prevNod[ 2 ],
-                                         nextNod[ 0 ], nextNod[ 1 ], nextNod[ 2 ] );
-
-          else if ( nbSame == 1 )  // ---> pyramid
-            aNewElem = aMesh->AddVolume (prevNod[ iBeforeSame ], prevNod[ iAfterSame ],
-                                         nextNod[ iAfterSame ],  nextNod[ iBeforeSame ],
-                                         nextNod[ iSameNode ]);
-
-          else // 2 same nodes:       ---> tetrahedron
-            aNewElem = aMesh->AddVolume (prevNod[ 0 ], prevNod[ 1 ], prevNod[ 2 ],
-                                         nextNod[ iNotSameNode ]);
-          break;
-        }
+      {
+        if ( nbDouble > 0 ) break;
+        if ( nbSame == 0 )       // ---> pentahedron
+          aNewElem = aMesh->AddVolume (prevNod[ 0 ], prevNod[ 1 ], prevNod[ 2 ],
+                                       nextNod[ 0 ], nextNod[ 1 ], nextNod[ 2 ] );
+
+        else if ( nbSame == 1 )  // ---> pyramid
+          aNewElem = aMesh->AddVolume (prevNod[ iBeforeSame ], prevNod[ iAfterSame ],
+                                       nextNod[ iAfterSame ],  nextNod[ iBeforeSame ],
+                                       nextNod[ iSameNode ]);
+
+        else // 2 same nodes:       ---> tetrahedron
+          aNewElem = aMesh->AddVolume (prevNod[ 0 ], prevNod[ 1 ], prevNod[ 2 ],
+                                       nextNod[ iNotSameNode ]);
+        break;
+      }
       case SMDSEntity_Quad_Edge: // sweep quadratic EDGE --->
+      {
+        if ( nbSame == 2 )
+          return;
+        if ( nbDouble+nbSame == 2 )
         {
-          if ( nbSame == 2 )
-            return;
-          if ( nbDouble+nbSame == 2 )
-          {
-            if(nbSame==0) {      // ---> quadratic quadrangle
-              aNewElem = aMesh->AddFace(prevNod[0], prevNod[1], nextNod[1], nextNod[0],
-                                        prevNod[2], midlNod[1], nextNod[2], midlNod[0]);
-            }
-            else { //(nbSame==1) // ---> quadratic triangle
-              if(sames[0]==2) {
-                return; // medium node on axis
-              }
-              else if(sames[0]==0)
-                aNewElem = aMesh->AddFace(prevNod[0], prevNod[1], nextNod[1],
-                                          prevNod[2], midlNod[1], nextNod[2] );
-              else // sames[0]==1
-                aNewElem = aMesh->AddFace(prevNod[0], prevNod[1], nextNod[0],
-                                          prevNod[2], nextNod[2], midlNod[0]);
-            }
+          if(nbSame==0) {      // ---> quadratic quadrangle
+            aNewElem = aMesh->AddFace(prevNod[0], prevNod[1], nextNod[1], nextNod[0],
+                                      prevNod[2], midlNod[1], nextNod[2], midlNod[0]);
           }
-          else if ( nbDouble == 3 )
-          {
-            if ( nbSame == 0 ) {  // ---> bi-quadratic quadrangle
-              aNewElem = aMesh->AddFace(prevNod[0], prevNod[1], nextNod[1], nextNod[0],
-                                        prevNod[2], midlNod[1], nextNod[2], midlNod[0], midlNod[2]);
+          else { //(nbSame==1) // ---> quadratic triangle
+            if(sames[0]==2) {
+              return; // medium node on axis
             }
+            else if(sames[0]==0)
+              aNewElem = aMesh->AddFace(prevNod[0], prevNod[1], nextNod[1],
+                                        prevNod[2], midlNod[1], nextNod[2] );
+            else // sames[0]==1
+              aNewElem = aMesh->AddFace(prevNod[0], prevNod[1], nextNod[0],
+                                        prevNod[2], nextNod[2], midlNod[0]);
+          }
+        }
+        else if ( nbDouble == 3 )
+        {
+          if ( nbSame == 0 ) {  // ---> bi-quadratic quadrangle
+            aNewElem = aMesh->AddFace(prevNod[0], prevNod[1], nextNod[1], nextNod[0],
+                                      prevNod[2], midlNod[1], nextNod[2], midlNod[0], midlNod[2]);
           }
-          else
-            return;
-          break;
         }
+        else
+          return;
+        break;
+      }
       case SMDSEntity_Quadrangle: { // sweep QUADRANGLE --->
         if ( nbDouble > 0 ) break;
 
@@ -4933,8 +4633,8 @@ void SMESH_MeshEditor::sweepElement(const SMDS_MeshElement*               elem,
 
     if ( aNewElem ) {
       newElems.push_back( aNewElem );
-      myLastCreatedElems.Append(aNewElem);
-      srcElements.Append( elem );
+      myLastCreatedElems.push_back(aNewElem);
+      srcElements.push_back( elem );
     }
 
     // set new prev nodes
@@ -5024,19 +4724,19 @@ void SMESH_MeshEditor::makeWalls (TNodeOfNodeListMap &     mapNewNodes,
       if ( !isQuadratic ) {
         if ( !aMesh->FindEdge( vecNewNodes[ 0 ]->second.back(),
                                vecNewNodes[ 1 ]->second.back())) {
-          myLastCreatedElems.Append(aMesh->AddEdge(vecNewNodes[ 0 ]->second.back(),
-                                                   vecNewNodes[ 1 ]->second.back()));
-          srcElements.Append( elem );
+          myLastCreatedElems.push_back(aMesh->AddEdge(vecNewNodes[ 0 ]->second.back(),
+                                                      vecNewNodes[ 1 ]->second.back()));
+          srcElements.push_back( elem );
         }
       }
       else {
         if ( !aMesh->FindEdge( vecNewNodes[ 0 ]->second.back(),
                                vecNewNodes[ 1 ]->second.back(),
                                vecNewNodes[ 2 ]->second.back())) {
-          myLastCreatedElems.Append(aMesh->AddEdge(vecNewNodes[ 0 ]->second.back(),
-                                                   vecNewNodes[ 1 ]->second.back(),
-                                                   vecNewNodes[ 2 ]->second.back()));
-          srcElements.Append( elem );
+          myLastCreatedElems.push_back(aMesh->AddEdge(vecNewNodes[ 0 ]->second.back(),
+                                                      vecNewNodes[ 1 ]->second.back(),
+                                                      vecNewNodes[ 2 ]->second.back()));
+          srcElements.push_back( elem );
         }
       }
     }
@@ -5064,14 +4764,14 @@ void SMESH_MeshEditor::makeWalls (TNodeOfNodeListMap &     mapNewNodes,
           // make a new edge and a ceiling for a new edge
           const SMDS_MeshElement* edge;
           if ( ! ( edge = aMesh->FindEdge( n1, n2 ))) {
-            myLastCreatedElems.Append( edge = aMesh->AddEdge( n1, n2 )); // free link edge
-            srcElements.Append( myLastCreatedElems.Last() );
+            myLastCreatedElems.push_back( edge = aMesh->AddEdge( n1, n2 )); // free link edge
+            srcElements.push_back( myLastCreatedElems.back() );
           }
           n1 = vecNewNodes[ iNode ]->second.back();
           n2 = vecNewNodes[ iNext ]->second.back();
           if ( !aMesh->FindEdge( n1, n2 )) {
-            myLastCreatedElems.Append(aMesh->AddEdge( n1, n2 )); // new edge ceiling
-            srcElements.Append( edge );
+            myLastCreatedElems.push_back(aMesh->AddEdge( n1, n2 )); // new edge ceiling
+            srcElements.push_back( edge );
           }
         }
       }
@@ -5092,15 +4792,15 @@ void SMESH_MeshEditor::makeWalls (TNodeOfNodeListMap &     mapNewNodes,
           // make an edge and a ceiling for a new edge
           // find medium node
           if ( !aMesh->FindEdge( n1, n2, n3 )) {
-            myLastCreatedElems.Append(aMesh->AddEdge( n1, n2, n3 )); // free link edge
-            srcElements.Append( elem );
+            myLastCreatedElems.push_back(aMesh->AddEdge( n1, n2, n3 )); // free link edge
+            srcElements.push_back( elem );
           }
           n1 = vecNewNodes[ iNode ]->second.back();
           n2 = vecNewNodes[ iNext ]->second.back();
           n3 = vecNewNodes[ iNode+nbn ]->second.back();
           if ( !aMesh->FindEdge( n1, n2, n3 )) {
-            myLastCreatedElems.Append(aMesh->AddEdge( n1, n2, n3 )); // ceiling edge
-            srcElements.Append( elem );
+            myLastCreatedElems.push_back(aMesh->AddEdge( n1, n2, n3 )); // ceiling edge
+            srcElements.push_back( elem );
           }
         }
       }
@@ -5193,8 +4893,8 @@ void SMESH_MeshEditor::makeWalls (TNodeOfNodeListMap &     mapNewNodes,
                 if ( f )
                   aMesh->ChangeElementNodes( f, &newOrder[0], nbn );
                 else
-                  myLastCreatedElems.Append(aMesh->AddFace( newOrder[ 0 ], newOrder[ 1 ],
-                                                            newOrder[ 2 ] ));
+                  myLastCreatedElems.push_back(aMesh->AddFace( newOrder[ 0 ], newOrder[ 1 ],
+                                                               newOrder[ 2 ] ));
               }
             }
             else if ( nbn == 4 )       ///// quadrangle
@@ -5208,8 +4908,8 @@ void SMESH_MeshEditor::makeWalls (TNodeOfNodeListMap &     mapNewNodes,
                 if ( f )
                   aMesh->ChangeElementNodes( f, &newOrder[0], nbn );
                 else
-                  myLastCreatedElems.Append(aMesh->AddFace( newOrder[ 0 ], newOrder[ 1 ],
-                                                            newOrder[ 2 ], newOrder[ 3 ]));
+                  myLastCreatedElems.push_back(aMesh->AddFace( newOrder[ 0 ], newOrder[ 1 ],
+                                                               newOrder[ 2 ], newOrder[ 3 ]));
               }
             }
             else if ( nbn == 6 && isQuadratic ) /////// quadratic triangle
@@ -5227,12 +4927,12 @@ void SMESH_MeshEditor::makeWalls (TNodeOfNodeListMap &     mapNewNodes,
                 if ( f )
                   aMesh->ChangeElementNodes( f, &newOrder[0], nbn );
                 else
-                  myLastCreatedElems.Append(aMesh->AddFace( newOrder[ 0 ],
-                                                            newOrder[ 1 ],
-                                                            newOrder[ 2 ],
-                                                            newOrder[ 3 ],
-                                                            newOrder[ 4 ],
-                                                            newOrder[ 5 ] ));
+                  myLastCreatedElems.push_back(aMesh->AddFace( newOrder[ 0 ],
+                                                               newOrder[ 1 ],
+                                                               newOrder[ 2 ],
+                                                               newOrder[ 3 ],
+                                                               newOrder[ 4 ],
+                                                               newOrder[ 5 ] ));
               }
             }
             else if ( nbn == 8 && isQuadratic ) /////// quadratic quadrangle
@@ -5253,10 +4953,10 @@ void SMESH_MeshEditor::makeWalls (TNodeOfNodeListMap &     mapNewNodes,
                 if ( f )
                   aMesh->ChangeElementNodes( f, &newOrder[0], nbn );
                 else
-                  myLastCreatedElems.Append(aMesh->AddFace(newOrder[ 0 ], newOrder[ 1 ],
-                                                           newOrder[ 2 ], newOrder[ 3 ],
-                                                           newOrder[ 4 ], newOrder[ 5 ],
-                                                           newOrder[ 6 ], newOrder[ 7 ]));
+                  myLastCreatedElems.push_back(aMesh->AddFace(newOrder[ 0 ], newOrder[ 1 ],
+                                                              newOrder[ 2 ], newOrder[ 3 ],
+                                                              newOrder[ 4 ], newOrder[ 5 ],
+                                                              newOrder[ 6 ], newOrder[ 7 ]));
               }
             }
             else if ( nbn == 9 && isQuadratic ) /////// bi-quadratic quadrangle
@@ -5278,11 +4978,11 @@ void SMESH_MeshEditor::makeWalls (TNodeOfNodeListMap &     mapNewNodes,
                 if ( f )
                   aMesh->ChangeElementNodes( f, &newOrder[0], nbn );
                 else
-                  myLastCreatedElems.Append(aMesh->AddFace(newOrder[ 0 ], newOrder[ 1 ],
-                                                           newOrder[ 2 ], newOrder[ 3 ],
-                                                           newOrder[ 4 ], newOrder[ 5 ],
-                                                           newOrder[ 6 ], newOrder[ 7 ],
-                                                           newOrder[ 8 ]));
+                  myLastCreatedElems.push_back(aMesh->AddFace(newOrder[ 0 ], newOrder[ 1 ],
+                                                              newOrder[ 2 ], newOrder[ 3 ],
+                                                              newOrder[ 4 ], newOrder[ 5 ],
+                                                              newOrder[ 6 ], newOrder[ 7 ],
+                                                              newOrder[ 8 ]));
               }
             }
             else  //////// polygon
@@ -5301,8 +5001,8 @@ void SMESH_MeshEditor::makeWalls (TNodeOfNodeListMap &     mapNewNodes,
               }
             }
 
-            while ( srcElements.Length() < myLastCreatedElems.Length() )
-              srcElements.Append( *srcEdge );
+            while ( srcElements.size() < myLastCreatedElems.size() )
+              srcElements.push_back( *srcEdge );
 
           }  // loop on free faces
 
@@ -5339,8 +5039,8 @@ void SMESH_MeshEditor::makeWalls (TNodeOfNodeListMap &     mapNewNodes,
 
         AddElement( nodeVec, anyFace.Init( elem ));
 
-        while ( srcElements.Length() < myLastCreatedElems.Length() )
-          srcElements.Append( elem );
+        while ( srcElements.size() < myLastCreatedElems.size() )
+          srcElements.push_back( elem );
       }
     }
   } // loop on swept elements
@@ -5360,11 +5060,16 @@ SMESH_MeshEditor::RotationSweep(TIDSortedElemSet   theElemSets[2],
                                 const bool         theMakeGroups,
                                 const bool         theMakeWalls)
 {
-  myLastCreatedElems.Clear();
-  myLastCreatedNodes.Clear();
+  ClearLastCreated();
+
+  setElemsFirst( theElemSets );
+  myLastCreatedElems.reserve( theElemSets[0].size() * theNbSteps );
+  myLastCreatedNodes.reserve( theElemSets[1].size() * theNbSteps );
 
   // source elements for each generated one
   SMESH_SequenceOfElemPtr srcElems, srcNodes;
+  srcElems.reserve( theElemSets[0].size() );
+  srcNodes.reserve( theElemSets[1].size() );
 
   gp_Trsf aTrsf;
   aTrsf.SetRotation( theAxis, theAngle );
@@ -5384,7 +5089,6 @@ SMESH_MeshEditor::RotationSweep(TIDSortedElemSet   theElemSets[2],
                                      myMesh->NbFaces(ORDER_QUADRATIC) +
                                      myMesh->NbVolumes(ORDER_QUADRATIC) );
   // loop on theElemSets
-  setElemsFirst( theElemSets );
   TIDSortedElemSet::iterator itElem;
   for ( int is2ndSet = 0; is2ndSet < 2; ++is2ndSet )
   {
@@ -5436,8 +5140,8 @@ SMESH_MeshEditor::RotationSweep(TIDSortedElemSet   theElemSets[2],
               {
                 aTrsf2.Transforms( coord[0], coord[1], coord[2] );
                 newNode = aMesh->AddNode( coord[0], coord[1], coord[2] );
-                myLastCreatedNodes.Append(newNode);
-                srcNodes.Append( node );
+                myLastCreatedNodes.push_back(newNode);
+                srcNodes.push_back( node );
                 listNewNodes.push_back( newNode );
                 aTrsf2.Transforms( coord[0], coord[1], coord[2] );
               }
@@ -5446,8 +5150,8 @@ SMESH_MeshEditor::RotationSweep(TIDSortedElemSet   theElemSets[2],
               }
               // create a corner node
               newNode = aMesh->AddNode( coord[0], coord[1], coord[2] );
-              myLastCreatedNodes.Append(newNode);
-              srcNodes.Append( node );
+              myLastCreatedNodes.push_back(newNode);
+              srcNodes.push_back( node );
               listNewNodes.push_back( newNode );
             }
             else {
@@ -5753,12 +5457,12 @@ makeNodesByDirAndSew( SMESHDS_Mesh*                     mesh,
     P1 += myDir.XYZ() * nextStep();
 
     // try to search in sequence of existing nodes
-    // if myNodes.Length()>0 we 'nave to use given sequence
+    // if myNodes.size()>0 we 'nave to use given sequence
     // else - use all nodes of mesh
     const SMDS_MeshNode * node = 0;
     if ( myNodes.Length() > 0 ) {
       int i;
-      for(i=1; i<=myNodes.Length(); i++) {
+      for ( i = 1; i <= myNodes.Length(); i++ ) {
         gp_XYZ P2 = SMESH_TNodeXYZ( myNodes.Value(i) );
         if (( P1 - P2 ).SquareModulus() < myTolerance * myTolerance )
         {
@@ -5920,13 +5624,17 @@ SMESH_MeshEditor::ExtrusionSweep (TIDSortedElemSet     theElemSets[2],
                                   ExtrusParam&         theParams,
                                   TTElemOfElemListMap& newElemsMap)
 {
-  myLastCreatedElems.Clear();
-  myLastCreatedNodes.Clear();
+  ClearLastCreated();
+
+  setElemsFirst( theElemSets );
+  myLastCreatedElems.reserve( theElemSets[0].size() * theParams.NbSteps() );
+  myLastCreatedNodes.reserve( theElemSets[1].size() * theParams.NbSteps() );
 
   // source elements for each generated one
   SMESH_SequenceOfElemPtr srcElems, srcNodes;
+  srcElems.reserve( theElemSets[0].size() );
+  srcNodes.reserve( theElemSets[1].size() );
 
-  setElemsFirst( theElemSets );
   const int nbSteps = theParams.NbSteps();
   theParams.SetElementsToUse( theElemSets[0], theElemSets[1] );
 
@@ -5985,8 +5693,8 @@ SMESH_MeshEditor::ExtrusionSweep (TIDSortedElemSet     theElemSets[2],
             list<const SMDS_MeshNode*>::iterator newNodesIt = listNewNodes.begin();
             for ( ; newNodesIt != listNewNodes.end(); ++newNodesIt )
             {
-              myLastCreatedNodes.Append( *newNodesIt );
-              srcNodes.Append( node );
+              myLastCreatedNodes.push_back( *newNodesIt );
+              srcNodes.push_back( node );
             }
           }
           else
@@ -6027,8 +5735,7 @@ SMESH_MeshEditor::ExtrusionAlongTrack (TIDSortedElemSet     theElements[2],
                                        const gp_Pnt&        theRefPoint,
                                        const bool           theMakeGroups)
 {
-  myLastCreatedElems.Clear();
-  myLastCreatedNodes.Clear();
+  ClearLastCreated();
 
   int aNbE;
   std::list<double> aPrms;
@@ -6202,8 +5909,7 @@ SMESH_MeshEditor::ExtrusionAlongTrack (TIDSortedElemSet     theElements[2],
                                        const gp_Pnt&        theRefPoint,
                                        const bool           theMakeGroups)
 {
-  myLastCreatedElems.Clear();
-  myLastCreatedNodes.Clear();
+  ClearLastCreated();
 
   int aNbE;
   std::list<double> aPrms;
@@ -6682,13 +6388,13 @@ SMESH_MeshEditor::makeExtrElements(TIDSortedElemSet                  theElemSets
               // create additional node
               gp_XYZ midP = 0.5 * ( aPN1.XYZ() + aPN0.XYZ() );
               const SMDS_MeshNode* newNode = aMesh->AddNode( midP.X(), midP.Y(), midP.Z() );
-              myLastCreatedNodes.Append(newNode);
-              srcNodes.Append( node );
+              myLastCreatedNodes.push_back(newNode);
+              srcNodes.push_back( node );
               listNewNodes.push_back( newNode );
             }
             const SMDS_MeshNode* newNode = aMesh->AddNode( aPN1.X(), aPN1.Y(), aPN1.Z() );
-            myLastCreatedNodes.Append(newNode);
-            srcNodes.Append( node );
+            myLastCreatedNodes.push_back(newNode);
+            srcNodes.push_back( node );
             listNewNodes.push_back( newNode );
 
             aPN0 = aPN1;
@@ -6714,8 +6420,8 @@ SMESH_MeshEditor::makeExtrElements(TIDSortedElemSet                  theElemSets
               double y = ( N->Y() + P.Y() )/2.;
               double z = ( N->Z() + P.Z() )/2.;
               const SMDS_MeshNode* newN = aMesh->AddNode(x,y,z);
-              srcNodes.Append( node );
-              myLastCreatedNodes.Append(newN);
+              srcNodes.push_back( node );
+              myLastCreatedNodes.push_back(newN);
               aNodes[2*i] = newN;
               aNodes[2*i+1] = N;
               P = gp_XYZ(N->X(),N->Y(),N->Z());
@@ -6808,8 +6514,8 @@ SMESH_MeshEditor::Transform (TIDSortedElemSet & theElems,
                              const bool         theMakeGroups,
                              SMESH_Mesh*        theTargetMesh)
 {
-  myLastCreatedElems.Clear();
-  myLastCreatedNodes.Clear();
+  ClearLastCreated();
+  myLastCreatedElems.reserve( theElems.size() );
 
   bool needReverse = false;
   string groupPostfix;
@@ -6904,14 +6610,14 @@ SMESH_MeshEditor::Transform (TIDSortedElemSet & theElems,
         if ( theTargetMesh ) {
           const SMDS_MeshNode * newNode = aTgtMesh->AddNode( coord[0], coord[1], coord[2] );
           n2n_isnew.first->second = newNode;
-          myLastCreatedNodes.Append(newNode);
-          srcNodes.Append( node );
+          myLastCreatedNodes.push_back(newNode);
+          srcNodes.push_back( node );
         }
         else if ( theCopy ) {
           const SMDS_MeshNode * newNode = aMesh->AddNode( coord[0], coord[1], coord[2] );
           n2n_isnew.first->second = newNode;
-          myLastCreatedNodes.Append(newNode);
-          srcNodes.Append( node );
+          myLastCreatedNodes.push_back(newNode);
+          srcNodes.push_back( node );
         }
         else {
           aMesh->MoveNode( node, coord[0], coord[1], coord[2] );
@@ -7001,7 +6707,7 @@ SMESH_MeshEditor::Transform (TIDSortedElemSet & theElems,
     if ( editor ) {
       // copy in this or a new mesh
       if ( editor->AddElement( nodes, elemType.Init( elem, /*basicOnly=*/false )))
-        srcElems.Append( elem );
+        srcElems.push_back( elem );
     }
     else {
       // reverse element as it was reversed by transformation
@@ -7012,7 +6718,7 @@ SMESH_MeshEditor::Transform (TIDSortedElemSet & theElems,
   } // loop on elements
 
   if ( editor && editor != this )
-    myLastCreatedElems = editor->myLastCreatedElems;
+    myLastCreatedElems.swap( editor->myLastCreatedElems );
 
   PGroupIDs newGroupIDs;
 
@@ -7023,14 +6729,97 @@ SMESH_MeshEditor::Transform (TIDSortedElemSet & theElems,
   return newGroupIDs;
 }
 
+//================================================================================
+/*!
+ * \brief Make an offset mesh from a source 2D mesh
+ *  \param [in] theElements - source faces
+ *  \param [in] theValue - offset value
+ *  \param [out] theTgtMesh - a mesh to add offset elements to
+ *  \param [in] theMakeGroups - to generate groups
+ *  \return PGroupIDs - IDs of created groups
+ */
+//================================================================================
+
+SMESH_MeshEditor::PGroupIDs SMESH_MeshEditor::Offset( TIDSortedElemSet & theElements,
+                                                      const double       theValue,
+                                                      SMESH_Mesh*        theTgtMesh,
+                                                      const bool         theMakeGroups,
+                                                      const bool         theFixSelfIntersection)
+{
+  SMESHDS_Mesh*    meshDS = GetMeshDS();
+  SMESHDS_Mesh* tgtMeshDS = theTgtMesh->GetMeshDS();
+  SMESH_MeshEditor tgtEditor( theTgtMesh );
+
+  SMDS_ElemIteratorPtr eIt;
+  if ( theElements.empty() ) eIt = meshDS->elementsIterator( SMDSAbs_Face );
+  else                       eIt = SMESHUtils::elemSetIterator( theElements );
+
+  SMESH_MeshAlgos::TEPairVec new2OldFaces;
+  SMESH_MeshAlgos::TNPairVec new2OldNodes;
+  std::unique_ptr< SMDS_Mesh > offsetMesh
+    ( SMESH_MeshAlgos::MakeOffset( eIt, *meshDS, theValue,
+                                   theFixSelfIntersection,
+                                   new2OldFaces, new2OldNodes ));
+
+  offsetMesh->Modified();
+  offsetMesh->CompactMesh(); // make IDs start from 1
+
+  // source elements for each generated one
+  SMESH_SequenceOfElemPtr srcElems, srcNodes;
+  srcElems.reserve( new2OldFaces.size() );
+  srcNodes.reserve( new2OldNodes.size() );
+
+  ClearLastCreated();
+  myLastCreatedElems.reserve( new2OldFaces.size() );
+  myLastCreatedNodes.reserve( new2OldNodes.size() );
+
+  // copy offsetMesh to theTgtMesh
+
+  int idShift = meshDS->MaxNodeID();
+  for ( size_t i = 0; i < new2OldNodes.size(); ++i )
+    if ( const SMDS_MeshNode* n = new2OldNodes[ i ].first )
+    {
+      if ( n->NbInverseElements() > 0 )
+      {
+        const SMDS_MeshNode* n2 =
+          tgtMeshDS->AddNodeWithID( n->X(), n->Y(), n->Z(), idShift + n->GetID() );
+        myLastCreatedNodes.push_back( n2 );
+        srcNodes.push_back( new2OldNodes[ i ].second );
+      }
+    }
+
+  ElemFeatures elemType;
+  for ( size_t i = 0; i < new2OldFaces.size(); ++i )
+    if ( const SMDS_MeshElement* f = new2OldFaces[ i ].first )
+    {
+      elemType.Init( f );
+      elemType.myNodes.clear();
+      for ( SMDS_NodeIteratorPtr nIt = f->nodeIterator(); nIt->more(); )
+      {
+        const SMDS_MeshNode* n2 = nIt->next();
+        elemType.myNodes.push_back( tgtMeshDS->FindNode( idShift + n2->GetID() ));
+      }
+      tgtEditor.AddElement( elemType.myNodes, elemType );
+      srcElems.push_back( new2OldFaces[ i ].second );
+    }
+
+  myLastCreatedElems.swap( tgtEditor.myLastCreatedElems );
+
+  PGroupIDs newGroupIDs;
+  if ( theMakeGroups )
+    newGroupIDs = generateGroups( srcNodes, srcElems, "offset", theTgtMesh, false );
+
+  return newGroupIDs;
+}
+
 //=======================================================================
 /*!
  * \brief Create groups of elements made during transformation
  *  \param nodeGens - nodes making corresponding myLastCreatedNodes
  *  \param elemGens - elements making corresponding myLastCreatedElems
- *  \param postfix - to append to names of new groups
+ *  \param postfix - to push_back to names of new groups
  *  \param targetMesh - mesh to create groups in
- *  \param topPresent - is there "top" elements that are created by sweeping
+ *  \param topPresent - is there are "top" elements that are created by sweeping
  */
 //=======================================================================
 
@@ -7083,30 +6872,30 @@ SMESH_MeshEditor::generateGroups(const SMESH_SequenceOfElemPtr& nodeGens,
   {
     const SMESH_SequenceOfElemPtr& gens  = isNodes ? nodeGens : elemGens;
     const SMESH_SequenceOfElemPtr& elems = isNodes ? myLastCreatedNodes : myLastCreatedElems;
-    if ( gens.Length() != elems.Length() )
+    if ( gens.size() != elems.size() )
       throw SALOME_Exception("SMESH_MeshEditor::generateGroups(): invalid args");
 
     // loop on created elements
-    for (int iElem = 1; iElem <= elems.Length(); ++iElem )
+    for (size_t iElem = 0; iElem < elems.size(); ++iElem )
     {
-      const SMDS_MeshElement* sourceElem = gens( iElem );
+      const SMDS_MeshElement* sourceElem = gens[ iElem ];
       if ( !sourceElem ) {
         MESSAGE("generateGroups(): NULL source element");
         continue;
       }
       list< TOldNewGroup > & groupsOldNew = groupsByType[ sourceElem->GetType() ];
       if ( groupsOldNew.empty() ) { // no groups of this type at all
-        while ( iElem < gens.Length() && gens( iElem+1 ) == sourceElem )
+        while ( iElem+1 < gens.size() && gens[ iElem+1 ] == sourceElem )
           ++iElem; // skip all elements made by sourceElem
         continue;
       }
       // collect all elements made by the iElem-th sourceElem
       resultElems.clear();
-      if ( const SMDS_MeshElement* resElem = elems( iElem ))
+      if ( const SMDS_MeshElement* resElem = elems[ iElem ])
         if ( resElem != sourceElem )
           resultElems.push_back( resElem );
-      while ( iElem < gens.Length() && gens( iElem+1 ) == sourceElem )
-        if ( const SMDS_MeshElement* resElem = elems( ++iElem ))
+      while ( iElem+1 < gens.size() && gens[ iElem+1 ] == sourceElem )
+        if ( const SMDS_MeshElement* resElem = elems[ ++iElem ])
           if ( resElem != sourceElem )
             resultElems.push_back( resElem );
 
@@ -7146,7 +6935,7 @@ SMESH_MeshEditor::generateGroups(const SMESH_SequenceOfElemPtr& nodeGens,
           {
             SMDS_MeshGroup & newTopGroup = gOldNew->get<2>()->SMDSGroup();
             newTopGroup.Add( topElem );
-         }
+          }
         }
       }
     } // loop on created elements
@@ -7233,8 +7022,7 @@ void SMESH_MeshEditor::FindCoincidentNodes (TIDSortedNodeSet &   theNodes,
                                             TListOfListOfNodes & theGroupsOfNodes,
                                             bool                 theSeparateCornersAndMedium)
 {
-  myLastCreatedElems.Clear();
-  myLastCreatedNodes.Clear();
+  ClearLastCreated();
 
   if ( myMesh->NbEdges  ( ORDER_QUADRATIC ) +
        myMesh->NbFaces  ( ORDER_QUADRATIC ) +
@@ -7347,8 +7135,7 @@ int SMESH_MeshEditor::SimplifyFace (const vector<const SMDS_MeshNode *>& faceNod
 void SMESH_MeshEditor::MergeNodes (TListOfListOfNodes & theGroupsOfNodes,
                                    const bool           theAvoidMakingHoles)
 {
-  myLastCreatedElems.Clear();
-  myLastCreatedNodes.Clear();
+  ClearLastCreated();
 
   SMESHDS_Mesh* mesh = GetMeshDS();
 
@@ -7973,15 +7760,14 @@ private:
 void SMESH_MeshEditor::FindEqualElements(TIDSortedElemSet &        theElements,
                                          TListOfListOfElementsID & theGroupsOfElementsID)
 {
-  myLastCreatedElems.Clear();
-  myLastCreatedNodes.Clear();
+  ClearLastCreated();
 
   typedef map< SortableElement, int > TMapOfNodeSet;
   typedef list<int> TGroupOfElems;
 
   SMDS_ElemIteratorPtr elemIt;
   if ( theElements.empty() ) elemIt = GetMeshDS()->elementsIterator();
-  else                       elemIt = elemSetIterator( theElements );
+  else                       elemIt = SMESHUtils::elemSetIterator( theElements );
 
   vector< TGroupOfElems > arrayOfGroups;
   TGroupOfElems groupOfElems;
@@ -8024,8 +7810,7 @@ void SMESH_MeshEditor::FindEqualElements(TIDSortedElemSet &        theElements,
 
 void SMESH_MeshEditor::MergeElements(TListOfListOfElementsID & theGroupsOfElementsID)
 {
-  myLastCreatedElems.Clear();
-  myLastCreatedNodes.Clear();
+  ClearLastCreated();
 
   typedef list<int> TListOfIDs;
   TListOfIDs rmElemIds; // IDs of elems to remove
@@ -8227,7 +8012,7 @@ bool SMESH_MeshEditor::FindFreeBorder (const SMDS_MeshNode*             theFirst
       if ( contNodes[0].empty() && contNodes[1].empty() )
         return false;
 
-      // append the best free border
+      // push_back the best free border
       cNL = & contNodes[ contNodes[0].empty() ? 1 : 0 ];
       cFL = & contFaces[ contFaces[0].empty() ? 1 : 0 ];
       theNodes.pop_back(); // remove nIgnore
@@ -8277,8 +8062,7 @@ SMESH_MeshEditor::SewFreeBorder (const SMDS_MeshNode* theBordFirstNode,
                                  const bool           toCreatePolygons,
                                  const bool           toCreatePolyedrs)
 {
-  myLastCreatedElems.Clear();
-  myLastCreatedNodes.Clear();
+  ClearLastCreated();
 
   Sew_Error aResult = SEW_OK;
 
@@ -8731,13 +8515,13 @@ SMESH_MeshEditor::SewFreeBorder (const SMDS_MeshNode* theBordFirstNode,
   // get new segments
   TIDSortedElemSet segments;
   SMESH_SequenceOfElemPtr newFaces;
-  for ( int i = 1; i <= myLastCreatedElems.Length(); ++i )
+  for ( size_t i = 0; i < myLastCreatedElems.size(); ++i )
   {
-    if ( !myLastCreatedElems(i) ) continue;
-    if ( myLastCreatedElems(i)->GetType() == SMDSAbs_Edge )
-      segments.insert( segments.end(), myLastCreatedElems(i) );
+    if ( !myLastCreatedElems[i] ) continue;
+    if ( myLastCreatedElems[i]->GetType() == SMDSAbs_Edge )
+      segments.insert( segments.end(), myLastCreatedElems[i] );
     else
-      newFaces.Append( myLastCreatedElems(i) );
+      newFaces.push_back( myLastCreatedElems[i] );
   }
   // get segments adjacent to merged nodes
   TListOfListOfNodes::iterator groupIt = nodeGroupsToMerge.begin();
@@ -8772,7 +8556,7 @@ SMESH_MeshEditor::SewFreeBorder (const SMDS_MeshNode* theBordFirstNode,
     myLastCreatedElems = newFaces;
     TIDSortedElemSet::iterator seg = segments.begin();
     for ( ; seg != segments.end(); ++seg )
-      myLastCreatedElems.Append( *seg );
+      myLastCreatedElems.push_back( *seg );
   }
 
   return aResult;
@@ -8842,7 +8626,7 @@ void SMESH_MeshEditor::InsertNodesIntoLink(const SMDS_MeshElement*     theElemen
       if ( newElems[i] )
       {
         aMesh->SetMeshElementOnShape( newElems[i], theElement->getshapeId() );
-        myLastCreatedElems.Append( newElems[i] );
+        myLastCreatedElems.push_back( newElems[i] );
       }
     ReplaceElemInGroups( theElement, newElems, aMesh );
     aMesh->RemoveElement( theElement );
@@ -9103,7 +8887,7 @@ void SMESH_MeshEditor::InsertNodesIntoLink(const SMDS_MeshElement*     theElemen
     if ( newElems[i] )
     {
       aMesh->SetMeshElementOnShape( newElems[i], theFace->getshapeId() );
-      myLastCreatedElems.Append( newElems[i] );
+      myLastCreatedElems.push_back( newElems[i] );
     }
   ReplaceElemInGroups( theFace, newElems, aMesh );
   aMesh->RemoveElement(theFace);
@@ -9119,8 +8903,7 @@ void SMESH_MeshEditor::UpdateVolumes (const SMDS_MeshNode*        theBetweenNode
                                       const SMDS_MeshNode*        theBetweenNode2,
                                       list<const SMDS_MeshNode*>& theNodesToInsert)
 {
-  myLastCreatedElems.Clear();
-  myLastCreatedNodes.Clear();
+  ClearLastCreated();
 
   SMDS_ElemIteratorPtr invElemIt = theBetweenNode1->GetInverseElementIterator(SMDSAbs_Volume);
   while (invElemIt->more()) { // loop on inverse elements of theBetweenNode1
@@ -9182,7 +8965,7 @@ void SMESH_MeshEditor::UpdateVolumes (const SMDS_MeshNode*        theBetweenNode
     if ( SMDS_MeshElement* newElem = aMesh->AddPolyhedralVolume( poly_nodes, quantities ))
     {
       aMesh->SetMeshElementOnShape( newElem, elem->getshapeId() );
-      myLastCreatedElems.Append( newElem );
+      myLastCreatedElems.push_back( newElem );
       ReplaceElemInGroups( elem, newElem, aMesh );
     }
     aMesh->RemoveElement( elem );
@@ -9300,52 +9083,52 @@ int SMESH_MeshEditor::convertElemToQuadratic(SMESHDS_SubMesh *   theSm,
     switch( aType )
     {
     case SMDSAbs_Edge :
-      {
-        NewElem = theHelper.AddEdge(nodes[0], nodes[1], id, theForce3d);
-        break;
-      }
+    {
+      NewElem = theHelper.AddEdge(nodes[0], nodes[1], id, theForce3d);
+      break;
+    }
     case SMDSAbs_Face :
+    {
+      switch(nbNodes)
       {
-        switch(nbNodes)
-        {
-        case 3:
-          NewElem = theHelper.AddFace(nodes[0], nodes[1], nodes[2], id, theForce3d);
-          break;
-        case 4:
-          NewElem = theHelper.AddFace(nodes[0], nodes[1], nodes[2], nodes[3], id, theForce3d);
-          break;
-        default:
-          NewElem = theHelper.AddPolygonalFace(nodes, id, theForce3d);
-        }
+      case 3:
+        NewElem = theHelper.AddFace(nodes[0], nodes[1], nodes[2], id, theForce3d);
+        break;
+      case 4:
+        NewElem = theHelper.AddFace(nodes[0], nodes[1], nodes[2], nodes[3], id, theForce3d);
         break;
+      default:
+        NewElem = theHelper.AddPolygonalFace(nodes, id, theForce3d);
       }
+      break;
+    }
     case SMDSAbs_Volume :
+    {
+      switch( aGeomType )
       {
-        switch( aGeomType )
-        {
-        case SMDSEntity_Tetra:
-          NewElem = theHelper.AddVolume(nodes[0], nodes[1], nodes[2], nodes[3], id, theForce3d);
-          break;
-        case SMDSEntity_Pyramid:
-          NewElem = theHelper.AddVolume(nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], id, theForce3d);
-          break;
-        case SMDSEntity_Penta:
-        case SMDSEntity_Quad_Penta:
-        case SMDSEntity_BiQuad_Penta:
-          NewElem = theHelper.AddVolume(nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5], id, theForce3d);
-          break;
-        case SMDSEntity_Hexa:
-        case SMDSEntity_Quad_Hexa:
-        case SMDSEntity_TriQuad_Hexa:
-          NewElem = theHelper.AddVolume(nodes[0], nodes[1], nodes[2], nodes[3],
-                                        nodes[4], nodes[5], nodes[6], nodes[7], id, theForce3d);
-          break;
-        case SMDSEntity_Hexagonal_Prism:
-        default:
-          NewElem = theHelper.AddPolyhedralVolume(nodes, nbNodeInFaces, id, theForce3d);
-        }
+      case SMDSEntity_Tetra:
+        NewElem = theHelper.AddVolume(nodes[0], nodes[1], nodes[2], nodes[3], id, theForce3d);
         break;
+      case SMDSEntity_Pyramid:
+        NewElem = theHelper.AddVolume(nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], id, theForce3d);
+        break;
+      case SMDSEntity_Penta:
+      case SMDSEntity_Quad_Penta:
+      case SMDSEntity_BiQuad_Penta:
+        NewElem = theHelper.AddVolume(nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5], id, theForce3d);
+        break;
+      case SMDSEntity_Hexa:
+      case SMDSEntity_Quad_Hexa:
+      case SMDSEntity_TriQuad_Hexa:
+        NewElem = theHelper.AddVolume(nodes[0], nodes[1], nodes[2], nodes[3],
+                                      nodes[4], nodes[5], nodes[6], nodes[7], id, theForce3d);
+        break;
+      case SMDSEntity_Hexagonal_Prism:
+      default:
+        NewElem = theHelper.AddPolyhedralVolume(nodes, nbNodeInFaces, id, theForce3d);
       }
+      break;
+    }
     default :
       continue;
     }
@@ -9723,7 +9506,7 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool        theForce3d,
     if( newElem && smDS )
       smDS->AddElement( newElem );
 
-     // remove central nodes
+    // remove central nodes
     for ( size_t i = nodes.size() - nbCentralNodes; i < nodes.size(); ++i )
       if ( nodes[i]->NbInverseElements() == 0 )
         meshDS->RemoveFreeNode( nodes[i], smDS, /*fromGroups=*/true );
@@ -9857,7 +9640,7 @@ void SMESH_MeshEditor::ConvertFromQuadratic(TIDSortedElemSet& theElements)
   }
 
   // replace given elements by linear ones
-  SMDS_ElemIteratorPtr elemIt = elemSetIterator( theElements );
+  SMDS_ElemIteratorPtr elemIt = SMESHUtils::elemSetIterator( theElements );
   removeQuadElem( /*theSm=*/0, elemIt, /*theShapeID=*/0 );
 
   // we need to convert remaining elements whose all medium nodes are in mediumNodeIDs
@@ -9909,7 +9692,7 @@ void SMESH_MeshEditor::ConvertFromQuadratic(TIDSortedElemSet& theElements)
       }
     }
   }
-  elemIt = elemSetIterator( moreElemsToConvert );
+  elemIt = SMESHUtils::elemSetIterator( moreElemsToConvert );
   removeQuadElem( /*theSm=*/0, elemIt, /*theShapeID=*/0 );
 }
 
@@ -9926,8 +9709,7 @@ SMESH_MeshEditor::SewSideElements (TIDSortedElemSet&    theSide1,
                                    const SMDS_MeshNode* theSecondNode1,
                                    const SMDS_MeshNode* theSecondNode2)
 {
-  myLastCreatedElems.Clear();
-  myLastCreatedNodes.Clear();
+  ClearLastCreated();
 
   if ( theSide1.size() != theSide2.size() )
     return SEW_DIFF_NB_OF_ELEMENTS;
@@ -10203,12 +9985,12 @@ SMESH_MeshEditor::SewSideElements (TIDSortedElemSet&    theSide1,
 
   if ( faceSet1.size() != faceSet2.size() ) {
     // delete temporary faces: they are in reverseElements of actual nodes
-//    SMDS_FaceIteratorPtr tmpFaceIt = aTmpFacesMesh.facesIterator();
-//    while ( tmpFaceIt->more() )
-//      aTmpFacesMesh.RemoveElement( tmpFaceIt->next() );
-//    list<const SMDS_MeshElement* >::iterator tmpFaceIt = tempFaceList.begin();
-//    for (; tmpFaceIt !=tempFaceList.end(); ++tmpFaceIt)
-//      aMesh->RemoveElement(*tmpFaceIt);
+    //    SMDS_FaceIteratorPtr tmpFaceIt = aTmpFacesMesh.facesIterator();
+    //    while ( tmpFaceIt->more() )
+    //      aTmpFacesMesh.RemoveElement( tmpFaceIt->next() );
+    //    list<const SMDS_MeshElement* >::iterator tmpFaceIt = tempFaceList.begin();
+    //    for (; tmpFaceIt !=tempFaceList.end(); ++tmpFaceIt)
+    //      aMesh->RemoveElement(*tmpFaceIt);
     MESSAGE("Diff nb of faces");
     return SEW_TOPO_DIFF_SETS_OF_ELEMENTS;
   }
@@ -10347,7 +10129,7 @@ SMESH_MeshEditor::SewSideElements (TIDSortedElemSet&    theSide1,
 
   if ( aResult == SEW_OK &&
        ( //linkIt[0] != linkList[0].end() ||
-         !faceSetPtr[0]->empty() || !faceSetPtr[1]->empty() )) {
+        !faceSetPtr[0]->empty() || !faceSetPtr[1]->empty() )) {
     MESSAGE( (linkIt[0] != linkList[0].end()) <<" "<< (faceSetPtr[0]->empty()) <<
              " " << (faceSetPtr[1]->empty()));
     aResult = SEW_TOPO_DIFF_SETS_OF_ELEMENTS;
@@ -10358,9 +10140,9 @@ SMESH_MeshEditor::SewSideElements (TIDSortedElemSet&    theSide1,
   // ====================================================================
 
   // delete temporary faces
-//  SMDS_FaceIteratorPtr tmpFaceIt = aTmpFacesMesh.facesIterator();
-//  while ( tmpFaceIt->more() )
-//    aTmpFacesMesh.RemoveElement( tmpFaceIt->next() );
+  //  SMDS_FaceIteratorPtr tmpFaceIt = aTmpFacesMesh.facesIterator();
+  //  while ( tmpFaceIt->more() )
+  //    aTmpFacesMesh.RemoveElement( tmpFaceIt->next() );
   list<const SMDS_MeshElement* >::iterator tmpFaceIt = tempFaceList.begin();
   for (; tmpFaceIt !=tempFaceList.end(); ++tmpFaceIt)
     aMesh->RemoveElement(*tmpFaceIt);
@@ -11182,7 +10964,7 @@ void SMESH_MeshEditor::DoubleElements( const TIDSortedElemSet& theElements )
   else
   {
     type = (*theElements.begin())->GetType();
-    elemIt = elemSetIterator( theElements );
+    elemIt = SMESHUtils::elemSetIterator( theElements );
   }
 
   // un-mark all elements to avoid duplicating just created elements
@@ -11291,7 +11073,7 @@ bool SMESH_MeshEditor::doubleNodes(SMESHDS_Mesh*           theMeshDS,
         aNewNode = theMeshDS->AddNode( aCurrNode->X(), aCurrNode->Y(), aCurrNode->Z() );
         copyPosition( aCurrNode, aNewNode );
         theNodeNodeMap[ aCurrNode ] = aNewNode;
-        myLastCreatedNodes.Append( aNewNode );
+        myLastCreatedNodes.push_back( aNewNode );
       }
       isDuplicate |= (aCurrNode != aNewNode);
       newNodes[ ind++ ] = aNewNode;
@@ -11350,7 +11132,7 @@ bool SMESH_MeshEditor::DoubleNodes( const std::list< int >& theListOfNodes,
     {
       copyPosition( aNode, aNewNode );
       anOldNodeToNewNode[ aNode ] = aNewNode;
-      myLastCreatedNodes.Append( aNewNode );
+      myLastCreatedNodes.push_back( aNewNode );
     }
   }
 
@@ -11385,8 +11167,8 @@ namespace {
 
   //================================================================================
   /*!
-  \brief Check if element located inside shape
-  \return TRUE if IN or ON shape, FALSE otherwise
+    \brief Check if element located inside shape
+    \return TRUE if IN or ON shape, FALSE otherwise
   */
   //================================================================================
 
@@ -13019,7 +12801,7 @@ int SMESH_MeshEditor::MakeBoundaryMesh(const TIDSortedElemSet& elements,
 
   SMDS_ElemIteratorPtr eIt;
   if (elements.empty()) eIt = aMesh->elementsIterator(elemType);
-  else                  eIt = elemSetIterator( elements );
+  else                  eIt = SMESHUtils::elemSetIterator( elements );
 
   while (eIt->more())
   {
@@ -13198,7 +12980,7 @@ int SMESH_MeshEditor::MakeBoundaryMesh(const TIDSortedElemSet& elements,
     else // store present elements to add them to a group
       for ( size_t i = 0 ; i < presentBndElems.size(); ++i )
       {
-        presentEditor->myLastCreatedElems.Append( presentBndElems[ i ]);
+        presentEditor->myLastCreatedElems.push_back( presentBndElems[ i ]);
       }
 
   } // loop on given elements
@@ -13209,11 +12991,11 @@ int SMESH_MeshEditor::MakeBoundaryMesh(const TIDSortedElemSet& elements,
   if ( group )
   {
     if ( SMESHDS_Group* g = dynamic_cast<SMESHDS_Group*>( group->GetGroupDS() ))
-      for ( int i = 0; i < tgtEditor.myLastCreatedElems.Size(); ++i )
-        g->SMDSGroup().Add( tgtEditor.myLastCreatedElems( i+1 ));
+      for ( size_t i = 0; i < tgtEditor.myLastCreatedElems.size(); ++i )
+        g->SMDSGroup().Add( tgtEditor.myLastCreatedElems[ i ]);
   }
-  tgtEditor.myLastCreatedElems.Clear();
-  tgtEditor2.myLastCreatedElems.Clear();
+  tgtEditor.myLastCreatedElems.clear();
+  tgtEditor2.myLastCreatedElems.clear();
 
   // -----------------------
   // 5. Copy given elements
@@ -13221,7 +13003,7 @@ int SMESH_MeshEditor::MakeBoundaryMesh(const TIDSortedElemSet& elements,
   if ( toCopyElements && targetMesh != myMesh )
   {
     if (elements.empty()) eIt = aMesh->elementsIterator(elemType);
-    else                  eIt = elemSetIterator( elements );
+    else                  eIt = SMESHUtils::elemSetIterator( elements );
     while (eIt->more())
     {
       const SMDS_MeshElement* elem = eIt->next();
@@ -13230,7 +13012,7 @@ int SMESH_MeshEditor::MakeBoundaryMesh(const TIDSortedElemSet& elements,
         tgtNodes[inode] = getNodeWithSameID( tgtMeshDS, elem->GetNode(inode) );
       tgtEditor.AddElement( tgtNodes, elemToCopy.Init( elem ));
 
-      tgtEditor.myLastCreatedElems.Clear();
+      tgtEditor.myLastCreatedElems.clear();
     }
   }
   return nbAddedBnd;
@@ -13716,15 +13498,15 @@ void SMESH_MeshEditor::MakePolyLine( TListOfPolySegments&   theSegments,
     if ( !nPrev || ( SMESH_NodeXYZ( nPrev ) - path.myPoints[0] ).SquareModulus() > tol*tol )
     {
       nPrev = mesh->AddNode( path.myPoints[0].X(), path.myPoints[0].Y(), path.myPoints[0].Z() );
-      myLastCreatedNodes.Append( nPrev );
+      myLastCreatedNodes.push_back( nPrev );
     }
     for ( size_t iP = 1; iP < path.myPoints.size(); ++iP )
     {
       n = mesh->AddNode( path.myPoints[iP].X(), path.myPoints[iP].Y(), path.myPoints[iP].Z() );
-      myLastCreatedNodes.Append( n );
+      myLastCreatedNodes.push_back( n );
 
       const SMDS_MeshElement* elem = mesh->AddEdge( nPrev, n );
-      myLastCreatedElems.Append( elem );
+      myLastCreatedElems.push_back( elem );
       if ( theGroup )
         theGroup->Add( elem );
 
index 9a54cb7..a864e4d 100644 (file)
@@ -465,6 +465,13 @@ public:
                        SMESH_Mesh*        theTargetMesh=0);
   // Move or copy theElements applying theTrsf to their nodes
 
+  PGroupIDs Offset( TIDSortedElemSet & theElements,
+                    const double       theValue,
+                    SMESH_Mesh*        theTgtMesh,
+                    const bool         theMakeGroups,
+                    const bool         theFixSelfIntersection);
+  // Make an offset mesh from a source 2D mesh
+
   typedef std::list< std::list< const SMDS_MeshNode* > > TListOfListOfNodes;
 
   void FindCoincidentNodes (TIDSortedNodeSet &   theNodes,
index 0a9251a..242900a 100644 (file)
@@ -4143,9 +4143,9 @@ namespace { // Structures used by FixQuadraticElements()
   {
     // code is valid for convex faces only
     gp_XYZ gc(0,0,0);
-    for ( TIDSortedNodeSet::const_iterator n = begin(); n!=end(); ++n)
-      gc += XYZ( *n ) / size();
-    for (unsigned i = 0; i < _sides.size(); ++i )
+    for ( TIDSortedNodeSet::const_iterator n = begin(); n != end(); ++n )
+      gc += XYZ( *n ) / double( size() );
+    for ( size_t i = 0; i < _sides.size(); ++i )
     {
       if ( _sides[i] == bentLink ) continue;
       gp_Vec linkNorm = _normal ^ gp_Vec( XYZ(_sides[i]->node1()), XYZ(_sides[i]->node2()));
@@ -4161,12 +4161,12 @@ namespace { // Structures used by FixQuadraticElements()
         return true;
     }
     return false;
-    
+
   }
 
   //================================================================================
   /*!
-   * \brief Find pairs of continues faces 
+   * \brief Find pairs of continues faces
    */
   //================================================================================
 
index b3acd18..4569e5e 100644 (file)
@@ -111,6 +111,7 @@ SET(_moc_HEADERS
   SMESHGUI_RotationDlg.h
   SMESHGUI_TranslationDlg.h
   SMESHGUI_ScaleDlg.h
+  SMESHGUI_OffsetDlg.h
   SMESHGUI_SymmetryDlg.h
   SMESHGUI_SewingDlg.h
   SMESHGUI_DuplicateNodesDlg.h
@@ -206,6 +207,7 @@ SET(_other_SOURCES
   SMESHGUI_RotationDlg.cxx
   SMESHGUI_TranslationDlg.cxx
   SMESHGUI_ScaleDlg.cxx
+  SMESHGUI_OffsetDlg.cxx
   SMESHGUI_SymmetryDlg.cxx
   SMESHGUI_SewingDlg.cxx
   SMESHGUI_DuplicateNodesDlg.cxx
index f85aa4a..54cd3a3 100644 (file)
@@ -74,6 +74,7 @@
 #include "SMESHGUI_RevolutionDlg.h"
 #include "SMESHGUI_RotationDlg.h"
 #include "SMESHGUI_ScaleDlg.h"
+#include "SMESHGUI_OffsetDlg.h"
 #include "SMESHGUI_Selection.h"
 #include "SMESHGUI_SewingDlg.h"
 #include "SMESHGUI_SingleEditDlg.h"
@@ -3534,6 +3535,20 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
       break;
     }
 
+  case SMESHOp::OpOffset:
+    {
+      if(checkLock(aStudy)) break;
+      if ( vtkwnd ) {
+        EmitSignalDeactivateDialog();
+        ( new SMESHGUI_OffsetDlg( this ) )->show();
+      }
+      else {
+        SUIT_MessageBox::warning(SMESHGUI::desktop(),
+                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
+      }
+      break;
+    }
+
   case SMESHOp::OpSewing:
     {
       if(checkLock(aStudy)) break;
@@ -3984,6 +3999,7 @@ void SMESHGUI::initialize( CAM_Application* app )
   createSMESHAction( SMESHOp::OpRotation,               "ROT",             "ICON_DLG_MESH_ROTATION" );
   createSMESHAction( SMESHOp::OpSymmetry,               "SYM",             "ICON_SMESH_SYMMETRY_PLANE" );
   createSMESHAction( SMESHOp::OpScale,                  "SCALE",           "ICON_DLG_MESH_SCALE" );
+  createSMESHAction( SMESHOp::OpOffset,                 "OFFSET",          "ICON_DLG_MESH_OFFSET" );
   createSMESHAction( SMESHOp::OpSewing,                 "SEW",             "ICON_SMESH_SEWING_FREEBORDERS" );
   createSMESHAction( SMESHOp::OpMergeNodes,             "MERGE",           "ICON_SMESH_MERGE_NODES" );
   createSMESHAction( SMESHOp::OpMergeElements,          "MERGE_ELEMENTS",  "ICON_DLG_MERGE_ELEMENTS" );
@@ -4222,31 +4238,32 @@ void SMESHGUI::initialize( CAM_Application* app )
   //createMenu( SMESHOp::OpRenumberingNodes,    renumId, -1 );
   //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
 
+  createMenu( SMESHOp::OpMergeNodes,     transfId, -1 );
+  createMenu( SMESHOp::OpMergeElements,  transfId, -1 );
   createMenu( SMESHOp::OpTranslation,    transfId, -1 );
   createMenu( SMESHOp::OpRotation,       transfId, -1 );
   createMenu( SMESHOp::OpSymmetry,       transfId, -1 );
   createMenu( SMESHOp::OpScale,          transfId, -1 );
+  createMenu( SMESHOp::OpOffset,         transfId, -1 );
   createMenu( SMESHOp::OpSewing,         transfId, -1 );
-  createMenu( SMESHOp::OpMergeNodes,     transfId, -1 );
-  createMenu( SMESHOp::OpMergeElements,  transfId, -1 );
   createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
 
+  createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
+  createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
+  createMenu( SMESHOp::OpExtrusion,              modifyId, -1 );
+  createMenu( SMESHOp::OpExtrusionAlongAPath,    modifyId, -1 );
+  createMenu( SMESHOp::OpRevolution,             modifyId, -1 );
+  createMenu( SMESHOp::OpOrientation,            modifyId, -1 );
+  createMenu( SMESHOp::OpReorientFaces,          modifyId, -1 );
   createMenu( SMESHOp::OpMoveNode,               modifyId, -1 );
   createMenu( SMESHOp::OpDiagonalInversion,      modifyId, -1 );
   createMenu( SMESHOp::OpUnionOfTwoTriangle,     modifyId, -1 );
-  createMenu( SMESHOp::OpOrientation,            modifyId, -1 );
-  createMenu( SMESHOp::OpReorientFaces,          modifyId, -1 );
   createMenu( SMESHOp::OpUnionOfTriangles,       modifyId, -1 );
   createMenu( SMESHOp::OpCuttingOfQuadrangles,   modifyId, -1 );
   createMenu( SMESHOp::OpSplitVolumes,           modifyId, -1 );
   createMenu( SMESHOp::OpSplitBiQuadratic,       modifyId, -1 );
   createMenu( SMESHOp::OpSmoothing,              modifyId, -1 );
-  createMenu( SMESHOp::OpExtrusion,              modifyId, -1 );
-  createMenu( SMESHOp::OpExtrusionAlongAPath ,   modifyId, -1 );
-  createMenu( SMESHOp::OpRevolution,             modifyId, -1 );
   createMenu( SMESHOp::OpPatternMapping,         modifyId, -1 );
-  createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
-  createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
 
   createMenu( SMESHOp::OpMinimumDistance,  measureId,   -1 );
   createMenu( SMESHOp::OpBoundingBox,      measureId,   -1 );
@@ -4366,31 +4383,32 @@ void SMESHGUI::initialize( CAM_Application* app )
   //createTool( SMESHOp::OpRenumberingNodes,    renumbTb );
   //createTool( SMESHOp::OpRenumberingElements, renumbTb );
 
+  createTool( SMESHOp::OpMergeNodes,     transformTb );
+  createTool( SMESHOp::OpMergeElements,  transformTb );
   createTool( SMESHOp::OpTranslation,    transformTb );
   createTool( SMESHOp::OpRotation,       transformTb );
   createTool( SMESHOp::OpSymmetry,       transformTb );
   createTool( SMESHOp::OpScale,          transformTb );
+  createTool( SMESHOp::OpOffset,         transformTb );
   createTool( SMESHOp::OpSewing,         transformTb );
-  createTool( SMESHOp::OpMergeNodes,     transformTb );
-  createTool( SMESHOp::OpMergeElements,  transformTb );
   createTool( SMESHOp::OpDuplicateNodes, transformTb );
 
+  createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
+  createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
+  createTool( SMESHOp::OpExtrusion,              modifyTb );
+  createTool( SMESHOp::OpExtrusionAlongAPath,    modifyTb );
+  createTool( SMESHOp::OpRevolution,             modifyTb );
+  createTool( SMESHOp::OpOrientation,            modifyTb );
+  createTool( SMESHOp::OpReorientFaces,          modifyTb );
   createTool( SMESHOp::OpMoveNode,               modifyTb );
   createTool( SMESHOp::OpDiagonalInversion,      modifyTb );
   createTool( SMESHOp::OpUnionOfTwoTriangle,     modifyTb );
-  createTool( SMESHOp::OpOrientation,            modifyTb );
-  createTool( SMESHOp::OpReorientFaces,          modifyTb );
   createTool( SMESHOp::OpUnionOfTriangles,       modifyTb );
   createTool( SMESHOp::OpCuttingOfQuadrangles,   modifyTb );
   createTool( SMESHOp::OpSplitVolumes,           modifyTb );
   createTool( SMESHOp::OpSplitBiQuadratic,       modifyTb );
   createTool( SMESHOp::OpSmoothing,              modifyTb );
-  createTool( SMESHOp::OpExtrusion,              modifyTb );
-  createTool( SMESHOp::OpExtrusionAlongAPath,    modifyTb );
-  createTool( SMESHOp::OpRevolution,             modifyTb );
   createTool( SMESHOp::OpPatternMapping,         modifyTb );
-  createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
-  createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
 
   createTool( SMESHOp::OpMinimumDistance, measuremTb );
 
index 25bbd46..a956989 100644 (file)
@@ -40,7 +40,7 @@
 #include <SMESH_FaceOrientationFilter.h>
 #include <SMDS_Mesh.hxx>
 
-// SALOME GUI inclues
+// SALOME GUI includes
 #include <SUIT_Desktop.h>
 #include <SUIT_Session.h>
 #include <SUIT_ResourceMgr.h>
@@ -56,7 +56,7 @@
 #include <Qtx.h>
 
 
-// IDL incldues
+// IDL includes
 #include CORBA_SERVER_HEADER(SMESH_MeshEditor)
 
 // OCCT includes
@@ -777,7 +777,7 @@ void SMESHGUI_AddMeshElementDlg::onTextChange (const QString& theNewText)
 
   mySimulation->SetVisibility(false);
 
-  // hilight entered nodes
+  // highlight entered nodes
   SMDS_Mesh* aMesh = 0;
   if (myActor)
     aMesh = myActor->GetObject()->GetMesh();
index 4193be4..427e65a 100644 (file)
@@ -977,7 +977,7 @@ void SMESHGUI_AddQuadraticElementDlg::onTextChange (const QString& theNewText)
 
   mySimulation->SetVisibility(false);
 
-  // hilight entered nodes
+  // highlight entered nodes
   SMDS_Mesh* aMesh = 0;
   if (myActor)
     aMesh = myActor->GetObject()->GetMesh();
index 0fc5aef..9f8c1f2 100644 (file)
@@ -452,7 +452,7 @@ void SMESHGUI_CopyMeshDlg::onTextChange (const QString& theNewText)
   buttonOk->setEnabled(false);
   buttonApply->setEnabled(false);
 
-  // hilight entered elements
+  // highlight entered elements
   SMDS_Mesh* aMesh = 0;
   if (myActor)
     aMesh = myActor->GetObject()->GetMesh();
index e938f06..f7017df 100644 (file)
@@ -717,7 +717,7 @@ void SMESHGUI_CreatePolyhedralVolumeDlg::onTextChange(const QString& theNewText)
         buttonOk->setEnabled( false );
         buttonApply->setEnabled( false );
       
-        // check entered ids of faces and hilight them
+        // check entered ids of faces and highlight them
         QStringList aListId;
         if ( aMesh ) {
           TColStd_MapOfInteger newIndices;
index 205544c..66b2688 100644 (file)
@@ -337,7 +337,7 @@ void SMESHGUI_3TypesSelector::onTextChange( const QString& theNewText )
 
   myBusy = true;
 
-  // hilight entered elements/nodes
+  // highlight entered elements/nodes
 
   myIDSource[ iType ]->length( 0 );
 
index 5ec69fe..b864ea4 100644 (file)
@@ -346,7 +346,7 @@ void SMESHGUI_FindElemByPointOp::onCloseView()
 }
 //================================================================================
 /*!
- * \brief hilight found selected elements
+ * \brief highlight found selected elements
  */
 //================================================================================
 
index 4fb23cb..8ff92dd 100644 (file)
@@ -2373,7 +2373,7 @@ void SMESHGUI_TreeElemInfo::saveInfo( QTextStream &out )
 */
 
 /*!
-  \brief Contructor
+  \brief Constructor
 */
 GrpComputor::GrpComputor( SMESH::SMESH_GroupBase_ptr grp,
                           QTreeWidgetItem*           item,
index 53e60ce..1d5030b 100755 (executable)
@@ -1400,7 +1400,7 @@ void SMESHGUI_MeshPatternDlg::onTextChanged (const QString& theNewText)
     activateSelection();
   }
 
-  // hilight entered elements/nodes
+  // highlight entered elements/nodes
   SMDS_Mesh* aMesh = 0;
   SMESH_Actor* anActor = SMESH::FindActorByObject(myMesh);
   if (anActor)
index 1b50b43..f62fb74 100755 (executable)
@@ -883,7 +883,7 @@ void SMESHGUI_MultiEditDlg::onListSelectionChanged()
     if (myListBox->item(i)->isSelected())
     {
       int anId = myListBox->item(i)->text().toInt();
-      if (anObj->GetElemVTKId(anId) >= 0) // avoid exception in hilight
+      if (anObj->GetElemVTKId(anId) >= 0) // avoid exception in highlight
         anIndexes.Add(anId);
     }
   }
diff --git a/src/SMESHGUI/SMESHGUI_OffsetDlg.cxx b/src/SMESHGUI/SMESHGUI_OffsetDlg.cxx
new file mode 100644 (file)
index 0000000..b63375a
--- /dev/null
@@ -0,0 +1,937 @@
+// Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//  File   : SMESHGUI_OffsetDlg.cxx
+
+//  SMESH includes
+
+#include "SMESHGUI_OffsetDlg.h"
+
+#include "SMESHGUI.h"
+#include "SMESHGUI_SpinBox.h"
+#include "SMESHGUI_Utils.h"
+#include "SMESHGUI_VTKUtils.h"
+#include "SMESHGUI_MeshUtils.h"
+#include "SMESHGUI_IdValidator.h"
+#include "SMESHGUI_FilterDlg.h"
+#include "SMESHGUI_MeshEditPreview.h"
+
+#include <SMESH_Actor.h>
+#include <SMESH_TypeFilter.hxx>
+#include <SMESH_LogicalFilter.hxx>
+#include <SMDS_Mesh.hxx>
+
+// SALOME GUI includes
+#include <LightApp_Application.h>
+#include <LightApp_SelectionMgr.h>
+#include <SALOME_ListIO.hxx>
+#include <SUIT_Desktop.h>
+#include <SUIT_MessageBox.h>
+#include <SUIT_OverrideCursor.h>
+#include <SUIT_ResourceMgr.h>
+#include <SUIT_Session.h>
+#include <SVTK_ViewModel.h>
+#include <SVTK_ViewWindow.h>
+#include <SalomeApp_Tools.h>
+
+// SALOME KERNEL includes
+#include <SALOMEDSClient.hxx>
+#include <SALOMEDSClient_SObject.hxx>
+
+// OCCT includes
+#include <TColStd_MapOfInteger.hxx>
+
+// Qt includes
+#include <QApplication>
+#include <QButtonGroup>
+#include <QGroupBox>
+#include <QLabel>
+#include <QLineEdit>
+#include <QPushButton>
+#include <QRadioButton>
+#include <QCheckBox>
+#include <QHBoxLayout>
+#include <QVBoxLayout>
+#include <QGridLayout>
+#include <QSpinBox>
+#include <QKeyEvent>
+
+// IDL includes
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(SMESH_Group)
+#include CORBA_SERVER_HEADER(SMESH_MeshEditor)
+
+enum { MOVE_ELEMS_BUTTON = 0, COPY_ELEMS_BUTTON, MAKE_MESH_BUTTON }; //!< action type
+
+/*!
+  \class BusyLocker
+  \brief Simple 'busy state' flag locker.
+  \internal
+*/
+class BusyLocker
+{
+public:
+  //! Constructor. Sets passed boolean flag to \c true.
+  BusyLocker( bool& busy ) : myBusy( busy ) { myBusy = true; }
+  //! Destructor. Clear external boolean flag passed as parameter to the constructor to \c false.
+  ~BusyLocker() { myBusy = false; }
+private:
+  bool& myBusy; //! External 'busy state' boolean flag
+};
+
+#define SPACING 6
+#define MARGIN  11
+
+//=================================================================================
+// class    : SMESHGUI_OffsetDlg()
+// purpose  :
+//=================================================================================
+SMESHGUI_OffsetDlg::SMESHGUI_OffsetDlg( SMESHGUI* theModule ) :
+  SMESHGUI_MultiPreviewDlg( theModule ),
+  mySelectionMgr( SMESH::GetSelectionMgr( theModule ) ),
+  myFilterDlg(0)
+{
+  QPixmap image0 (SMESH::GetResourceMgr( mySMESHGUI )->loadPixmap("SMESH", tr("ICON_DLG_MESH_OFFSET")));
+  QPixmap image1 (SMESH::GetResourceMgr( mySMESHGUI )->loadPixmap("SMESH", tr("ICON_SELECT")));
+
+  setModal(false);
+  setAttribute(Qt::WA_DeleteOnClose, true);
+  setWindowTitle(tr("SMESH_OFFSET_TITLE"));
+  setSizeGripEnabled(true);
+
+  QVBoxLayout* dlgLayout = new QVBoxLayout(this);
+  dlgLayout->setSpacing(SPACING);
+  dlgLayout->setMargin(MARGIN);
+
+  /***************************************************************/
+  ConstructorsBox = new QGroupBox(tr("SMESH_OFFSET"), this);
+  QHBoxLayout* ConstructorsBoxLayout = new QHBoxLayout(ConstructorsBox);
+  ConstructorsBoxLayout->setSpacing(SPACING);
+  ConstructorsBoxLayout->setMargin(MARGIN);
+
+  QRadioButton* RadioButton1= new QRadioButton(ConstructorsBox);
+  RadioButton1->setIcon(image0);
+
+  ConstructorsBoxLayout->addWidget(RadioButton1);
+
+  /***************************************************************/
+  GroupArguments = new QGroupBox(tr("SMESH_ARGUMENTS"), this);
+  QGridLayout* GroupArgumentsLayout = new QGridLayout(GroupArguments);
+  GroupArgumentsLayout->setSpacing(SPACING);
+  GroupArgumentsLayout->setMargin(MARGIN);
+
+  myIdValidator = new SMESHGUI_IdValidator(this);
+
+  // Controls for elements selection
+  TextLabelElements = new QLabel(tr("SMESH_ID_ELEMENTS"), GroupArguments);
+  // SelectElementsButton = new QPushButton(GroupArguments);
+  // SelectElementsButton->setIcon(image1);
+  LineEditElements = new QLineEdit(GroupArguments);
+  LineEditElements->setValidator(myIdValidator);
+  LineEditElements->setMaxLength(-1);
+  myFilterBtn = new QPushButton( tr( "SMESH_BUT_FILTER" ), GroupArguments );
+  connect(myFilterBtn,   SIGNAL(clicked()), this, SLOT(setFilters()));
+
+  // Control for the whole mesh selection
+  CheckBoxMesh = new QCheckBox(tr("SMESH_SELECT_WHOLE_MESH"), GroupArguments);
+
+  // offset
+  QLabel* TextLabel1 = new QLabel(tr("OFFSET_VALUE"), GroupArguments);
+  SpinBox = new SMESHGUI_SpinBox(GroupArguments);
+
+
+  // switch of action type
+  ActionBox = new QGroupBox(GroupArguments);
+  ActionGroup = new QButtonGroup(GroupArguments);
+  QVBoxLayout* ActionBoxLayout = new QVBoxLayout(ActionBox);
+  ActionBoxLayout->addSpacing(SPACING);
+  ActionBoxLayout->setMargin(MARGIN);
+
+  QRadioButton* aMoveElements = new QRadioButton(tr("SMESH_MOVE_ELEMENTS"), ActionBox);
+  QRadioButton* aCopyElements = new QRadioButton(tr("SMESH_COPY_ELEMENTS"), ActionBox);
+  QRadioButton* aCreateMesh   = new QRadioButton(tr("SMESH_CREATE_MESH"),   ActionBox);
+
+  ActionBoxLayout->addWidget(aMoveElements);
+  ActionBoxLayout->addWidget(aCopyElements);
+  ActionBoxLayout->addWidget(aCreateMesh);
+  ActionGroup->addButton(aMoveElements, MOVE_ELEMS_BUTTON);
+  ActionGroup->addButton(aCopyElements, COPY_ELEMS_BUTTON);
+  ActionGroup->addButton(aCreateMesh,   MAKE_MESH_BUTTON);
+
+  // CheckBox for groups generation
+  MakeGroupsCheck = new QCheckBox(tr("SMESH_MAKE_GROUPS"), GroupArguments);
+  MakeGroupsCheck->setChecked(false);
+
+  // Name of a mesh to create
+  LineEditNewMesh = new QLineEdit(GroupArguments);
+
+  //Preview check box
+  myPreviewCheckBox = new QCheckBox(tr("PREVIEW"), GroupArguments);
+
+  // layout
+  GroupArgumentsLayout->addWidget(TextLabelElements,    0, 0);
+  //GroupArgumentsLayout->addWidget(SelectElementsButton, 0, 1);
+  GroupArgumentsLayout->addWidget(LineEditElements,     0, 2, 1, 5);
+  GroupArgumentsLayout->addWidget(myFilterBtn,          0, 7);
+  GroupArgumentsLayout->addWidget(CheckBoxMesh,         1, 0, 1, 8);
+  GroupArgumentsLayout->addWidget(TextLabel1,           2, 0);
+  GroupArgumentsLayout->addWidget(SpinBox,              2, 3);
+  GroupArgumentsLayout->addWidget(ActionBox,            3, 0, 3, 4);
+  GroupArgumentsLayout->addWidget(MakeGroupsCheck,      4, 5, 1, 4);
+  GroupArgumentsLayout->addWidget(LineEditNewMesh,      5, 5, 1, 4);
+  GroupArgumentsLayout->addWidget(myPreviewCheckBox,    6, 0);
+
+  /***************************************************************/
+  GroupButtons = new QGroupBox(this);
+  QHBoxLayout* GroupButtonsLayout = new QHBoxLayout(GroupButtons);
+  GroupButtonsLayout->setSpacing(SPACING);
+  GroupButtonsLayout->setMargin(MARGIN);
+
+  buttonOk = new QPushButton(tr("SMESH_BUT_APPLY_AND_CLOSE"), GroupButtons);
+  buttonOk->setAutoDefault(true);
+  buttonOk->setDefault(true);
+  buttonApply = new QPushButton(tr("SMESH_BUT_APPLY"), GroupButtons);
+  buttonApply->setAutoDefault(true);
+  buttonCancel = new QPushButton(tr("SMESH_BUT_CLOSE"), GroupButtons);
+  buttonCancel->setAutoDefault(true);
+  buttonHelp = new QPushButton(tr("SMESH_BUT_HELP"), GroupButtons);
+  buttonHelp->setAutoDefault(true);
+
+  GroupButtonsLayout->addWidget(buttonOk);
+  GroupButtonsLayout->addSpacing(10);
+  GroupButtonsLayout->addWidget(buttonApply);
+  GroupButtonsLayout->addSpacing(10);
+  GroupButtonsLayout->addStretch();
+  GroupButtonsLayout->addWidget(buttonCancel);
+  GroupButtonsLayout->addWidget(buttonHelp);
+
+  /***************************************************************/
+  dlgLayout->addWidget(ConstructorsBox);
+  dlgLayout->addWidget(GroupArguments);
+  dlgLayout->addWidget(GroupButtons);
+
+  /* Initialisations */
+  SpinBox->RangeStepAndValidator(COORD_MIN, COORD_MAX, 1.0, "length_precision");
+
+  RadioButton1->setChecked(true);
+
+  mySelector = (SMESH::GetViewWindow( mySMESHGUI ))->GetSelector();
+
+  mySMESHGUI->SetActiveDialogBox((QDialog*)this);
+
+  // Costruction of the logical filter
+  SMESH_TypeFilter* aMeshOrSubMeshFilter = new SMESH_TypeFilter (SMESH::MESHorSUBMESH);
+  SMESH_TypeFilter* aSmeshGroupFilter    = new SMESH_TypeFilter (SMESH::GROUP);
+
+  QList<SUIT_SelectionFilter*> aListOfFilters;
+  if (aMeshOrSubMeshFilter) aListOfFilters.append(aMeshOrSubMeshFilter);
+  if (aSmeshGroupFilter)    aListOfFilters.append(aSmeshGroupFilter);
+
+  myMeshOrSubMeshOrGroupFilter =
+    new SMESH_LogicalFilter(aListOfFilters, SMESH_LogicalFilter::LO_OR);
+
+  myHelpFileName = "Offset_page.html";
+
+  Init();
+
+  /* signals and slots connections */
+  connect(buttonOk,     SIGNAL(clicked()), this, SLOT(ClickOnOk()));
+  connect(buttonCancel, SIGNAL(clicked()), this, SLOT(reject()));
+  connect(buttonApply,  SIGNAL(clicked()), this, SLOT(ClickOnApply()));
+  connect(buttonHelp,   SIGNAL(clicked()), this, SLOT(ClickOnHelp()));
+
+  //connect(SelectElementsButton, SIGNAL (clicked()), this, SLOT(SetEditCurrentArgument()));
+
+  connect(mySMESHGUI, SIGNAL (SignalDeactivateActiveDialog()), this, SLOT(DeactivateActiveDialog()));
+  connect(mySelectionMgr, SIGNAL(currentSelectionChanged()),   this, SLOT(SelectionIntoArgument()));
+  /* to close dialog if study change */
+  connect(mySMESHGUI, SIGNAL(SignalCloseAllDialogs()),      this, SLOT(reject()));
+  connect(mySMESHGUI, SIGNAL(SignalActivatedViewManager()), this, SLOT(onOpenView()));
+  connect(mySMESHGUI, SIGNAL(SignalCloseView()),            this, SLOT(onCloseView()));
+
+  connect(LineEditElements, SIGNAL(textChanged(const QString&)),    SLOT(onTextChange(const QString&)));
+  connect(CheckBoxMesh,     SIGNAL(toggled(bool)),                  SLOT(onSelectMesh(bool)));
+  connect(ActionGroup,      SIGNAL(buttonClicked(int)),             SLOT(onActionClicked(int)));
+
+  connect(SpinBox,  SIGNAL(valueChanged(double)), this, SLOT(toDisplaySimulation()));
+
+  //To Connect preview check box
+  connectPreviewControl();
+
+  SelectionIntoArgument();
+  onActionClicked(MOVE_ELEMS_BUTTON);
+}
+
+//=================================================================================
+// function : ~SMESHGUI_OffsetDlg()
+// purpose  : Destroys the object and frees any allocated resources
+//=================================================================================
+SMESHGUI_OffsetDlg::~SMESHGUI_OffsetDlg()
+{
+  if ( myFilterDlg ) {
+    myFilterDlg->setParent( 0 );
+    delete myFilterDlg;
+    myFilterDlg = 0;
+  }
+}
+
+//=================================================================================
+// function : Init()
+// purpose  :
+//=================================================================================
+void SMESHGUI_OffsetDlg::Init (bool ResetControls)
+{
+  myBusy = false;
+  myObjects.clear();
+  myObjectsNames.clear();
+  myMeshes.clear();
+
+  LineEditElements->clear();
+  myElementsId = "";
+  myNbOkElements = 0;
+
+  buttonOk->setEnabled(false);
+  buttonApply->setEnabled(false);
+
+  myActor = 0;
+
+  if (ResetControls)
+  {
+    SpinBox->SetValue(1.0);
+    myPreviewCheckBox->setChecked(false);
+    onDisplaySimulation(false);
+
+    ActionGroup->button( MOVE_ELEMS_BUTTON )->setChecked(true);
+    CheckBoxMesh->setChecked(true);
+    onSelectMesh(true);
+  }
+}
+
+//=================================================================================
+// function : ClickOnApply()
+// purpose  :
+//=================================================================================
+bool SMESHGUI_OffsetDlg::ClickOnApply()
+{
+  if (mySMESHGUI->isActiveStudyLocked())
+    return false;
+
+  if( !isValid() )
+    return false;
+
+  SUIT_OverrideCursor aWaitCursor;
+
+  if (myNbOkElements)
+  {
+    QStringList aListElementsId = myElementsId.split(" ", QString::SkipEmptyParts);
+
+    SMESH::long_array_var anElementsId = new SMESH::long_array;
+    anElementsId->length(aListElementsId.count());
+    for (int i = 0; i < aListElementsId.count(); i++)
+      anElementsId[i] = aListElementsId[i].toInt();
+
+    double offsetValue = SpinBox->value();
+
+    QStringList aParameters;
+    aParameters << SpinBox->text();
+
+    int actionButton = ActionGroup->checkedId();
+    bool makeGroups = ( MakeGroupsCheck->isEnabled() && MakeGroupsCheck->isChecked() );
+    SMESH::ListOfGroups_var groups;
+    SMESH::SMESH_Mesh_var mesh;
+    QStringList anEntryList;
+    try
+    {
+      switch ( actionButton ) {
+
+      case MOVE_ELEMS_BUTTON:
+        if ( CheckBoxMesh->isChecked() )
+          for ( int i = 0; i < myObjects.count(); i++ ) {
+            SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditor();
+            myMeshes[i]->SetParameters( aParameters.join( ":" ).toLatin1().constData() );
+            mesh = aMeshEditor->Offset( myObjects[i], offsetValue, true, "", groups.out() );
+          }
+        else {
+          SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditor();
+          SMESH::IDSource_wrap src = aMeshEditor->MakeIDSource(anElementsId, SMESH::FACE);
+          myMeshes[0]->SetParameters( aParameters.join( ":" ).toLatin1().constData() );
+          mesh = aMeshEditor->Offset( src, offsetValue, true, "", groups.out() );
+        }
+        break;
+
+      case COPY_ELEMS_BUTTON:
+        if ( CheckBoxMesh->isChecked() )
+          for ( int i = 0; i < myObjects.count(); i++ ) {
+            SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditor();
+            myMeshes[i]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+            mesh = aMeshEditor->Offset( myObjects[i], offsetValue, makeGroups, "", groups.out() );
+          }
+        else {
+          SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditor();
+          SMESH::IDSource_wrap src = aMeshEditor->MakeIDSource(anElementsId, SMESH::FACE );
+          myMeshes[0]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+          mesh = aMeshEditor->Offset( src, offsetValue, makeGroups, "", groups.out() );
+        }
+        break;
+
+      case MAKE_MESH_BUTTON: {
+        SMESH::SMESH_Mesh_var mesh;
+        if ( CheckBoxMesh->isChecked() ) {
+          for ( int i = 0; i < myObjects.count(); i++ ) {
+            QString aName =
+              SMESH::UniqueMeshName( LineEditNewMesh->text().replace( "*", myObjectsNames[i] ));
+            SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditor();
+            myMeshes[i]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+            mesh = aMeshEditor->Offset( myObjects[i], offsetValue, makeGroups,
+                                        aName.toLatin1().data(), groups.out() );
+            if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( mesh ))
+              anEntryList.append( aSObject->GetID().c_str() );
+          }
+        }
+        else {
+          SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditor();
+          myMeshes[0]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+          SMESH::IDSource_wrap src = aMeshEditor->MakeIDSource(anElementsId, SMESH::FACE );
+          mesh = aMeshEditor->Offset( src, offsetValue, makeGroups,
+                                      LineEditNewMesh->text().toLatin1().data(), groups.out() );
+          if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( mesh ) )
+            anEntryList.append( aSObject->GetID().c_str() );
+        }
+        break;
+      }
+      }
+    }
+    catch ( const SALOME::SALOME_Exception& S_ex ) {
+      SalomeApp_Tools::QtCatchCorbaException( S_ex );
+    }
+    catch (...) {
+    }
+
+    for ( int i = 0; i < myObjects.count(); i++ ) {
+      SMESH_Actor* actor = SMESH::FindActorByObject( myObjects[i] );
+      if ( actor ) SMESH::Update( actor->getIO(), true );
+    }
+
+    if ( makeGroups || actionButton == MAKE_MESH_BUTTON )
+    {
+      mySMESHGUI->updateObjBrowser(true); // new groups may appear
+      if( LightApp_Application* anApp =
+          dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
+        anApp->browseObjects( anEntryList, isApplyAndClose() );
+    }
+    if ( !isApplyAndClose() )
+    {
+      Init(false);
+      SelectionIntoArgument();
+    }
+    SMESHGUI::Modified();
+  }
+
+  return true;
+}
+
+//=================================================================================
+// function : ClickOnOk()
+// purpose  :
+//=================================================================================
+void SMESHGUI_OffsetDlg::ClickOnOk()
+{
+  setIsApplyAndClose( true );
+  if( ClickOnApply() )
+    reject();
+}
+
+//=================================================================================
+// function : reject()
+// purpose  :
+//=================================================================================
+void SMESHGUI_OffsetDlg::reject()
+{
+  disconnect(mySelectionMgr, 0, this, 0);
+  mySelectionMgr->clearFilters();
+  if (SMESH::GetCurrentVtkView()) {
+    SMESH::RemoveFilters(); // PAL6938 -- clean all mesh entity filters
+    SMESH::SetPointRepresentation(false);
+  }
+  if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+    aViewWindow->SetSelectionMode( ActorSelection );
+  mySMESHGUI->ResetState();
+  QDialog::reject();
+}
+
+//=================================================================================
+// function : onOpenView()
+// purpose  :
+//=================================================================================
+void SMESHGUI_OffsetDlg::onOpenView()
+{
+  if ( mySelector ) {
+    SMESH::SetPointRepresentation(false);
+  }
+  else {
+    mySelector = SMESH::GetViewWindow( mySMESHGUI )->GetSelector();
+    ActivateThisDialog();
+  }
+}
+
+//=================================================================================
+// function : onCloseView()
+// purpose  :
+//=================================================================================
+void SMESHGUI_OffsetDlg::onCloseView()
+{
+  DeactivateActiveDialog();
+  mySelector = 0;
+}
+
+//=================================================================================
+// function : ClickOnHelp()
+// purpose  :
+//=================================================================================
+void SMESHGUI_OffsetDlg::ClickOnHelp()
+{
+  LightApp_Application* app = (LightApp_Application*)(SUIT_Session::session()->activeApplication());
+  if (app)
+    app->onHelpContextModule(mySMESHGUI ? app->moduleName(mySMESHGUI->moduleName()) : QString(""), myHelpFileName);
+  else {
+    QString platform;
+#ifdef WIN32
+    platform = "winapplication";
+#else
+    platform = "application";
+#endif
+    SUIT_MessageBox::warning(this, tr("WRN_WARNING"),
+                             tr("EXTERNAL_BROWSER_CANNOT_SHOW_PAGE").
+                             arg(app->resourceMgr()->stringValue("ExternalBrowser",
+                                                                 platform)).
+                             arg(myHelpFileName));
+  }
+}
+
+//=======================================================================
+// function : onTextChange()
+// purpose  :
+//=======================================================================
+
+void SMESHGUI_OffsetDlg::onTextChange (const QString& theNewText)
+{
+  if (myBusy) return;
+  BusyLocker lock( myBusy );
+
+  myNbOkElements = 0;
+
+  buttonOk->setEnabled(false);
+  buttonApply->setEnabled(false);
+
+  // hilight entered elements
+  SMDS_Mesh* aMesh = 0;
+  if (myActor)
+    aMesh = myActor->GetObject()->GetMesh();
+
+  if (aMesh) {
+    Handle(SALOME_InteractiveObject) anIO = myActor->getIO();
+
+    TColStd_MapOfInteger newIndices;
+
+    QStringList aListId = theNewText.split(" ", QString::SkipEmptyParts);
+    for (int i = 0; i < aListId.count(); i++)
+    {
+      if ( const SMDS_MeshElement * e = aMesh->FindElement(aListId[ i ].toInt()))
+        newIndices.Add( e->GetID() );
+      myNbOkElements++;
+    }
+
+    mySelector->AddOrRemoveIndex( anIO, newIndices, false );
+    if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+      aViewWindow->highlight( anIO, true, true );
+
+    myElementsId = theNewText;
+  }
+
+  if (myNbOkElements) {
+    buttonOk->setEnabled(true);
+    buttonApply->setEnabled(true);
+  }
+}
+
+//=================================================================================
+// function : SelectionIntoArgument()
+// purpose  : Called when selection as changed or other case
+//=================================================================================
+void SMESHGUI_OffsetDlg::SelectionIntoArgument()
+{
+  if (myBusy) return;
+  if (myFilterDlg && myFilterDlg->isVisible()) return; // filter dlg active
+
+  BusyLocker lock( myBusy );
+
+  // clear
+  myActor = 0;
+  QString aString = "";
+  onDisplaySimulation(false);
+
+  LineEditElements->setText(aString);
+  myNbOkElements = 0;
+  buttonOk->setEnabled(false);
+  buttonApply->setEnabled(false);
+
+  if (!GroupButtons->isEnabled()) // inactive
+    return;
+
+  // get selected mesh
+  SALOME_ListIO aList;
+  mySelectionMgr->selectedObjects(aList);
+
+  int nbSel = aList.Extent();
+  if (nbSel < 1)
+    return;
+
+  myElementsId = "";
+  myObjects.clear();
+  myObjectsNames.clear();
+  myMeshes.clear();
+
+  for ( SALOME_ListIteratorOfListIO it( aList ); it.More(); it.Next() )
+  {
+    Handle(SALOME_InteractiveObject) IO = it.Value();
+    SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO( IO );
+    if ( aMesh->_is_nil() || aMesh->NbFaces() == 0 )
+      return;
+
+    myActor = SMESH::FindActorByObject( aMesh );
+    if ( !myActor )
+      myActor = SMESH::FindActorByEntry( IO->getEntry() );
+
+    SMESH::SMESH_IDSource_var idSrc = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>( IO );
+    if ( _PTR(SObject) obj = SMESH::FindSObject( idSrc ))
+    {
+      std::string name = obj->GetName();
+      if ( !name.empty() )
+      {
+        myObjects << idSrc;
+        myObjectsNames << name.c_str();
+        myMeshes << aMesh;
+      }
+    }
+  }
+
+  // MakeGroups is available if there are groups and "Copy"
+  int aNbGroups = 0;
+  for ( int i = 0; i < myMeshes.count(); i++ )
+    aNbGroups += myMeshes[i]->NbGroups();
+
+  if ( aNbGroups == 0 ) {
+    MakeGroupsCheck->setChecked(false);
+    MakeGroupsCheck->setEnabled(false);
+  }
+  else if ( ActionGroup->checkedId() != MOVE_ELEMS_BUTTON ) {
+    MakeGroupsCheck->setEnabled(true);
+  }
+
+  if (CheckBoxMesh->isChecked()) {
+    if (myMeshes.isEmpty())
+      return;
+    SMESH::GetNameOfSelectedIObjects( mySelectionMgr, aString );
+  }
+  else {
+    int aNbUnits = SMESH::GetNameOfSelectedElements(mySelector, aList.First(), aString);
+    myElementsId = aString;
+    if (aNbUnits < 1)
+      return;
+  }
+
+  myNbOkElements = true;
+  
+  LineEditElements->setText(aString);
+  LineEditElements->repaint();
+  LineEditElements->setEnabled(false); // to fully update lineedit IPAL 19809
+  LineEditElements->setEnabled(true);
+  setNewMeshName();
+
+  buttonOk->setEnabled(true);
+  buttonApply->setEnabled(true);
+
+  onDisplaySimulation(true);
+}
+
+//=================================================================================
+// function : DeactivateActiveDialog()
+// purpose  :
+//=================================================================================
+
+void SMESHGUI_OffsetDlg::DeactivateActiveDialog()
+{
+  if (ConstructorsBox->isEnabled())
+  {
+    ConstructorsBox->setEnabled(false);
+    GroupArguments->setEnabled(false);
+    GroupButtons->setEnabled(false);
+    mySMESHGUI->ResetState();
+    mySMESHGUI->SetActiveDialogBox(0);
+  }
+}
+
+//=================================================================================
+// function : ActivateThisDialog()
+// purpose  :
+//=================================================================================
+
+void SMESHGUI_OffsetDlg::ActivateThisDialog()
+{
+  /* Emit a signal to deactivate the active dialog */
+  mySMESHGUI->EmitSignalDeactivateDialog();
+  ConstructorsBox->setEnabled(true);
+  GroupArguments->setEnabled(true);
+  GroupButtons->setEnabled(true);
+
+  mySMESHGUI->SetActiveDialogBox((QDialog*)this);
+
+  if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+    aViewWindow->SetSelectionMode( CellSelection );
+
+  SelectionIntoArgument();
+}
+
+//=================================================================================
+// function : enterEvent()
+// purpose  :
+//=================================================================================
+
+void SMESHGUI_OffsetDlg::enterEvent (QEvent*)
+{
+  if (!ConstructorsBox->isEnabled()) {
+    SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI );
+    if ( aViewWindow && !mySelector) {
+      mySelector = aViewWindow->GetSelector();
+    }
+    ActivateThisDialog();
+  }
+}
+
+//=======================================================================
+//function : onSelectMesh
+//purpose  :
+//=======================================================================
+
+void SMESHGUI_OffsetDlg::onSelectMesh (bool toSelectMesh)
+{
+  if (toSelectMesh)
+    TextLabelElements->setText(tr("SMESH_NAME"));
+  else
+    TextLabelElements->setText(tr("SMESH_ID_ELEMENTS"));
+  myFilterBtn->setEnabled(!toSelectMesh);
+
+  mySelectionMgr->clearFilters();
+  SMESH::SetPointRepresentation(false);
+
+  if (toSelectMesh)
+  {
+    if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+      aViewWindow->SetSelectionMode( ActorSelection );
+    mySelectionMgr->installFilter( myMeshOrSubMeshOrGroupFilter );
+    LineEditElements->setReadOnly( true );
+    LineEditElements->setValidator( 0 );
+  }
+  else
+  {
+    if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+      aViewWindow->SetSelectionMode( FaceSelection );
+    LineEditElements->setReadOnly( false );
+    LineEditElements->setValidator( myIdValidator );
+    onTextChange(LineEditElements->text());
+    hidePreview();
+  }
+
+  SelectionIntoArgument();
+}
+
+//=======================================================================
+//function : onActionClicked
+//purpose  : slot called when an action type changed
+//=======================================================================
+
+void SMESHGUI_OffsetDlg::onActionClicked(int button)
+{
+  int aNbGroups = 0;
+  for ( int i = 0; i < myMeshes.count(); i++ )
+    aNbGroups += myMeshes[i]->NbGroups();
+
+  switch ( button ) {
+  case MOVE_ELEMS_BUTTON:
+    MakeGroupsCheck->setEnabled(false);
+    LineEditNewMesh->setEnabled(false);
+    break;
+  case COPY_ELEMS_BUTTON:
+    LineEditNewMesh->setEnabled(false);
+    MakeGroupsCheck->setText( tr("SMESH_MAKE_GROUPS"));
+    MakeGroupsCheck->setEnabled( myMeshes.isEmpty() || aNbGroups > 0 );
+    break;
+  case MAKE_MESH_BUTTON:
+    LineEditNewMesh->setEnabled(true);
+    MakeGroupsCheck->setText( tr("SMESH_COPY_GROUPS"));
+    MakeGroupsCheck->setEnabled( myMeshes.isEmpty() || aNbGroups > 0 );
+    break;
+  }
+  setNewMeshName();
+  //toDisplaySimulation();
+}
+
+//=======================================================================
+//function : setNewMeshName
+//purpose  : update contents of LineEditNewMesh
+//=======================================================================
+
+void SMESHGUI_OffsetDlg::setNewMeshName()
+{
+  LineEditNewMesh->setText("");
+  if ( LineEditNewMesh->isEnabled() && !myMeshes.isEmpty() ) {
+    QString name;
+    if ( CheckBoxMesh->isChecked() ) {
+      name = myObjects.count() > 1 ? "*" : LineEditElements->text();
+    }
+    else {
+      _PTR(SObject) meshSO = SMESH::FindSObject( myMeshes[0] );
+      name = meshSO->GetName().c_str();
+    }
+    if ( !name.isEmpty() )
+      LineEditNewMesh->setText( SMESH::UniqueMeshName( name, "Offset"));
+  }
+}
+
+//=================================================================================
+// function : keyPressEvent()
+// purpose  :
+//=================================================================================
+
+void SMESHGUI_OffsetDlg::keyPressEvent( QKeyEvent* e )
+{
+  QDialog::keyPressEvent( e );
+  if ( e->isAccepted() )
+    return;
+
+  if ( e->key() == Qt::Key_F1 ) {
+    e->accept();
+    ClickOnHelp();
+  }
+}
+
+//=================================================================================
+// function : setFilters()
+// purpose  : SLOT. Called when "Filter" button pressed.
+//=================================================================================
+
+void SMESHGUI_OffsetDlg::setFilters()
+{
+  if ( myMeshes.isEmpty() ) {
+    SUIT_MessageBox::critical(this, tr("SMESH_ERROR"), tr("NO_MESH_SELECTED"));
+    return;
+  }
+  if ( !myFilterDlg ) {
+    myFilterDlg = new SMESHGUI_FilterDlg( mySMESHGUI, SMESH::ALL );
+    connect(myFilterDlg, SIGNAL(Accepted()), SLOT(onFilterAccepted()));
+  }
+
+  myFilterDlg->Init( SMESH::FACE );
+  myFilterDlg->SetSelection();
+  myFilterDlg->SetMesh( myMeshes[0] );
+  myFilterDlg->SetSourceWg( LineEditElements );
+
+  myFilterDlg->show();
+}
+
+//=======================================================================
+// name    : onFilterAccepted()
+// Purpose : SLOT. Called when Filter dlg closed with OK button.
+//           Activate [Apply] if no Actor is available
+//=======================================================================
+
+void SMESHGUI_OffsetDlg::onFilterAccepted()
+{
+  if ( myMeshes.length() > 0 && !buttonOk->isEnabled() )
+  {
+    myElementsId = LineEditElements->text();
+    QStringList aListElementsId = myElementsId.split(" ", QString::SkipEmptyParts);
+    myNbOkElements = aListElementsId.count();
+    buttonOk->setEnabled   ( myNbOkElements );
+    buttonApply->setEnabled( myNbOkElements );
+  }
+}
+
+//=================================================================================
+// function : isValid
+// purpose  :
+//=================================================================================
+
+bool SMESHGUI_OffsetDlg::isValid()
+{
+  return true;
+}
+
+//=================================================================================
+// function : onDisplaySimulation
+// purpose  : Show/Hide preview
+//=================================================================================
+void SMESHGUI_OffsetDlg::onDisplaySimulation( bool toDisplayPreview )
+{
+  SUIT_OverrideCursor aWaitCursor;
+
+  if (myPreviewCheckBox->isChecked() && toDisplayPreview)
+  {
+    if ( myNbOkElements && isValid() )
+    {
+      double offsetValue = SpinBox->value();
+
+      SMESH::ListOfGroups_var groups;
+      SMESH::SMESH_Mesh_var mesh;
+
+      try
+      {
+        QList<SMESH::MeshPreviewStruct_var> aMeshPreviewStruct;
+
+        if ( CheckBoxMesh->isChecked())
+          for ( int i = 0; i < myObjects.count(); i++ )
+          {
+            SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditPreviewer();
+            mesh = aMeshEditor->Offset( myObjects[i], offsetValue, false, "", groups.out() );
+            aMeshPreviewStruct << aMeshEditor->GetPreviewData();
+          }
+        else
+        {
+          SMESH::long_array_var anElementsId = new SMESH::long_array;
+          QStringList aListElementsId = myElementsId.split(" ", QString::SkipEmptyParts);
+          anElementsId->length(aListElementsId.count());
+          for (int i = 0; i < aListElementsId.count(); i++)
+            anElementsId[i] = aListElementsId[i].toInt();
+
+          SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditPreviewer();
+          SMESH::IDSource_wrap src = aMeshEditor->MakeIDSource(anElementsId, SMESH::FACE);
+          mesh = aMeshEditor->Offset( src, offsetValue, false, "", groups.out() );
+          aMeshPreviewStruct << aMeshEditor->GetPreviewData();
+        }
+        setSimulationPreview(aMeshPreviewStruct);
+
+      } catch (...) {
+        hidePreview();
+      }
+    } else {
+      hidePreview();
+    }
+  } else {
+    hidePreview();
+  }
+}
index c45b9ea..46387cc 100644 (file)
@@ -166,6 +166,7 @@ namespace SMESHOp {
     OpMergeNodes             = 4405,   // MENU MODIFICATION - TRANSFORMATION - MERGE NODES
     OpMergeElements          = 4406,   // MENU MODIFICATION - TRANSFORMATION - MERGE ELEMENTS
     OpDuplicateNodes         = 4407,   // MENU MODIFICATION - TRANSFORMATION - DUPLICATE NODES OR/AND ELEMENTS
+    OpOffset                 = 4408,   // MENU MODIFICATION - TRANSFORMATION - OFFSET
     OpMoveNode               = 4500,   // MENU MODIFICATION - MOVE NODE
     OpDiagonalInversion      = 4501,   // MENU MODIFICATION - DIAGONAL INVERSION
     OpUnionOfTwoTriangle     = 4502,   // MENU MODIFICATION - UNION OF TWO TRIANGLE
index 067eb5f..1e458d8 100644 (file)
@@ -345,7 +345,7 @@ void SMESHGUI_RemoveElementsDlg::onTextChange(const QString& theNewText)
 
   myNbOkElements = 0;
 
-  // hilight entered elements
+  // highlight entered elements
   if(myActor){
     if(SMDS_Mesh* aMesh = myActor->GetObject()->GetMesh()){
       Handle(SALOME_InteractiveObject) anIO = myActor->getIO();
index 805b37c..1eb516a 100644 (file)
@@ -351,7 +351,7 @@ void SMESHGUI_RemoveNodesDlg::onTextChange(const QString& theNewText)
 
   myNbOkNodes = 0;
 
-  // hilight entered nodes
+  // highlight entered nodes
   if(myActor){
     if(SMDS_Mesh* aMesh = myActor->GetObject()->GetMesh()){
       Handle(SALOME_InteractiveObject) anIO = myActor->getIO();
index 48e7204..abeb2cc 100644 (file)
@@ -635,7 +635,7 @@ void SMESHGUI_RotationDlg::onTextChange (const QString& theNewText)
   buttonOk->setEnabled(false);
   buttonApply->setEnabled(false);
 
-  // hilight entered elements
+  // highlight entered elements
   SMDS_Mesh* aMesh = 0;
   if (myActor)
     aMesh = myActor->GetObject()->GetMesh();
index 85e9dd4..034a712 100644 (file)
@@ -674,7 +674,7 @@ void SMESHGUI_ScaleDlg::onTextChange (const QString& theNewText)
   buttonOk->setEnabled(false);
   buttonApply->setEnabled(false);
 
-  // hilight entered elements
+  // highlight entered elements
   SMDS_Mesh* aMesh = 0;
   if (myActor)
     aMesh = myActor->GetObject()->GetMesh();
index ca55110..2d69e85 100644 (file)
@@ -250,11 +250,11 @@ void SMESHGUI_SelectionOp::setSelectionMode( const Selection_Mode mode )
 // Purpose : Highlight object in 3d viewer
 //=======================================================================
 void SMESHGUI_SelectionOp::highlight( const Handle( SALOME_InteractiveObject )& obj,
-                                      const bool hilight, const bool immediately )
+                                      const bool highlight, const bool immediately )
 {
   SVTK_ViewWindow* wnd = viewWindow();
   if( wnd )
-    wnd->highlight( obj, hilight, immediately );
+    wnd->highlight( obj, highlight, immediately );
 }
 
 //=======================================================================
index b60a88c..69a5c01 100644 (file)
@@ -104,7 +104,7 @@ protected:
   //! Set selection mode in VTK viewer
   void                          setSelectionMode( const Selection_Mode );
 
-  //! Hilight object in VTK viewer
+  //! Highlight object in VTK viewer
   void                          highlight( const Handle( SALOME_InteractiveObject )&,
                                            const bool, const bool = true );
                                
index 22253c4..d2562b3 100644 (file)
@@ -1532,7 +1532,7 @@ void SMESHGUI_SewingDlg::onTextChange (const QString& theNewText)
   else if (send == LineEdit6)
     myOk6 = false;
 
-  // hilight entered elements/nodes
+  // highlight entered elements/nodes
   SMDS_Mesh* aMesh = 0;
 
   if (myActor)
index 3a5e922..0a8722e 100755 (executable)
@@ -341,7 +341,7 @@ void SMESHGUI_SingleEditDlg::onTextChange (const QString& theNewText)
   myOkBtn->setEnabled(false);
   myApplyBtn->setEnabled(false);
 
-  // hilight entered edge
+  // highlight entered edge
   if(myActor){
     if(SMDS_Mesh* aMesh = myActor->GetObject()->GetMesh()){
       Handle(SALOME_InteractiveObject) anIO = myActor->getIO();
index caa4c51..51335cb 100644 (file)
@@ -518,7 +518,7 @@ void SMESHGUI_SmoothingDlg::onTextChange (const QString& theNewText)
   buttonOk->setEnabled(false);
   buttonApply->setEnabled(false);
 
-  // hilight entered elements/nodes
+  // highlight entered elements/nodes
   SMDS_Mesh* aMesh = myActor ? myActor->GetObject()->GetMesh() : 0;
   QStringList aListId = theNewText.split(" ", QString::SkipEmptyParts);
 
index e688602..6495659 100644 (file)
@@ -693,7 +693,7 @@ void SMESHGUI_SymmetryDlg::onTextChange (const QString& theNewText)
   buttonOk->setEnabled(false);
   buttonApply->setEnabled(false);
 
-  // hilight entered elements
+  // highlight entered elements
   SMDS_Mesh* aMesh = 0;
   if (myActor)
     aMesh = myActor->GetObject()->GetMesh();
index 75e5635..cf878e9 100644 (file)
@@ -705,7 +705,7 @@ void SMESHGUI_TranslationDlg::onTextChange (const QString& theNewText)
   buttonOk->setEnabled(false);
   buttonApply->setEnabled(false);
 
-  // hilight entered elements
+  // highlight entered elements
   SMDS_Mesh* aMesh = 0;
   if (myActor)
     aMesh = myActor->GetObject()->GetMesh();
index 27ce252..629c0d1 100644 (file)
             <translation>scale.png</translation>
         </message>
         <message>
+            <source>ICON_DLG_MESH_OFFSET</source>
+            <translation>mesh_offset.png</translation>
+        </message>
+        <message>
             <source>ICON_DLG_SCALE_ALONG_AXES</source>
             <translation>scale_along_axes.png</translation>
         </message>
index ef6213c..ba574d9 100644 (file)
         <translation>Scale Transform</translation>
     </message>
     <message>
+        <source>MEN_OFFSET</source>
+        <translation>Offset</translation>
+    </message>
+    <message>
         <source>MEN_DUPLICATE_NODES</source>
         <translation>Duplicate Nodes or/and Elements</translation>
     </message>
@@ -1926,7 +1930,7 @@ add the exported data to its contents?</translation>
         <translation>Hexahedrons</translation>
     </message>
     <message>
-        <source>SMESH_HILIGHT_COLOR</source>
+        <source>SMESH_HIGHLIGHT_COLOR</source>
         <translation>Highlight Color</translation>
     </message>
     <message>
@@ -3555,6 +3559,10 @@ Use Display Entity menu command to show them.
         <translation>Scale Transform</translation>
     </message>
     <message>
+        <source>STB_OFFSET</source>
+        <translation>Offset</translation>
+    </message>
+    <message>
         <source>STB_DUPLICATE_NODES</source>
         <translation>Duplicate Nodes or/and Elements</translation>
     </message>
@@ -4235,6 +4243,10 @@ Use Display Entity menu command to show them.
         <translation>Scale Transform</translation>
     </message>
     <message>
+        <source>TOP_OFFSET</source>
+        <translation>Offset</translation>
+    </message>
+    <message>
         <source>TOP_DUPLICATE_NODES</source>
         <translation>Duplicate Nodes or/and Elements</translation>
     </message>
@@ -4510,6 +4522,21 @@ It can&apos;t be deleted </translation>
     </message>
 </context>
 <context>
+    <name>SMESHGUI_OffsetDlg</name>
+    <message>
+        <source>SMESH_OFFSET_TITLE</source>
+        <translation>Offset</translation>
+    </message>
+    <message>
+        <source>SMESH_OFFSET</source>
+        <translation>Offset</translation>
+    </message>
+    <message>
+        <source>OFFSET_VALUE</source>
+        <translation>Offset Value</translation>
+    </message>
+</context>
+<context>
     <name>SMESHGUI_AddMeshElementDlg</name>
     <message>
         <source>NB_ADDED</source>
index 2f5882e..80ba636 100755 (executable)
@@ -1910,7 +1910,7 @@ les données exportées ?</translation>
         <translation>Hexaèdres</translation>
     </message>
     <message>
-        <source>SMESH_HILIGHT_COLOR</source>
+        <source>SMESH_HIGHLIGHT_COLOR</source>
         <translation>Couleur de sélection</translation>
     </message>
     <message>
index 77c6734..22e77aa 100644 (file)
       <translation>六面体</translation>
     </message>
     <message>
-      <source>SMESH_HILIGHT_COLOR</source>
+      <source>SMESH_HIGHLIGHT_COLOR</source>
       <translation>選択色</translation>
     </message>
     <message>
index 6750f06..707e7b0 100644 (file)
@@ -87,6 +87,8 @@ SET(SMESHUtils_SOURCES
   SMESH_DeMerge.cxx
   SMESH_Delaunay.cxx
   SMESH_FillHole.cxx
+  SMESH_Triangulate.cxx
+  SMESH_Offset.cxx
   )
 
 # --- rules ---
index fbaac9e..257ef5e 100644 (file)
@@ -56,7 +56,7 @@ namespace SMESH_MAT2d
   //-------------------------------------------------------------------------------------
   // type of Branch end point
   enum BranchEndType { BE_UNDEF,
-                       BE_ON_VERTEX, // branch ends at a convex VRTEX
+                       BE_ON_VERTEX, // branch ends at a convex VERTEX
                        BE_BRANCH_POINT, // branch meats 2 or more other branches
                        BE_END // branch end equidistant from several adjacent segments
   };
index dbf355e..1de6ba8 100644 (file)
@@ -48,7 +48,7 @@
 #include <limits>
 #include <numeric>
 
-using namespace std;
+#include <boost/container/flat_set.hpp>
 
 //=======================================================================
 /*!
@@ -110,21 +110,21 @@ struct SMESH_NodeSearcherImpl: public SMESH_NodeSearcher
    */
   const SMDS_MeshNode* FindClosestTo( const gp_Pnt& thePnt )
   {
-    map<double, const SMDS_MeshNode*> dist2Nodes;
+    std::map<double, const SMDS_MeshNode*> dist2Nodes;
     myOctreeNode->NodesAround( thePnt.Coord(), dist2Nodes, myHalfLeafSize );
     if ( !dist2Nodes.empty() )
       return dist2Nodes.begin()->second;
-    list<const SMDS_MeshNode*> nodes;
+    std::list<const SMDS_MeshNode*> nodes;
     //myOctreeNode->NodesAround( &tgtNode, &nodes, myHalfLeafSize );
 
     double minSqDist = DBL_MAX;
     if ( nodes.empty() )  // get all nodes of OctreeNode's closest to thePnt
     {
       // sort leafs by their distance from thePnt
-      typedef map< double, SMESH_OctreeNode* > TDistTreeMap;
+      typedef std::map< double, SMESH_OctreeNode* > TDistTreeMap;
       TDistTreeMap treeMap;
-      list< SMESH_OctreeNode* > treeList;
-      list< SMESH_OctreeNode* >::iterator trIt;
+      std::list< SMESH_OctreeNode* > treeList;
+      std::list< SMESH_OctreeNode* >::iterator trIt;
       treeList.push_back( myOctreeNode );
 
       gp_XYZ pointNode( thePnt.X(), thePnt.Y(), thePnt.Z() );
@@ -143,9 +143,10 @@ struct SMESH_NodeSearcherImpl: public SMESH_NodeSearcher
         {
           const Bnd_B3d& box = *tree->getBox();
           double sqDist = thePnt.SquareDistance( 0.5 * ( box.CornerMin() + box.CornerMax() ));
-          pair<TDistTreeMap::iterator,bool> it_in = treeMap.insert( make_pair( sqDist, tree ));
+          std::pair<TDistTreeMap::iterator,bool> it_in =
+            treeMap.insert( std::make_pair( sqDist, tree ));
           if ( !it_in.second ) // not unique distance to box center
-            treeMap.insert( it_in.first, make_pair( sqDist + 1e-13*treeMap.size(), tree ));
+            treeMap.insert( it_in.first, std::make_pair( sqDist + 1e-13*treeMap.size(), tree ));
         }
       }
       // find distance after which there is no sense to check tree's
@@ -168,7 +169,7 @@ struct SMESH_NodeSearcherImpl: public SMESH_NodeSearcher
     // find closest among nodes
     minSqDist = DBL_MAX;
     const SMDS_MeshNode* closestNode = 0;
-    list<const SMDS_MeshNode*>::iterator nIt = nodes.begin();
+    std::list<const SMDS_MeshNode*>::iterator nIt = nodes.begin();
     for ( ; nIt != nodes.end(); ++nIt ) {
       double sqDist = thePnt.SquareDistance( SMESH_TNodeXYZ( *nIt ) );
       if ( minSqDist > sqDist ) {
@@ -226,15 +227,16 @@ namespace // Utils used in SMESH_ElementSearcherImpl::FindElementsByPoint()
   {
   public:
 
+    typedef boost::container::flat_set< const SMDS_MeshElement* > TElemSeq;
+
     ElementBndBoxTree(const SMDS_Mesh&     mesh,
                       SMDSAbs_ElementType  elemType,
                       SMDS_ElemIteratorPtr theElemIt = SMDS_ElemIteratorPtr(),
                       double               tolerance = NodeRadius );
-    void getElementsNearPoint( const gp_Pnt& point, vector<const SMDS_MeshElement*>& foundElems );
-    void getElementsNearLine ( const gp_Ax1& line,  vector<const SMDS_MeshElement*>& foundElems);
-    void getElementsInSphere ( const gp_XYZ&                    center,
-                               const double                     radius,
-                               vector<const SMDS_MeshElement*>& foundElems);
+    void getElementsNearPoint( const gp_Pnt& point, TElemSeq& foundElems );
+    void getElementsNearLine ( const gp_Ax1& line,  TElemSeq& foundElems );
+    void getElementsInBox    ( const Bnd_B3d& box,  TElemSeq& foundElems );
+    void getElementsInSphere ( const gp_XYZ& center, const double radius, TElemSeq& foundElems );
     ElementBndBoxTree* getLeafAtPoint( const gp_XYZ& point );
 
   protected:
@@ -247,10 +249,9 @@ namespace // Utils used in SMESH_ElementSearcherImpl::FindElementsByPoint()
     struct ElementBox : public Bnd_B3d
     {
       const SMDS_MeshElement* _element;
-      bool                    _isMarked;
       void init(const SMDS_MeshElement* elem, double tolerance);
     };
-    vector< ElementBox* > _elements;
+    std::vector< ElementBox* > _elements;
 
     typedef ObjectPool< ElementBox > TElementBoxPool;
 
@@ -258,7 +259,6 @@ namespace // Utils used in SMESH_ElementSearcherImpl::FindElementsByPoint()
     struct LimitAndPool : public SMESH_TreeLimit
     {
       TElementBoxPool            _elBoPool;
-      std::vector< ElementBox* > _markedElems;
       LimitAndPool():SMESH_TreeLimit( MaxLevel, /*minSize=*/0. ) {}
     };
     LimitAndPool* getLimitAndPool() const
@@ -345,37 +345,21 @@ namespace // Utils used in SMESH_ElementSearcherImpl::FindElementsByPoint()
    */
   //================================================================================
 
-  void ElementBndBoxTree::getElementsNearPoint( const gp_Pnt&                    point,
-                                                vector<const SMDS_MeshElement*>& foundElems)
+  void ElementBndBoxTree::getElementsNearPoint( const gp_Pnt& point, TElemSeq& foundElems)
   {
     if ( getBox()->IsOut( point.XYZ() ))
       return;
 
     if ( isLeaf() )
     {
-      LimitAndPool* pool = getLimitAndPool();
-
       for ( size_t i = 0; i < _elements.size(); ++i )
-        if ( !_elements[i]->IsOut( point.XYZ() ) &&
-             !_elements[i]->_isMarked )
-        {
-          foundElems.push_back( _elements[i]->_element );
-          _elements[i]->_isMarked = true;
-          pool->_markedElems.push_back( _elements[i] );
-        }
+        if ( !_elements[i]->IsOut( point.XYZ() ))
+          foundElems.insert( _elements[i]->_element );
     }
     else
     {
       for (int i = 0; i < 8; i++)
         ((ElementBndBoxTree*) myChildren[i])->getElementsNearPoint( point, foundElems );
-
-      if ( level() == 0 )
-      {
-        LimitAndPool* pool = getLimitAndPool();
-        for ( size_t i = 0; i < pool->_markedElems.size(); ++i )
-          pool->_markedElems[i]->_isMarked = false;
-        pool->_markedElems.clear();
-      }
     }
   }
 
@@ -385,37 +369,21 @@ namespace // Utils used in SMESH_ElementSearcherImpl::FindElementsByPoint()
    */
   //================================================================================
 
-  void ElementBndBoxTree::getElementsNearLine( const gp_Ax1&                    line,
-                                               vector<const SMDS_MeshElement*>& foundElems)
+  void ElementBndBoxTree::getElementsNearLine( const gp_Ax1& line, TElemSeq& foundElems )
   {
     if ( getBox()->IsOut( line ))
       return;
 
     if ( isLeaf() )
     {
-      LimitAndPool* pool = getLimitAndPool();
-
       for ( size_t i = 0; i < _elements.size(); ++i )
-        if ( !_elements[i]->IsOut( line ) &&
-             !_elements[i]->_isMarked )
-        {
-          foundElems.push_back( _elements[i]->_element );
-          _elements[i]->_isMarked = true;
-          pool->_markedElems.push_back( _elements[i] );
-        }
+        if ( !_elements[i]->IsOut( line ) )
+          foundElems.insert( _elements[i]->_element );
     }
     else
     {
       for (int i = 0; i < 8; i++)
         ((ElementBndBoxTree*) myChildren[i])->getElementsNearLine( line, foundElems );
-
-      if ( level() == 0 )
-      {
-        LimitAndPool* pool = getLimitAndPool();
-        for ( size_t i = 0; i < pool->_markedElems.size(); ++i )
-          pool->_markedElems[i]->_isMarked = false;
-        pool->_markedElems.clear();
-      }
     }
   }
 
@@ -425,38 +393,47 @@ namespace // Utils used in SMESH_ElementSearcherImpl::FindElementsByPoint()
    */
   //================================================================================
 
-  void ElementBndBoxTree::getElementsInSphere ( const gp_XYZ&                    center,
-                                                const double                     radius,
-                                                vector<const SMDS_MeshElement*>& foundElems)
+  void ElementBndBoxTree::getElementsInSphere ( const gp_XYZ& center,
+                                                const double  radius,
+                                                TElemSeq&     foundElems)
   {
     if ( getBox()->IsOut( center, radius ))
       return;
 
     if ( isLeaf() )
     {
-      LimitAndPool* pool = getLimitAndPool();
-
       for ( size_t i = 0; i < _elements.size(); ++i )
-        if ( !_elements[i]->IsOut( center, radius ) &&
-             !_elements[i]->_isMarked )
-        {
-          foundElems.push_back( _elements[i]->_element );
-          _elements[i]->_isMarked = true;
-          pool->_markedElems.push_back( _elements[i] );
-        }
+        if ( !_elements[i]->IsOut( center, radius ))
+          foundElems.insert( _elements[i]->_element );
     }
     else
     {
       for (int i = 0; i < 8; i++)
         ((ElementBndBoxTree*) myChildren[i])->getElementsInSphere( center, radius, foundElems );
+    }
+  }
 
-      if ( level() == 0 )
-      {
-        LimitAndPool* pool = getLimitAndPool();
-        for ( size_t i = 0; i < pool->_markedElems.size(); ++i )
-          pool->_markedElems[i]->_isMarked = false;
-        pool->_markedElems.clear();
-      }
+  //================================================================================
+  /*!
+   * \brief Return elements from leaves intersecting the box
+   */
+  //================================================================================
+
+  void ElementBndBoxTree::getElementsInBox( const Bnd_B3d& box,  TElemSeq& foundElems )
+  {
+    if ( getBox()->IsOut( box ))
+      return;
+
+    if ( isLeaf() )
+    {
+      for ( size_t i = 0; i < _elements.size(); ++i )
+        if ( !_elements[i]->IsOut( box ))
+          foundElems.insert( _elements[i]->_element );
+    }
+    else
+    {
+      for (int i = 0; i < 8; i++)
+        ((ElementBndBoxTree*) myChildren[i])->getElementsInBox( box, foundElems );
     }
   }
 
@@ -493,7 +470,6 @@ namespace // Utils used in SMESH_ElementSearcherImpl::FindElementsByPoint()
   void ElementBndBoxTree::ElementBox::init(const SMDS_MeshElement* elem, double tolerance)
   {
     _element  = elem;
-    _isMarked = false;
     SMDS_ElemIteratorPtr nIt = elem->nodesIterator();
     while ( nIt->more() )
       Add( SMESH_NodeXYZ( nIt->next() ));
@@ -515,15 +491,15 @@ SMESH_ElementSearcher::~SMESH_ElementSearcher()
 
 struct SMESH_ElementSearcherImpl: public SMESH_ElementSearcher
 {
-  SMDS_Mesh*                   _mesh;
-  SMDS_ElemIteratorPtr         _meshPartIt;
-  ElementBndBoxTree*           _ebbTree      [SMDSAbs_NbElementTypes];
-  int                          _ebbTreeHeight[SMDSAbs_NbElementTypes];
-  SMESH_NodeSearcherImpl*      _nodeSearcher;
-  SMDSAbs_ElementType          _elementType;
-  double                       _tolerance;
-  bool                         _outerFacesFound;
-  set<const SMDS_MeshElement*> _outerFaces; // empty means "no internal faces at all"
+  SMDS_Mesh*                        _mesh;
+  SMDS_ElemIteratorPtr              _meshPartIt;
+  ElementBndBoxTree*                _ebbTree      [SMDSAbs_NbElementTypes];
+  int                               _ebbTreeHeight[SMDSAbs_NbElementTypes];
+  SMESH_NodeSearcherImpl*           _nodeSearcher;
+  SMDSAbs_ElementType               _elementType;
+  double                            _tolerance;
+  bool                              _outerFacesFound;
+  std::set<const SMDS_MeshElement*> _outerFaces; // empty means "no internal faces at all"
 
   SMESH_ElementSearcherImpl( SMDS_Mesh&           mesh,
                              double               tol=-1,
@@ -545,20 +521,23 @@ struct SMESH_ElementSearcherImpl: public SMESH_ElementSearcher
     }
     if ( _nodeSearcher ) delete _nodeSearcher; _nodeSearcher = 0;
   }
-  virtual int FindElementsByPoint(const gp_Pnt&                      point,
-                                  SMDSAbs_ElementType                type,
-                                  vector< const SMDS_MeshElement* >& foundElements);
+  virtual int FindElementsByPoint(const gp_Pnt&                           point,
+                                  SMDSAbs_ElementType                     type,
+                                  std::vector< const SMDS_MeshElement* >& foundElements);
   virtual TopAbs_State GetPointState(const gp_Pnt& point);
   virtual const SMDS_MeshElement* FindClosestTo( const gp_Pnt&       point,
                                                  SMDSAbs_ElementType type );
 
-  virtual void GetElementsNearLine( const gp_Ax1&                      line,
-                                    SMDSAbs_ElementType                type,
-                                    vector< const SMDS_MeshElement* >& foundElems);
-  virtual void GetElementsInSphere( const gp_XYZ&                      center,
-                                    const double                       radius,
-                                    SMDSAbs_ElementType                type,
-                                    vector< const SMDS_MeshElement* >& foundElems);
+  virtual void GetElementsNearLine( const gp_Ax1&                           line,
+                                    SMDSAbs_ElementType                     type,
+                                    std::vector< const SMDS_MeshElement* >& foundElems);
+  virtual void GetElementsInSphere( const gp_XYZ&                           center,
+                                    const double                            radius,
+                                    SMDSAbs_ElementType                     type,
+                                    std::vector< const SMDS_MeshElement* >& foundElems);
+  virtual void GetElementsInBox( const Bnd_B3d&                          box,
+                                 SMDSAbs_ElementType                     type,
+                                 std::vector< const SMDS_MeshElement* >& foundElems);
   virtual gp_XYZ Project(const gp_Pnt&            point,
                          SMDSAbs_ElementType      type,
                          const SMDS_MeshElement** closestElem);
@@ -649,7 +628,7 @@ double SMESH_ElementSearcherImpl::getTolerance()
         while ( nodeIt->more() )
         {
           double dist = n1.Distance( static_cast<const SMDS_MeshNode*>( nodeIt->next() ));
-          elemSize = max( dist, elemSize );
+          elemSize = std::max( dist, elemSize );
         }
       }
       _tolerance = 1e-4 * elemSize;
@@ -707,10 +686,10 @@ void SMESH_ElementSearcherImpl::findOuterBoundary(const SMDS_MeshElement* outerF
   // and BTW find out if there are internal faces at all.
 
   // checked links and links where outer boundary meets internal one
-  set< SMESH_TLink > visitedLinks, seamLinks;
+  std::set< SMESH_TLink > visitedLinks, seamLinks;
 
   // links to treat with already visited faces sharing them
-  list < TFaceLink > startLinks;
+  std::list < TFaceLink > startLinks;
 
   // load startLinks with the first outerFace
   startLinks.push_back( TFaceLink( outerFace->GetNode(0), outerFace->GetNode(1), outerFace));
@@ -752,8 +731,8 @@ void SMESH_ElementSearcherImpl::findOuterBoundary(const SMDS_MeshElement* outerF
         // direction from the link inside outerFace
         gp_Vec dirInOF = gp_Vec( ofNorm ) ^ n1n2;
         // sort all other faces by angle with the dirInOF
-        map< double, const SMDS_MeshElement* > angle2Face;
-        set< const SMDS_MeshElement*, TIDCompare >::const_iterator face = faces.begin();
+        std::map< double, const SMDS_MeshElement* > angle2Face;
+        std::set< const SMDS_MeshElement*, TIDCompare >::const_iterator face = faces.begin();
         for ( ; face != faces.end(); ++face )
         {
           if ( *face == outerFace ) continue;
@@ -762,7 +741,7 @@ void SMESH_ElementSearcherImpl::findOuterBoundary(const SMDS_MeshElement* outerF
           gp_Vec dirInF = gp_Vec( fNorm ) ^ n1n2;
           double angle = dirInOF.AngleWithRef( dirInF, n1n2 );
           if ( angle < 0 ) angle += 2. * M_PI;
-          angle2Face.insert( make_pair( angle, *face ));
+          angle2Face.insert( std::make_pair( angle, *face ));
         }
         if ( !angle2Face.empty() )
           outerFace2 = angle2Face.begin()->second;
@@ -807,9 +786,9 @@ void SMESH_ElementSearcherImpl::findOuterBoundary(const SMDS_MeshElement* outerF
 //=======================================================================
 
 int SMESH_ElementSearcherImpl::
-FindElementsByPoint(const gp_Pnt&                      point,
-                    SMDSAbs_ElementType                type,
-                    vector< const SMDS_MeshElement* >& foundElements)
+FindElementsByPoint(const gp_Pnt&                           point,
+                    SMDSAbs_ElementType                     type,
+                    std::vector< const SMDS_MeshElement* >& foundElements)
 {
   foundElements.clear();
   _elementType = type;
@@ -850,9 +829,9 @@ FindElementsByPoint(const gp_Pnt&                      point,
     {
       _ebbTree[_elementType] = new ElementBndBoxTree( *_mesh, type, _meshPartIt, tolerance );
     }
-    vector< const SMDS_MeshElement* > suspectElems;
+    ElementBndBoxTree::TElemSeq suspectElems;
     _ebbTree[ type ]->getElementsNearPoint( point, suspectElems );
-    vector< const SMDS_MeshElement* >::iterator elem = suspectElems.begin();
+    ElementBndBoxTree::TElemSeq::iterator elem = suspectElems.begin();
     for ( ; elem != suspectElems.end(); ++elem )
       if ( !SMESH_MeshAlgos::IsOut( *elem, point, tolerance ))
         foundElements.push_back( *elem );
@@ -883,7 +862,7 @@ SMESH_ElementSearcherImpl::FindClosestTo( const gp_Pnt&       point,
     if ( !ebbTree )
       ebbTree = new ElementBndBoxTree( *_mesh, type, _meshPartIt );
 
-    vector<const SMDS_MeshElement*> suspectElems;
+    ElementBndBoxTree::TElemSeq suspectElems;
     ebbTree->getElementsNearPoint( point, suspectElems );
 
     if ( suspectElems.empty() && ebbTree->maxSize() > 0 )
@@ -902,20 +881,20 @@ SMESH_ElementSearcherImpl::FindClosestTo( const gp_Pnt&       point,
       }
     }
     double minDist = std::numeric_limits<double>::max();
-    multimap< double, const SMDS_MeshElement* > dist2face;
-    vector<const SMDS_MeshElement*>::iterator elem = suspectElems.begin();
+    std::multimap< double, const SMDS_MeshElement* > dist2face;
+    ElementBndBoxTree::TElemSeq::iterator elem = suspectElems.begin();
     for ( ; elem != suspectElems.end(); ++elem )
     {
       double dist = SMESH_MeshAlgos::GetDistance( *elem, point );
       if ( dist < minDist + 1e-10)
       {
         minDist = dist;
-        dist2face.insert( dist2face.begin(), make_pair( dist, *elem ));
+        dist2face.insert( dist2face.begin(), std::make_pair( dist, *elem ));
       }
     }
     if ( !dist2face.empty() )
     {
-      multimap< double, const SMDS_MeshElement* >::iterator d2f = dist2face.begin();
+      std::multimap< double, const SMDS_MeshElement* >::iterator d2f = dist2face.begin();
       closestElem = d2f->second;
       // if there are several elements at the same distance, select one
       // with GC closest to the point
@@ -974,21 +953,21 @@ TopAbs_State SMESH_ElementSearcherImpl::GetPointState(const gp_Pnt& point)
 
   const int nbAxes = 3;
   gp_Dir axisDir[ nbAxes ] = { gp::DX(), gp::DY(), gp::DZ() };
-  map< double, TInters >   paramOnLine2TInters[ nbAxes ];
-  list< TInters > tangentInters[ nbAxes ]; // of faces whose plane includes the line
-  multimap< int, int > nbInt2Axis; // to find the simplest case
+  std::map< double, TInters >   paramOnLine2TInters[ nbAxes ];
+  std::list< TInters > tangentInters[ nbAxes ]; // of faces whose plane includes the line
+  std::multimap< int, int > nbInt2Axis; // to find the simplest case
   for ( int axis = 0; axis < nbAxes; ++axis )
   {
     gp_Ax1 lineAxis( point, axisDir[axis]);
     gp_Lin line    ( lineAxis );
 
-    vector<const SMDS_MeshElement*> suspectFaces; // faces possibly intersecting the line
+    ElementBndBoxTree::TElemSeq suspectFaces; // faces possibly intersecting the line
     ebbTree->getElementsNearLine( lineAxis, suspectFaces );
 
     // Intersect faces with the line
 
-    map< double, TInters > & u2inters = paramOnLine2TInters[ axis ];
-    vector<const SMDS_MeshElement*>::iterator face = suspectFaces.begin();
+    std::map< double, TInters > & u2inters = paramOnLine2TInters[ axis ];
+    ElementBndBoxTree::TElemSeq::iterator face = suspectFaces.begin();
     for ( ; face != suspectFaces.end(); ++face )
     {
       // get face plane
@@ -1009,7 +988,7 @@ TopAbs_State SMESH_ElementSearcherImpl::GetPointState(const gp_Pnt& point)
         double tol = 1e-4 * Sqrt( fNorm.Modulus() );
         gp_Pnt intersectionPoint = intersection.Point(1);
         if ( !SMESH_MeshAlgos::IsOut( *face, intersectionPoint, tol ))
-          u2inters.insert(make_pair( intersection.ParamOnConic(1), TInters( *face, fNorm )));
+          u2inters.insert( std::make_pair( intersection.ParamOnConic(1), TInters( *face, fNorm )));
       }
     }
     // Analyse intersections roughly
@@ -1033,7 +1012,7 @@ TopAbs_State SMESH_ElementSearcherImpl::GetPointState(const gp_Pnt& point)
     if ( nbIntBeforePoint == 1 || nbIntAfterPoint == 1 )
       return TopAbs_IN;
 
-    nbInt2Axis.insert( make_pair( min( nbIntBeforePoint, nbIntAfterPoint ), axis ));
+    nbInt2Axis.insert( std::make_pair( std::min( nbIntBeforePoint, nbIntAfterPoint ), axis ));
 
     if ( _outerFacesFound ) break; // pass to thorough analysis
 
@@ -1047,29 +1026,29 @@ TopAbs_State SMESH_ElementSearcherImpl::GetPointState(const gp_Pnt& point)
 
   for ( int hasPositionInfo = _outerFacesFound; hasPositionInfo < 2; ++hasPositionInfo )
   {
-    multimap< int, int >::const_iterator nb_axis = nbInt2Axis.begin();
+    std::multimap< int, int >::const_iterator nb_axis = nbInt2Axis.begin();
     for ( ; nb_axis != nbInt2Axis.end(); ++nb_axis )
     {
       int axis = nb_axis->second;
-      map< double, TInters > & u2inters = paramOnLine2TInters[ axis ];
+      std::map< double, TInters > & u2inters = paramOnLine2TInters[ axis ];
 
       gp_Ax1 lineAxis( point, axisDir[axis]);
       gp_Lin line    ( lineAxis );
 
       // add tangent intersections to u2inters
       double param;
-      list< TInters >::const_iterator tgtInt = tangentInters[ axis ].begin();
+      std::list< TInters >::const_iterator tgtInt = tangentInters[ axis ].begin();
       for ( ; tgtInt != tangentInters[ axis ].end(); ++tgtInt )
         if ( getIntersParamOnLine( line, tgtInt->_face, tolerance, param ))
-          u2inters.insert(make_pair( param, *tgtInt ));
+          u2inters.insert( std::make_pair( param, *tgtInt ));
       tangentInters[ axis ].clear();
 
       // Count intersections before and after the point excluding touching ones.
       // If hasPositionInfo we count intersections of outer boundary only
 
       int nbIntBeforePoint = 0, nbIntAfterPoint = 0;
-      double f = numeric_limits<double>::max(), l = -numeric_limits<double>::max();
-      map< double, TInters >::iterator u_int1 = u2inters.begin(), u_int2 = u_int1;
+      double f = std::numeric_limits<double>::max(), l = -std::numeric_limits<double>::max();
+      std::map< double, TInters >::iterator u_int1 = u2inters.begin(), u_int2 = u_int1;
       bool ok = ! u_int1->second._coincides;
       while ( ok && u_int1 != u2inters.end() )
       {
@@ -1118,8 +1097,8 @@ TopAbs_State SMESH_ElementSearcherImpl::GetPointState(const gp_Pnt& point)
           // decide if we skipped a touching intersection
           if ( nbSamePnt + nbTgt > 0 )
           {
-            double minDot = numeric_limits<double>::max(), maxDot = -numeric_limits<double>::max();
-            map< double, TInters >::iterator u_int = u_int1;
+            double minDot = std::numeric_limits<double>::max(), maxDot = -minDot;
+            std::map< double, TInters >::iterator u_int = u_int1;
             for ( ; u_int != u_int2; ++u_int )
             {
               if ( u_int->second._coincides ) continue;
@@ -1172,7 +1151,7 @@ TopAbs_State SMESH_ElementSearcherImpl::GetPointState(const gp_Pnt& point)
     if ( !hasPositionInfo )
     {
       // gather info on faces position - is face in the outer boundary or not
-      map< double, TInters > & u2inters = paramOnLine2TInters[ 0 ];
+      std::map< double, TInters > & u2inters = paramOnLine2TInters[ 0 ];
       findOuterBoundary( u2inters.begin()->second._face );
     }
 
@@ -1187,16 +1166,20 @@ TopAbs_State SMESH_ElementSearcherImpl::GetPointState(const gp_Pnt& point)
  */
 //=======================================================================
 
-void SMESH_ElementSearcherImpl::GetElementsNearLine( const gp_Ax1&                      line,
-                                                     SMDSAbs_ElementType                type,
-                                                     vector< const SMDS_MeshElement* >& foundElems)
+void SMESH_ElementSearcherImpl::
+GetElementsNearLine( const gp_Ax1&                           line,
+                     SMDSAbs_ElementType                     type,
+                     std::vector< const SMDS_MeshElement* >& foundElems)
 {
   _elementType = type;
   ElementBndBoxTree*& ebbTree = _ebbTree[ type ];
   if ( !ebbTree )
     ebbTree = new ElementBndBoxTree( *_mesh, _elementType, _meshPartIt );
 
-  ebbTree->getElementsNearLine( line, foundElems );
+  ElementBndBoxTree::TElemSeq elems;
+  ebbTree->getElementsNearLine( line, elems );
+
+  foundElems.insert( foundElems.end(), elems.begin(), elems.end() );
 }
 
 //=======================================================================
@@ -1205,17 +1188,43 @@ void SMESH_ElementSearcherImpl::GetElementsNearLine( const gp_Ax1&
  */
 //=======================================================================
 
-void SMESH_ElementSearcherImpl::GetElementsInSphere( const gp_XYZ&                      center,
-                                                     const double                       radius,
-                                                     SMDSAbs_ElementType                type,
-                                                     vector< const SMDS_MeshElement* >& foundElems)
+void SMESH_ElementSearcherImpl::
+GetElementsInSphere( const gp_XYZ&                           center,
+                     const double                            radius,
+                     SMDSAbs_ElementType                     type,
+                     std::vector< const SMDS_MeshElement* >& foundElems)
 {
   _elementType = type;
   ElementBndBoxTree*& ebbTree = _ebbTree[ type ];
   if ( !ebbTree )
     ebbTree = new ElementBndBoxTree( *_mesh, _elementType, _meshPartIt );
 
-  ebbTree->getElementsInSphere( center, radius, foundElems );
+  ElementBndBoxTree::TElemSeq elems;
+  ebbTree->getElementsInSphere( center, radius, elems );
+
+  foundElems.insert( foundElems.end(), elems.begin(), elems.end() );
+}
+
+//=======================================================================
+/*
+ * Return elements whose bounding box intersects a given bounding box
+ */
+//=======================================================================
+
+void SMESH_ElementSearcherImpl::
+GetElementsInBox( const Bnd_B3d&                          box,
+                  SMDSAbs_ElementType                     type,
+                  std::vector< const SMDS_MeshElement* >& foundElems)
+{
+  _elementType = type;
+  ElementBndBoxTree*& ebbTree = _ebbTree[ type ];
+  if ( !ebbTree )
+    ebbTree = new ElementBndBoxTree( *_mesh, _elementType, _meshPartIt, getTolerance() );
+
+  ElementBndBoxTree::TElemSeq elems;
+  ebbTree->getElementsInBox( box, elems );
+
+  foundElems.insert( foundElems.end(), elems.begin(), elems.end() );
 }
 
 //=======================================================================
@@ -1242,7 +1251,7 @@ gp_XYZ SMESH_ElementSearcherImpl::Project(const gp_Pnt&            point,
   const Bnd_B3d* box = ebbLeaf->getBox();
   double radius = ( box->CornerMax() - box->CornerMin() ).Modulus();
 
-  vector< const SMDS_MeshElement* > elems;
+  ElementBndBoxTree::TElemSeq elems;
   ebbTree->getElementsInSphere( p, radius, elems );
   while ( elems.empty() )
   {
@@ -1252,13 +1261,14 @@ gp_XYZ SMESH_ElementSearcherImpl::Project(const gp_Pnt&            point,
   gp_XYZ proj, bestProj;
   const SMDS_MeshElement* elem = 0;
   double minDist = 2 * radius;
-  for ( size_t i = 0; i < elems.size(); ++i )
+  ElementBndBoxTree::TElemSeq::iterator e = elems.begin();
+  for ( ; e != elems.end(); ++e )
   {
-    double d = SMESH_MeshAlgos::GetDistance( elems[i], p, &proj );
+    double d = SMESH_MeshAlgos::GetDistance( *e, p, &proj );
     if ( d < minDist )
     {
       bestProj = proj;
-      elem = elems[i];
+      elem = *e;
       minDist = d;
     }
   }
@@ -1282,7 +1292,7 @@ bool SMESH_MeshAlgos::IsOut( const SMDS_MeshElement* element, const gp_Pnt& poin
 
   // get ordered nodes
 
-  vector< SMESH_TNodeXYZ > xyz; xyz.reserve( element->NbNodes()+1 );
+  std::vector< SMESH_TNodeXYZ > xyz; xyz.reserve( element->NbNodes()+1 );
 
   SMDS_ElemIteratorPtr nodeIt = element->interlacedNodesElemIterator();
   for ( int i = 0; nodeIt->more(); ++i )
@@ -1347,7 +1357,7 @@ bool SMESH_MeshAlgos::IsOut( const SMDS_MeshElement* element, const gp_Pnt& poin
     if ( n2pSize * n2pSize > fNormSize * 100 ) return true; // point is very far
     plnNorm /= n2pSize;
     // for each node of the face, compute its signed distance to the cutting plane
-    vector<double> dist( nbNodes + 1);
+    std::vector<double> dist( nbNodes + 1);
     for ( i = 0; i < nbNodes; ++i )
     {
       gp_Vec n2p( xyz[i], point );
@@ -1550,7 +1560,7 @@ double SMESH_MeshAlgos::GetDistance( const SMDS_MeshFace* face,
 
   // coordinates of nodes (medium nodes, if any, ignored)
   typedef SMDS_StdIterator< SMESH_TNodeXYZ, SMDS_ElemIteratorPtr > TXyzIterator;
-  vector<gp_XYZ> xyz( TXyzIterator( face->nodesIterator()), TXyzIterator() );
+  std::vector<gp_XYZ> xyz( TXyzIterator( face->nodesIterator()), TXyzIterator() );
   xyz.resize( face->NbCornerNodes()+1 );
 
   // transformation to get xyz[0] lies on the origin, xyz[1] lies on the Z axis,
@@ -1574,7 +1584,7 @@ double SMESH_MeshAlgos::GetDistance( const SMDS_MeshFace* face,
   trsf.SetTransformation( tgtCS );
 
   // move all the nodes to 2D
-  vector<gp_XY> xy( xyz.size() );
+  std::vector<gp_XY> xy( xyz.size() );
   for ( size_t i = 0;i < xyz.size()-1; ++i )
   {
     gp_XYZ p3d = xyz[i];
@@ -1590,7 +1600,7 @@ double SMESH_MeshAlgos::GetDistance( const SMDS_MeshFace* face,
   gp_XY point2D( tmpPnt.X(), tmpPnt.Z() );
 
   // loop on edges of the face to analyze point position ralative to the face
-  set< PointPos > pntPosSet;
+  std::set< PointPos > pntPosSet;
   for ( size_t i = 1; i < xy.size(); ++i )
   {
     PointPos pos = getPointPosition( point2D, &xy[0], i-1 );
@@ -1608,7 +1618,7 @@ double SMESH_MeshAlgos::GetDistance( const SMDS_MeshFace* face,
     gp_Vec n1p ( xyz[ pos._index ], point  );
     double u = ( edge * n1p ) / edge.SquareMagnitude(); // param [0,1] on the edge
     // projection of the point on the edge
-    gp_XYZ proj = ( 1. - u ) * xyz[ pos._index ] + u * xyz[ pos._index+1 ];
+    gp_XYZ proj = xyz[ pos._index ] + u * edge.XYZ();
     if ( closestPnt ) *closestPnt = proj;
     return point.Distance( proj );
   }
@@ -1655,7 +1665,7 @@ double SMESH_MeshAlgos::GetDistance( const SMDS_MeshEdge* seg,
 
   int i = 0, nbNodes = seg->NbNodes();
 
-  vector< SMESH_TNodeXYZ > xyz( nbNodes );
+  std::vector< SMESH_TNodeXYZ > xyz( nbNodes );
   SMDS_ElemIteratorPtr nodeIt = seg->interlacedNodesElemIterator();
   while ( nodeIt->more() )
     xyz[ i++ ].Set( nodeIt->next() );
@@ -1734,7 +1744,7 @@ double SMESH_MeshAlgos::GetDistance( const SMDS_MeshVolume* volume,
       break;
     }
     default:
-      vector<const SMDS_MeshNode *> nvec( nodes, nodes + vTool.NbFaceNodes( iF ));
+      std::vector<const SMDS_MeshNode *> nvec( nodes, nodes + vTool.NbFaceNodes( iF ));
       SMDS_PolygonalFaceOfNodes tmpFace( nvec );
       dist = GetDistance( &tmpFace, point, closestPnt );
     }
@@ -1839,7 +1849,7 @@ SMESH_MeshAlgos::FindFaceInSet(const SMDS_MeshNode*    n1,
         }
         else if ( n2 == prevN && n1 == n )
         {
-          face = elem; swap( i1, i2 );
+          face = elem; std::swap( i1, i2 );
         }
         prevN = n;
       }
@@ -1874,7 +1884,7 @@ bool SMESH_MeshAlgos::FaceNormal(const SMDS_MeshElement* F, gp_XYZ& normal, bool
     normal += ( p[2] - p[1] ) ^ ( p[0] - p[1] );
   }
   double size2 = normal.SquareModulus();
-  bool ok = ( size2 > numeric_limits<double>::min() * numeric_limits<double>::min());
+  bool ok = ( size2 > std::numeric_limits<double>::min() * std::numeric_limits<double>::min());
   if ( normalized && ok )
     normal /= sqrt( size2 );
 
@@ -1886,10 +1896,10 @@ bool SMESH_MeshAlgos::FaceNormal(const SMDS_MeshElement* F, gp_XYZ& normal, bool
 //purpose  : Return nodes common to two elements
 //=======================================================================
 
-vector< const SMDS_MeshNode*> SMESH_MeshAlgos::GetCommonNodes(const SMDS_MeshElement* e1,
-                                                              const SMDS_MeshElement* e2)
+std::vector< const SMDS_MeshNode*> SMESH_MeshAlgos::GetCommonNodes(const SMDS_MeshElement* e1,
+                                                                   const SMDS_MeshElement* e2)
 {
-  vector< const SMDS_MeshNode*> common;
+  std::vector< const SMDS_MeshNode*> common;
   for ( int i = 0 ; i < e1->NbNodes(); ++i )
     if ( e2->GetNodeIndex( e1->GetNode( i )) >= 0 )
       common.push_back( e1->GetNode( i ));
index 88b1c6d..3b1097a 100644 (file)
@@ -24,7 +24,7 @@
 // Author    : Edward AGAPOV (eap)
 
 // This file holds some low level algorithms extracted from SMESH_MeshEditor
-// to make them accessible from Controls package
+// to make them accessible from Controls package, and more
 
 
 #ifndef __SMESH_MeshAlgos_HXX__
@@ -41,6 +41,7 @@
 
 class gp_Pnt;
 class gp_Ax1;
+class Bnd_B3d;
 class SMDS_MeshNode;
 class SMDS_MeshElement;
 class SMDS_Mesh;
@@ -97,6 +98,12 @@ struct SMESHUtils_EXPORT SMESH_ElementSearcher
                                     SMDSAbs_ElementType                     type,
                                     std::vector< const SMDS_MeshElement* >& foundElems) = 0;
   /*!
+   * \brief Return elements whose bounding box intersects a given bounding box
+   */
+  virtual void GetElementsInBox( const Bnd_B3d&                          box,
+                                 SMDSAbs_ElementType                     type,
+                                 std::vector< const SMDS_MeshElement* >& foundElems) = 0;
+  /*!
    * \brief Find out if the given point is out of closed 2D mesh.
    */
   virtual TopAbs_State GetPointState(const gp_Pnt& point) = 0;
@@ -115,6 +122,27 @@ struct SMESHUtils_EXPORT SMESH_ElementSearcher
 namespace SMESH_MeshAlgos
 {
   /*!
+   * \brief Return SMESH_NodeSearcher. The caller is responsible for deleting it
+   */
+  SMESHUtils_EXPORT
+  SMESH_NodeSearcher* GetNodeSearcher( SMDS_Mesh& mesh );
+
+  SMESHUtils_EXPORT
+  SMESH_NodeSearcher* GetNodeSearcher( SMDS_ElemIteratorPtr elemIt );
+
+  /*!
+   * \brief Return SMESH_ElementSearcher. The caller is responsible for deleting it
+   */
+  SMESHUtils_EXPORT
+  SMESH_ElementSearcher* GetElementSearcher( SMDS_Mesh& mesh,
+                                             double     tolerance=-1.);
+  SMESHUtils_EXPORT
+  SMESH_ElementSearcher* GetElementSearcher( SMDS_Mesh& mesh,
+                                             SMDS_ElemIteratorPtr elemIt,
+                                             double     tolerance=-1. );
+
+
+  /*!
    * \brief Return true if the point is IN or ON of the element
    */
   SMESHUtils_EXPORT
@@ -219,26 +247,6 @@ namespace SMESH_MeshAlgos
         MarkElems( (*it)->nodesIterator(), isMarked );
   }
 
-  /*!
-   * \brief Return SMESH_NodeSearcher. The caller is responsible for deleting it
-   */
-  SMESHUtils_EXPORT
-  SMESH_NodeSearcher* GetNodeSearcher( SMDS_Mesh& mesh );
-
-  SMESHUtils_EXPORT
-  SMESH_NodeSearcher* GetNodeSearcher( SMDS_ElemIteratorPtr elemIt );
-
-  /*!
-   * \brief Return SMESH_ElementSearcher. The caller is responsible for deleting it
-   */
-  SMESHUtils_EXPORT
-  SMESH_ElementSearcher* GetElementSearcher( SMDS_Mesh& mesh,
-                                             double     tolerance=-1.);
-  SMESHUtils_EXPORT
-  SMESH_ElementSearcher* GetElementSearcher( SMDS_Mesh& mesh,
-                                             SMDS_ElemIteratorPtr elemIt,
-                                             double     tolerance=-1. );
-
 
 
   typedef std::vector<const SMDS_MeshNode*> TFreeBorder;
@@ -262,18 +270,16 @@ namespace SMESH_MeshAlgos
    * Returns TFreeBorder's coincident within the given tolerance.
    * If the tolerance <= 0.0 then one tenth of an average size of elements adjacent
    * to free borders being compared is used.
-   *
-   * (Implemented in ./SMESH_FreeBorders.cxx)
    */
   SMESHUtils_EXPORT
   void FindCoincidentFreeBorders(SMDS_Mesh&              mesh,
                                  double                  tolerance,
                                  CoincidentFreeBorders & foundFreeBordes);
+  // Implemented in ./SMESH_FreeBorders.cxx
+
   /*!
    * Returns all or only closed TFreeBorder's.
    * Optionally check if the mesh is manifold and if faces are correctly oriented.
-   *
-   * (Implemented in ./SMESH_FreeBorders.cxx)
    */
   SMESHUtils_EXPORT
   void FindFreeBorders(SMDS_Mesh&       mesh,
@@ -281,26 +287,84 @@ namespace SMESH_MeshAlgos
                        const bool       closedOnly,
                        bool*            isManifold = 0,
                        bool*            isGoodOri = 0);
+  // Implemented in ./SMESH_FreeBorders.cxx
+
   /*!
    * Fill a hole defined by a TFreeBorder with 2D elements.
-   *
-   * (Implemented in ./SMESH_FillHole.cxx)
    */
   SMESHUtils_EXPORT
   void FillHole(const TFreeBorder &                   freeBorder,
                 SMDS_Mesh&                            mesh,
                 std::vector<const SMDS_MeshElement*>& newFaces);
+  // Implemented in ./SMESH_FillHole.cxx
 
 
   /*!
    * \brief Find nodes whose merge makes the element invalid
-   *
-   * (Implemented in SMESH_DeMerge.cxx)
    */
   SMESHUtils_EXPORT
   void DeMerge(const SMDS_MeshElement*              elem,
                std::vector< const SMDS_MeshNode* >& newNodes,
                std::vector< const SMDS_MeshNode* >& noMergeNodes);
+  // Implemented in SMESH_DeMerge.cxx
+
+
+  typedef std::vector< std::pair< const SMDS_MeshElement*, const SMDS_MeshElement* > > TEPairVec;
+  typedef std::vector< std::pair< const SMDS_MeshNode*, const SMDS_MeshNode* > >       TNPairVec;
+  /*!
+   * \brief Create an offset mesh of given faces
+   *  \param [in] faceIt - the input faces
+   *  \param [in] theFixIntersections - to fix self intersections of the offset mesh or not
+   *  \param [out] new2OldFaces - history of faces
+   *  \param [out] new2OldNodes - history of nodes
+   *  \return SMDS_Mesh* - the new offset mesh, a caller should delete
+   */
+  SMESHUtils_EXPORT
+  SMDS_Mesh* MakeOffset( SMDS_ElemIteratorPtr faceIt,
+                         SMDS_Mesh&           mesh,
+                         const double         offset,
+                         const bool           theFixIntersections,
+                         TEPairVec&           new2OldFaces,
+                         TNPairVec&           new2OldNodes );
+  // Implemented in ./SMESH_Offset.cxx
+
+
+  /*!
+   * \brief Divide a mesh face into triangles
+   */
+  // Implemented in ./SMESH_Triangulate.cxx
+
+  class SMESHUtils_EXPORT Triangulate
+  {
+  public:
+
+    static int GetNbTriangles( const SMDS_MeshElement* face );
+
+    int GetTriangles( const SMDS_MeshElement*             face,
+                      std::vector< const SMDS_MeshNode*>& nodes);
+  private:
+
+    bool triangulate( std::vector< const SMDS_MeshNode*>& nodes, const size_t nbNodes );
+
+    /*!
+     * \brief Vertex of a polygon. Together with 2 neighbor Vertices represents a triangle
+     */
+    struct PolyVertex
+    {
+      SMESH_NodeXYZ _nxyz;
+      gp_XY         _xy;
+      PolyVertex*   _prev;
+      PolyVertex*   _next;
+
+      void   SetNodeAndNext( const SMDS_MeshNode* n, PolyVertex& v );
+      void   GetTriaNodes( const SMDS_MeshNode** nodes) const;
+      double TriaArea() const;
+      bool   IsInsideTria( const PolyVertex* v );
+      PolyVertex* Delete();
+    };
+    std::vector< PolyVertex > _pv;
+  };
+
 
 } // namespace SMESH_MeshAlgos
 
index dc74b07..9fbc5b0 100644 (file)
@@ -29,6 +29,7 @@
 
 #include "SMESH_Utils.hxx"
 
+#include "SMDS_SetIterator.hxx"
 #include "SMDS_MeshNode.hxx"
 
 #include <gp_XYZ.hxx>
@@ -39,6 +40,8 @@
 #include <set>
 #include <cassert>
 
+#include <boost/make_shared.hpp>
+
 typedef std::map<const SMDS_MeshElement*,
                  std::list<const SMDS_MeshElement*>, TIDCompare > TElemOfElemListMap;
 typedef std::map<const SMDS_MeshElement*,
@@ -100,6 +103,14 @@ namespace SMESHUtils
   private:
     ArrayDeleter( const ArrayDeleter& );
   };
+
+  template < class ELEM_SET >
+  SMDS_ElemIteratorPtr elemSetIterator( const ELEM_SET& elements )
+  {
+    typedef SMDS_SetIterator
+      < SMDS_pElement, typename ELEM_SET::const_iterator> TSetIterator;
+    return boost::make_shared< TSetIterator >( elements.begin(), elements.end() );
+  }
 }
 
 //=======================================================================
@@ -127,6 +138,7 @@ struct SMESH_TLink: public NLink
     return ( l1.node1() == l2.node1() && l1.node2() == l2.node2() );
   }
 };
+typedef SMESH_TLink SMESH_Link;
 
 //=======================================================================
 /*!
@@ -163,9 +175,13 @@ struct SMESH_TNodeXYZ : public gp_XYZ
     }
     return false;
   }
+  const SMDS_MeshNode* Node() const { return _node; }
   double Distance(const SMDS_MeshNode* n)       const { return (SMESH_TNodeXYZ( n )-*this).Modulus(); }
   double SquareDistance(const SMDS_MeshNode* n) const { return (SMESH_TNodeXYZ( n )-*this).SquareModulus(); }
   bool operator==(const SMESH_TNodeXYZ& other)  const { return _node == other._node; }
+  bool operator!=(const SMESH_TNodeXYZ& other)  const { return _node != other._node; }
+  bool operator!() const { return !_node; }
+  const SMDS_MeshNode* operator->() const { return _node; }
 };
 typedef SMESH_TNodeXYZ SMESH_NodeXYZ;
 
@@ -198,17 +214,12 @@ typedef std::vector< UVPtStruct > UVPtStructVec;
 
 // --------------------------------------------------------------------------------
 // class SMESH_SequenceOfElemPtr
-#include <NCollection_DefineSequence.hxx>
-
-class SMDS_MeshElement;
-
-typedef const SMDS_MeshElement* SMDS_MeshElementPtr;
-
-DEFINE_SEQUENCE (SMESH_SequenceOfElemPtr, SMESH_BaseCollectionElemPtr, SMDS_MeshElementPtr)
 
+typedef std::vector< const SMDS_MeshElement* > SMESH_SequenceOfElemPtr;
 
 // --------------------------------------------------------------------------------
 // class SMESH_SequenceOfNode
+#include <NCollection_DefineSequence.hxx>
 typedef const SMDS_MeshNode* SMDS_MeshNodePtr;
 
 DEFINE_SEQUENCE(SMESH_SequenceOfNode,
index e5bd4f9..7f3765e 100644 (file)
@@ -117,10 +117,7 @@ private:
   // get next free object identifier
   int getNextId()
   {
-    int id = 1;
-    while( mapIdToIOR.IsBound( id ) )
-      id++;
-    return id;
+    return mapIdToIOR.Extent() + 1;
   }
 
   TInt2StringMap mapIdToIOR; // persistent-to-transient map
index e434840..bb3703d 100644 (file)
@@ -1021,7 +1021,7 @@ void SMESH_Gen_i::UpdateParameters(CORBA::Object_ptr theObject, const char* theP
   myLastObj.clear();
   myLastParameters.clear();
   myLastParamIndex.clear(); /* vector holding indices of virables within the string
-                               of all varibles used for theObject */ 
+                               of all variables used for theObject */ 
   int nbVars = 0;
   int pos = 0, prevPos = 0, len = strlen( theParameters );
   if ( len == 0 ) return;
@@ -1050,7 +1050,7 @@ void SMESH_Gen_i::UpdateParameters(CORBA::Object_ptr theObject, const char* theP
     return;
 
   // store
-  // (1) variable names in the string of all varibles used for theObject and
+  // (1) variable names in the string of all variables used for theObject and
   // (2) indices of found variables in myLastParamIndex.
 
   // remember theObject
index 6cad2a9..72ce66d 100644 (file)
@@ -165,7 +165,10 @@ namespace MeshEditor_I {
     }
     void Remove( SMDSAbs_ElementType type )
     {
-      SMDS_ElemIteratorPtr eIt = GetMeshDS()->elementsIterator( type );
+      Remove( GetMeshDS()->elementsIterator( type ));
+    }
+    void Remove( SMDS_ElemIteratorPtr eIt )
+    {
       while ( eIt->more() )
         GetMeshDS()->RemoveFreeElement( eIt->next(), /*sm=*/0, /*fromGroups=*/false );
     }
@@ -522,14 +525,14 @@ SMESH::MeshPreviewStruct* SMESH_MeshEditor_i::GetPreviewData()
   SMESH_TRY;
   const bool hasBadElems = ( getEditor().GetError() && getEditor().GetError()->HasBadElems() );
 
-  if ( myIsPreviewMode || hasBadElems ) { // --- MeshPreviewStruct filling ---
-
+  if ( myIsPreviewMode || hasBadElems )
+  {
     list<int> aNodesConnectivity;
     typedef map<int, int> TNodesMap;
     TNodesMap nodesMap;
 
     SMESHDS_Mesh* aMeshDS;
-    std::auto_ptr< SMESH_MeshPartDS > aMeshPartDS;
+    std::unique_ptr< SMESH_MeshPartDS > aMeshPartDS;
     if ( hasBadElems ) {
       aMeshPartDS.reset( new SMESH_MeshPartDS( getEditor().GetError()->myBadElements ));
       aMeshDS = aMeshPartDS.get();
@@ -615,9 +618,9 @@ SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedNodes()
   SMESH::long_array_var myLastCreatedNodes = new SMESH::long_array();
 
   const SMESH_SequenceOfElemPtr& aSeq = getEditor().GetLastCreatedNodes();
-  myLastCreatedNodes->length( aSeq.Length() );
-  for (int i = 1; i <= aSeq.Length(); i++)
-    myLastCreatedNodes[i-1] = aSeq.Value(i)->GetID();
+  myLastCreatedNodes->length( aSeq.size() );
+  for ( size_t i = 0; i < aSeq.size(); i++)
+    myLastCreatedNodes[i] = aSeq[i]->GetID();
 
   return myLastCreatedNodes._retn();
   SMESH_CATCH( SMESH::throwCorbaException );
@@ -638,9 +641,9 @@ SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedElems()
   SMESH::long_array_var myLastCreatedElems = new SMESH::long_array();
 
   const SMESH_SequenceOfElemPtr& aSeq = getEditor().GetLastCreatedElems();
-  myLastCreatedElems->length( aSeq.Length() );
-  for ( int i = 1; i <= aSeq.Length(); i++ )
-    myLastCreatedElems[i-1] = aSeq.Value(i)->GetID();
+  myLastCreatedElems->length( aSeq.size() );
+  for ( size_t i = 0; i < aSeq.size(); i++ )
+    myLastCreatedElems[i] = aSeq[i]->GetID();
 
   return myLastCreatedElems._retn();
   SMESH_CATCH( SMESH::throwCorbaException );
@@ -4014,6 +4017,84 @@ SMESH_MeshEditor_i::ScaleMakeMesh(SMESH::SMESH_IDSource_ptr  theObject,
   return mesh._retn();
 }
 
+//================================================================================
+/*!
+ * \brief Make an offset mesh from a source 2D mesh
+ *  \param [inout] theObject - source mesh. New elements are added to this mesh
+ *         if \a theMeshName is empty.
+ *  \param [in] theValue - offset value
+ *  \param [in] theCopyGroups - to generate groups
+ *  \param [in] theMeshName - optional name of a new mesh
+ *  \param [out] theGroups - new groups
+ *  \return SMESH::SMESH_Mesh_ptr - the modified mesh
+ */
+//================================================================================
+
+SMESH::SMESH_Mesh_ptr SMESH_MeshEditor_i::Offset( SMESH::SMESH_IDSource_ptr theObject,
+                                                  CORBA::Double             theValue,
+                                                  CORBA::Boolean            theCopyGroups,
+                                                  const char*               theMeshName,
+                                                  SMESH::ListOfGroups_out   theGroups)
+  throw (SALOME::SALOME_Exception)
+{
+  SMESH_TRY;
+  initData();
+
+  SMESHDS_Mesh* aMeshDS = getMeshDS();
+
+  SMESH::SMESH_Mesh_var         mesh_var;
+  ::SMESH_MeshEditor::PGroupIDs groupIds;
+
+  TPythonDump pyDump;
+
+  TIDSortedElemSet elements, copyElements;
+  if ( idSourceToSet( theObject, aMeshDS, elements, SMDSAbs_Face,
+                      /*emptyIfIsMesh=*/ !myIsPreviewMode ))
+  {
+    // mesh to modify
+    SMESH_Mesh* tgtMesh = 0;
+    if ( myIsPreviewMode )
+    {
+      TPreviewMesh * tmpMesh = getPreviewMesh();
+      tgtMesh = tmpMesh;
+      tmpMesh->Copy( elements, copyElements );
+      theCopyGroups = false;
+    }
+    else
+    {
+      mesh_var =
+        *theMeshName ? makeMesh( theMeshName ) : SMESH::SMESH_Mesh::_duplicate( myMesh_i->_this() );
+      SMESH_Mesh_i* mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh_var );
+      tgtMesh = & mesh_i->GetImpl();
+    }
+    groupIds = getEditor().Offset( elements, theValue, tgtMesh, theCopyGroups, !myIsPreviewMode );
+
+    tgtMesh->GetMeshDS()->Modified();
+  }
+
+  if ( myIsPreviewMode )
+  {
+    getPreviewMesh()->Remove( SMESHUtils::elemSetIterator( copyElements ));
+  }
+  else
+  {
+    theGroups = theCopyGroups ? getGroups( groupIds.get() ) : new SMESH::ListOfGroups;
+
+    // result of Offset() is a tuple (mesh, groups)
+    if ( mesh_var->_is_nil() ) pyDump << myMesh_i->_this() << ", ";
+    else                       pyDump << mesh_var          << ", ";
+    pyDump << theGroups << " = "
+           << this << ".Offset( "
+           << theValue << ", "
+           << theCopyGroups << ", "
+           << "'" << theMeshName<< "')";
+  }
+
+  return mesh_var._retn();
+
+  SMESH_CATCH( SMESH::throwCorbaException );
+  return SMESH::SMESH_Mesh::_nil();
+}
 
 //=======================================================================
 //function : findCoincidentNodes
@@ -4713,8 +4794,7 @@ void SMESH_MeshEditor_i::FillHole(const SMESH::FreeBorder& theHole)
     getEditor().ClearLastCreated();
     SMESH_SequenceOfElemPtr& aSeq =
       const_cast<SMESH_SequenceOfElemPtr&>( getEditor().GetLastCreatedElems() );
-    for ( size_t i = 0; i < newFaces.size(); ++i )
-      aSeq.Append( newFaces[i] );
+    aSeq.swap( newFaces );
 
     TPythonDump() << this << ".FillHole( SMESH.FreeBorder(" << theHole.nodeIDs << " ))";
   }
@@ -5529,7 +5609,7 @@ bool SMESH_MeshEditor_i::idSourceToSet(SMESH::SMESH_IDSource_ptr  theIDSource,
  * \param theElements - container of elements to duplicate.
  * \param theGroupName - a name of group to contain the generated elements.
  *                    If a group with such a name already exists, the new elements
- *                    are added to the existng group, else a new group is created.
+ *                    are added to the existing group, else a new group is created.
  *                    If \a theGroupName is empty, new elements are not added 
  *                    in any group.
  * \return a group where the new elements are added. NULL if theGroupName == "".
@@ -5554,11 +5634,11 @@ SMESH_MeshEditor_i::DoubleElements(SMESH::SMESH_IDSource_ptr theElements,
   {
     getEditor().DoubleElements( elems );
 
-    if ( strlen( theGroupName ) && !getEditor().GetLastCreatedElems().IsEmpty() )
+    if ( strlen( theGroupName ) && !getEditor().GetLastCreatedElems().empty() )
     {
       // group type
       SMESH::ElementType type =
-        SMESH::ElementType( getEditor().GetLastCreatedElems().Value(1)->GetType() );
+        SMESH::ElementType( getEditor().GetLastCreatedElems()[0]->GetType() );
       // find existing group
       SMESH::ListOfGroups_var groups = myMesh_i->GetGroups();
       for ( size_t i = 0; i < groups->length(); ++i )
@@ -5578,8 +5658,8 @@ SMESH_MeshEditor_i::DoubleElements(SMESH::SMESH_IDSource_ptr theElements,
       {
         SMESHDS_Group* groupDS = static_cast< SMESHDS_Group* >( group_i->GetGroupDS() );
         const SMESH_SequenceOfElemPtr& aSeq = getEditor().GetLastCreatedElems();
-        for ( int i = 1; i <= aSeq.Length(); i++ )
-          groupDS->SMDSGroup().Add( aSeq(i) );
+        for ( size_t i = 0; i <= aSeq.size(); i++ )
+          groupDS->SMDSGroup().Add( aSeq[i] );
       }
     }
   }
@@ -6070,14 +6150,14 @@ SMESH_MeshEditor_i::DoubleNodeElemGroup2New(SMESH::SMESH_GroupBase_ptr theElems,
     // Create group with newly created elements
     CORBA::String_var elemGroupName = theElems->GetName();
     std::string aNewName = generateGroupName( std::string(elemGroupName.in()) + "_double");
-    if ( !getEditor().GetLastCreatedElems().IsEmpty() && theElemGroupNeeded )
+    if ( !getEditor().GetLastCreatedElems().empty() && theElemGroupNeeded )
     {
       SMESH::long_array_var anIds = GetLastCreatedElems();
       SMESH::ElementType aGroupType = myMesh_i->GetElementType(anIds[0], true);
       aNewElemGroup = myMesh_i->CreateGroup(aGroupType, aNewName.c_str());
       aNewElemGroup->Add(anIds);
     }
-    if ( !getEditor().GetLastCreatedNodes().IsEmpty() && theNodeGroupNeeded )
+    if ( !getEditor().GetLastCreatedNodes().empty() && theNodeGroupNeeded )
     {
       SMESH::long_array_var anIds = GetLastCreatedNodes();
       aNewNodeGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
@@ -6302,14 +6382,14 @@ SMESH_MeshEditor_i::DoubleNodeElemGroups2New(const SMESH::ListOfGroups& theElems
     // Create group with newly created elements
     CORBA::String_var elemGroupName = theElems[0]->GetName();
     std::string aNewName = generateGroupName( std::string(elemGroupName.in()) + "_double");
-    if ( !getEditor().GetLastCreatedElems().IsEmpty() && theElemGroupNeeded )
+    if ( !getEditor().GetLastCreatedElems().empty() && theElemGroupNeeded )
     {
       SMESH::long_array_var anIds = GetLastCreatedElems();
       SMESH::ElementType aGroupType = myMesh_i->GetElementType(anIds[0], true);
       aNewElemGroup = myMesh_i->CreateGroup(aGroupType, aNewName.c_str());
       aNewElemGroup->Add(anIds);
     }
-    if ( !getEditor().GetLastCreatedNodes().IsEmpty() && theNodeGroupNeeded )
+    if ( !getEditor().GetLastCreatedNodes().empty() && theNodeGroupNeeded )
     {
       SMESH::long_array_var anIds = GetLastCreatedNodes();
       aNewNodeGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
index bcc0dfc..72a5c31 100644 (file)
@@ -472,11 +472,18 @@ public:
                                        const SMESH::double_array& theScaleFact)
     throw (SALOME::SALOME_Exception);
 
-  SMESH::SMESH_Mesh_ptr ScaleMakeMesh(SMESH::SMESH_IDSource_ptr Object,
-                                      const SMESH::PointStruct& Point,
+  SMESH::SMESH_Mesh_ptr ScaleMakeMesh(SMESH::SMESH_IDSource_ptr  Object,
+                                      const SMESH::PointStruct&  Point,
                                       const SMESH::double_array& theScaleFact,
-                                      CORBA::Boolean            CopyGroups,
-                                      const char*               MeshName)
+                                      CORBA::Boolean             CopyGroups,
+                                      const char*                MeshName)
+    throw (SALOME::SALOME_Exception);
+
+  SMESH::SMESH_Mesh_ptr Offset( SMESH::SMESH_IDSource_ptr theObject,
+                                CORBA::Double             Value,
+                                CORBA::Boolean            CopyGroups,
+                                const char*               MeshName,
+                                SMESH::ListOfGroups_out   Groups)
     throw (SALOME::SALOME_Exception);
 
   void FindCoincidentNodes (CORBA::Double                  Tolerance,
@@ -983,8 +990,6 @@ public:
 
   // temporary IDSources
   struct _IDSource;
-  // std::list< _IDSource* >      myAuxIDSources;
-  // void                         deleteAuxIDSources();
 };
 
 #endif
index 52baab3..b5977f5 100644 (file)
@@ -90,7 +90,7 @@ namespace SMESH
 
   // ===========================================================================================
   /*!
-   * \brief Object used to make TPythonDump know that its held value can be a varible
+   * \brief Object used to make TPythonDump know that its held value can be a variable
    *
    * TPythonDump substitute TVar with names of notebook variables if any.
    */
index 270d594..f2641f7 100644 (file)
@@ -4583,6 +4583,24 @@ class Mesh:
         self.mesh.SetParameters(Parameters)
         return Mesh( self.smeshpyD, self.geompyD, mesh )
 
+    ## Create an offset mesh from the given 2D object
+    #  @param theObject the source object (mesh, submesh, group or filter)
+    #  @param theValue signed offset size
+    #  @param MakeGroups forces the generation of new groups from existing ones
+    #  @param NewMeshName the name of a mesh to create. If empty, offset elements are added
+    #         to this mesh
+    #  @return a tuple (mesh, list_of_groups)
+    #  @ingroup l2_modif_trsf
+    def Offset(self, theObject, theValue, MakeGroups=False, NewMeshName=''):
+        if isinstance( theObject, Mesh ):
+            theObject = theObject.GetMesh()
+        theValue,Parameters,hasVars = ParseParameters(theValue)
+        mesh_groups = self.editor.Offset(theObject, theValue, MakeGroups, NewMeshName )
+        self.mesh.SetParameters(Parameters)
+        # if mesh_groups[0]:
+        #     return Mesh( self.smeshpyD, self.geompyD, mesh_groups[0] ), mesh_groups[1]
+        return mesh_groups
+
     ## Find groups of adjacent nodes within Tolerance.
     #  @param Tolerance the value of tolerance
     #  @param SeparateCornerAndMediumNodes if @c True, in quadratic mesh puts
@@ -4794,7 +4812,7 @@ class Mesh:
     #         a Mesh, elements of highest dimension are duplicated
     #  @param theGroupName - a name of group to contain the generated elements.
     #                    If a group with such a name already exists, the new elements
-    #                    are added to the existng group, else a new group is created.
+    #                    are added to the existing group, else a new group is created.
     #                    If \a theGroupName is empty, new elements are not added 
     #                    in any group.
     # @return a group where the new elements are added. None if theGroupName == "".
index 62e590b..2c1beef 100644 (file)
@@ -2613,34 +2613,34 @@ namespace
   {
     enum { X = 1, Y = 2, Z = 4 }; // == 001, 010, 100
     int nbFacets = 0;
-    int vertex = 0, egdeMask = 0;
+    int vertex = 0, edgeMask = 0;
 
     if ( Abs( _grid->_coords[0][ _i   ] - ip->_uvw[0] ) < _grid->_tol ) {
       facets[ nbFacets++ ] = SMESH_Block::ID_F0yz;
-      egdeMask |= X;
+      edgeMask |= X;
     }
     else if ( Abs( _grid->_coords[0][ _i+1 ] - ip->_uvw[0] ) < _grid->_tol ) {
       facets[ nbFacets++ ] = SMESH_Block::ID_F1yz;
       vertex   |= X;
-      egdeMask |= X;
+      edgeMask |= X;
     }
     if ( Abs( _grid->_coords[1][ _j   ] - ip->_uvw[1] ) < _grid->_tol ) {
       facets[ nbFacets++ ] = SMESH_Block::ID_Fx0z;
-      egdeMask |= Y;
+      edgeMask |= Y;
     }
     else if ( Abs( _grid->_coords[1][ _j+1 ] - ip->_uvw[1] ) < _grid->_tol ) {
       facets[ nbFacets++ ] = SMESH_Block::ID_Fx1z;
       vertex   |= Y;
-      egdeMask |= Y;
+      edgeMask |= Y;
     }
     if ( Abs( _grid->_coords[2][ _k   ] - ip->_uvw[2] ) < _grid->_tol ) {
       facets[ nbFacets++ ] = SMESH_Block::ID_Fxy0;
-      egdeMask |= Z;
+      edgeMask |= Z;
     }
     else if ( Abs( _grid->_coords[2][ _k+1 ] - ip->_uvw[2] ) < _grid->_tol ) {
       facets[ nbFacets++ ] = SMESH_Block::ID_Fxy1;
       vertex   |= Z;
-      egdeMask |= Z;
+      edgeMask |= Z;
     }
 
     switch ( nbFacets )
@@ -2656,7 +2656,7 @@ namespace
         { SMESH_Block::ID_Ex00, 0, SMESH_Block::ID_Ex10, 0,
           SMESH_Block::ID_Ex01, 0, SMESH_Block::ID_Ex11 }
       };
-      switch ( egdeMask ) {
+      switch ( edgeMask ) {
       case X | Y: sub = edge[ 0 ][ vertex ]; break;
       case X | Z: sub = edge[ 1 ][ vertex ]; break;
       default:    sub = edge[ 2 ][ vertex ];
index 9f87234..f7698b5 100644 (file)
@@ -219,7 +219,7 @@ bool StdMeshersGUI_PropagationHelperWdg::buildChains()
   // aPreviewActor holds a map od all sub-shapes of mainShape
   SMESH_PreviewActorsCollection* previewActor = mySubSelectWdg->GetActorCollection();
   if ( !previewActor ) return false;
-  const QList<int>& egdeIDs = previewActor->GetIndices();
+  const QList<int>& edgeIDs = previewActor->GetIndices();
 
   // Make a 'map' of WIREs of EDGE with quadrilateral WIREs only
 
@@ -277,11 +277,11 @@ bool StdMeshersGUI_PropagationHelperWdg::buildChains()
 
   TColStd_MapOfInteger shapeEdges;
   if ( !shape.IsSame( mainShape ))
-    for ( QList<TGeomID>::const_iterator ieIt = egdeIDs.begin(); ieIt != egdeIDs.end(); ++ieIt )
+    for ( QList<TGeomID>::const_iterator ieIt = edgeIDs.begin(); ieIt != edgeIDs.end(); ++ieIt )
       shapeEdges.Add( *ieIt );
 
   // loop on all EDGEs in mainShape
-  for ( QList<TGeomID>::const_iterator ieIt = egdeIDs.begin(); ieIt != egdeIDs.end(); ++ieIt )
+  for ( QList<TGeomID>::const_iterator ieIt = edgeIDs.begin(); ieIt != edgeIDs.end(); ++ieIt )
   {
     if ( chainedEdges.Contains( *ieIt ))
       continue;
@@ -329,7 +329,7 @@ bool StdMeshersGUI_PropagationHelperWdg::buildChains()
       if ( ch.size() < 2 )
         myChains.pop_back();
     }
-  } // loop on egdeIDs
+  } // loop on edgeIDs
 
   return !myChains.empty();
 }
index a5d363c..185f666 100644 (file)
@@ -56,8 +56,8 @@ def PublishGroups ():
                 TempNames = []
                 for MacroObj in Config.ListObj :
                         if group in MacroObj.GroupNames :
-                                Occurences = IndexMultiOcc(MacroObj.GroupNames, group)
-                                for Occ in Occurences :
+                                Occurrences = IndexMultiOcc(MacroObj.GroupNames, group)
+                                for Occ in Occurrences :
                                         TempGEOList += MacroObj.GetBorder(Occ)
                 GroupGEO.append(geompy.MakeCompound(TempGEOList))
                 geompy.addToStudyInFather(FinalCompound,GroupGEO[-1],'GR_'+group)
index ba6fef3..d8a1f56 100644 (file)
@@ -35,7 +35,7 @@ These two parameters allow the user to prescribe a Maximal/Minimal size for the
 
 - **Mesh gradation**
 This parameter P controls the element size variation : MeshGems-SurfOpt will avoid having two adjacent edges which sizes vary more than the given gradation. A size correction is applied to the size map : if two adjacent edges are respectively e1 and e2 long and e2 > Pxe1, then, the new size for the second edge will be set to P x e1.
-**This procedure is deactived if P=-1**
+**This procedure is deactivated if P=-1**
 
 
 
index 8d9cf55..14e9b99 100644 (file)
@@ -22,7 +22,7 @@ Simple case
 Optimisation
 ------------
     
-This is the main remeshing Option.  SurfOpt always does quality improvement. It is done by point smooting and edge swapping.  It can produce a regular mesh for finite element computation (initial mesh is a a geometrical mesh). In this case, the given surface trianglation is modified in accordance to a size map : an intrinsic size map is computed automatically. it is based on the surface proporties.  SurfOpt is also able to  produce a geometrical mesh (initial mesh is a a mesh for finite element computation). In both case, It can coarsen or enrich the mesh.     
+This is the main remeshing Option.  SurfOpt always does quality improvement. It is done by point smoothing and edge swapping.  It can produce a regular mesh for finite element computation (initial mesh is a a geometrical mesh). In this case, the given surface trianglation is modified in accordance to a size map : an intrinsic size map is computed automatically. it is based on the surface proporties.  SurfOpt is also able to  produce a geometrical mesh (initial mesh is a mesh for finite element computation). In both case, It can coarsen or enrich the mesh.     
 
    - **Quality improvement** 
 
index 4fec4e8..4d2a631 100644 (file)
@@ -100,10 +100,10 @@ class PluginDialog(QDialog):
 
     def setupJobManager(self):
         '''
-        This function configures the jobmanager by transmiting the
+        This function configures the jobmanager by transmitting the
         parameters required for a local execution and a remote
         execution. The choice between "local" and "remote" is done at
-        the initialize step, by specifing the name of the resource to
+        the initialize step, by specifying the name of the resource to
         be used.
         '''
         # We first