src/SMESH_I/SMESH_MeshEditor_i.cxx

   1 // Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 //  File   : SMESH_MeshEditor_i.cxx
  23 //  Author : Nicolas REJNERI
  24 //  Module : SMESH
  25
  26 #ifdef WIN32
  27 #define NOMINMAX
  28 #endif
  29
  30 // A macro used in SMESH_TryCatch.hxx,
  31 // it re-raises a CORBA SALOME exception thrown by SMESH_MeshEditor_i and caught by SMESH_CATCH
  32 #define SMY_OWN_CATCH \
  33   catch ( SALOME::SALOME_Exception & e ) { throw e; }
  34
  35 #include "SMESH_MeshEditor_i.hxx"
  36
  37 #include "SMDS_EdgePosition.hxx"
  38 #include "SMDS_ElemIterator.hxx"
  39 #include "SMDS_FacePosition.hxx"
  40 #include "SMDS_IteratorOnIterators.hxx"
  41 #include "SMDS_LinearEdge.hxx"
  42 #include "SMDS_Mesh0DElement.hxx"
  43 #include "SMDS_MeshFace.hxx"
  44 #include "SMDS_MeshVolume.hxx"
  45 #include "SMDS_SetIterator.hxx"
  46 #include "SMDS_VolumeTool.hxx"
  47 #include "SMESHDS_Group.hxx"
  48 #include "SMESHDS_GroupOnGeom.hxx"
  49 #include "SMESH_ControlsDef.hxx"
  50 #include "SMESH_Filter_i.hxx"
  51 #include "SMESH_Gen_i.hxx"
  52 #include "SMESH_Group.hxx"
  53 #include "SMESH_Group_i.hxx"
  54 #include "SMESH_MeshAlgos.hxx"
  55 #include "SMESH_MeshPartDS.hxx"
  56 #include "SMESH_MesherHelper.hxx"
  57 #include "SMESH_PythonDump.hxx"
  58 #include "SMESH_subMeshEventListener.hxx"
  59 #include "SMESH_subMesh_i.hxx"
  60
  61 #include <utilities.h>
  62 #include <Utils_ExceptHandlers.hxx>
  63 #include <Utils_CorbaException.hxx>
  64 #include <SALOMEDS_wrap.hxx>
  65 #include <SALOME_GenericObj_i.hh>
  66
  67 #include <BRepAdaptor_Surface.hxx>
  68 #include <BRep_Tool.hxx>
  69 #include <TopExp_Explorer.hxx>
  70 #include <TopoDS.hxx>
  71 #include <TopoDS_Edge.hxx>
  72 #include <TopoDS_Face.hxx>
  73 #include <gp_Ax1.hxx>
  74 #include <gp_Ax2.hxx>
  75 #include <gp_Vec.hxx>
  76
  77 #include <Standard_Failure.hxx>
  78 #include <Standard_ErrorHandler.hxx>
  79
  80 #include <sstream>
  81 #include <limits>
  82
  83 #include "SMESH_TryCatch.hxx" // include after OCCT headers!
  84
  85 #define cast2Node(elem) static_cast<const SMDS_MeshNode*>( elem )
  86
  87 using namespace std;
  88 using SMESH::TPythonDump;
  89 using SMESH::TVar;
  90
  91 namespace MeshEditor_I {
  92
  93   //=============================================================================
  94   /*!
  95    * \brief Mesh to apply modifications for preview purposes
  96    */
  97   //=============================================================================
  98
  99   struct TPreviewMesh: public SMESH_Mesh
 100   {
 101     SMDSAbs_ElementType myPreviewType; // type to show
 102     //!< Constructor
 103     TPreviewMesh(SMDSAbs_ElementType previewElements = SMDSAbs_All) {
 104       _isShapeToMesh = (_id = 0);
 105       _myMeshDS  = new SMESHDS_Mesh( _id, true );
 106       myPreviewType = previewElements;
 107     }
 108     //!< Copy a set of elements
 109     void Copy(const TIDSortedElemSet & theElements,
 110               TIDSortedElemSet&        theCopyElements,
 111               SMDSAbs_ElementType      theSelectType = SMDSAbs_All,
 112               SMDSAbs_ElementType      theAvoidType = SMDSAbs_All)
 113     {
 114       // loop on theIDsOfElements
 115       TIDSortedElemSet::const_iterator eIt = theElements.begin();
 116       for ( ; eIt != theElements.end(); ++eIt )
 117       {
 118         const SMDS_MeshElement* anElem = *eIt;
 119         if ( !anElem ) continue;
 120         SMDSAbs_ElementType type = anElem->GetType();
 121         if ( type == theAvoidType ||
 122              ( theSelectType != SMDSAbs_All && type != theSelectType ))
 123           continue;
 124         const SMDS_MeshElement* anElemCopy;
 125         if ( type == SMDSAbs_Node)
 126           anElemCopy = Copy( cast2Node(anElem) );
 127         else
 128           anElemCopy = Copy( anElem );
 129         if ( anElemCopy )
 130           theCopyElements.insert( theCopyElements.end(), anElemCopy );
 131       }
 132     }
 133     //!< Copy an element
 134     SMDS_MeshElement* Copy( const SMDS_MeshElement* anElem )
 135     {
 136       // copy element nodes
 137       int anElemNbNodes = anElem->NbNodes();
 138       vector< int > anElemNodesID( anElemNbNodes ) ;
 139       SMDS_ElemIteratorPtr itElemNodes = anElem->nodesIterator();
 140       for ( int i = 0; itElemNodes->more(); i++)
 141       {
 142         const SMDS_MeshNode* anElemNode = cast2Node( itElemNodes->next() );
 143         Copy( anElemNode );
 144         anElemNodesID[i] = anElemNode->GetID();
 145       }
 146
 147       // creates a corresponding element on copied nodes
 148       ::SMESH_MeshEditor::ElemFeatures elemType;
 149       elemType.Init( anElem, /*basicOnly=*/false );
 150       elemType.SetID( anElem->GetID() );
 151       SMDS_MeshElement* anElemCopy =
 152         ::SMESH_MeshEditor(this).AddElement( anElemNodesID, elemType );
 153       return anElemCopy;
 154     }
 155     //!< Copy a node
 156     SMDS_MeshNode* Copy( const SMDS_MeshNode* anElemNode )
 157     {
 158       return _myMeshDS->AddNodeWithID(anElemNode->X(), anElemNode->Y(), anElemNode->Z(),
 159                                       anElemNode->GetID());
 160     }
 161     void RemoveAll()
 162     {
 163       GetMeshDS()->ClearMesh();
 164     }
 165     void Remove( SMDSAbs_ElementType type )
 166     {
 167       Remove( GetMeshDS()->elementsIterator( type ));
 168     }
 169     void Remove( SMDS_ElemIteratorPtr eIt )
 170     {
 171       while ( eIt->more() )
 172         GetMeshDS()->RemoveFreeElement( eIt->next(), /*sm=*/0, /*fromGroups=*/false );
 173     }
 174   };// struct TPreviewMesh
 175
 176   static SMESH_NodeSearcher *    theNodeSearcher    = 0;
 177   static SMESH_ElementSearcher * theElementSearcher = 0;
 178
 179   //=============================================================================
 180   /*!
 181    * \brief Deleter of theNodeSearcher at any compute event occurred
 182    */
 183   //=============================================================================
 184
 185   struct TSearchersDeleter : public SMESH_subMeshEventListener
 186   {
 187     SMESH_Mesh* myMesh;
 188     string      myMeshPartIOR;
 189     //!< Constructor
 190     TSearchersDeleter(): SMESH_subMeshEventListener( false, // won't be deleted by submesh
 191                                                      "SMESH_MeshEditor_i::TSearchersDeleter"),
 192                          myMesh(0) {}
 193     //!< Delete theNodeSearcher
 194     static void Delete()
 195     {
 196       if ( theNodeSearcher )    delete theNodeSearcher;    theNodeSearcher    = 0;
 197       if ( theElementSearcher ) delete theElementSearcher; theElementSearcher = 0;
 198     }
 199     typedef map < int, SMESH_subMesh * > TDependsOnMap;
 200     //!< The meshod called by submesh: do my main job
 201     void ProcessEvent(const int, const int eventType, SMESH_subMesh* sm,
 202                       SMESH_subMeshEventListenerData*,const SMESH_Hypothesis*)
 203     {
 204       if ( eventType == SMESH_subMesh::COMPUTE_EVENT ) {
 205         Delete();
 206         Unset( sm->GetFather() );
 207       }
 208     }
 209     //!< set self on all submeshes and delete theNodeSearcher if other mesh is set
 210     void Set(SMESH_Mesh* mesh, const string& meshPartIOR = string())
 211     {
 212       if ( myMesh != mesh || myMeshPartIOR != meshPartIOR)
 213       {
 214         if ( myMesh ) {
 215           Delete();
 216           Unset( myMesh );
 217         }
 218         myMesh = mesh;
 219         myMeshPartIOR = meshPartIOR;
 220         SMESH_subMesh* sm = mesh->GetSubMesh( mesh->GetShapeToMesh() );
 221         SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator( /*includeSelf=*/true );
 222         while ( smIt->more() )
 223         {
 224           sm = smIt->next();
 225           sm->SetEventListener( this, 0, sm );
 226         }
 227       }
 228     }
 229     //!<  delete self from all submeshes
 230     void Unset(SMESH_Mesh* mesh)
 231     {
 232       if ( SMESH_subMesh* sm = mesh->GetSubMeshContaining(1) ) {
 233         SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator( /*includeSelf=*/true );
 234         while ( smIt->more() )
 235           smIt->next()->DeleteEventListener( this );
 236       }
 237       myMesh = 0;
 238     }
 239
 240   } theSearchersDeleter;
 241
 242   TCollection_AsciiString mirrorTypeName( SMESH::SMESH_MeshEditor::MirrorType theMirrorType )
 243   {
 244     TCollection_AsciiString typeStr;
 245     switch ( theMirrorType ) {
 246     case  SMESH::SMESH_MeshEditor::POINT:
 247       typeStr = "SMESH.SMESH_MeshEditor.POINT";
 248       break;
 249     case  SMESH::SMESH_MeshEditor::AXIS:
 250       typeStr = "SMESH.SMESH_MeshEditor.AXIS";
 251       break;
 252     default:
 253       typeStr = "SMESH.SMESH_MeshEditor.PLANE";
 254     }
 255     return typeStr;
 256   }
 257   //================================================================================
 258   /*!
 259    * \brief function for conversion of long_array to TIDSortedElemSet
 260    * \param IDs - array of IDs
 261    * \param aMesh - mesh
 262    * \param aMap - collection to fill
 263    * \param aType - element type
 264    */
 265   //================================================================================
 266
 267   void arrayToSet(const SMESH::long_array & IDs,
 268                   const SMESHDS_Mesh*       aMesh,
 269                   TIDSortedElemSet&         aMap,
 270                   const SMDSAbs_ElementType aType = SMDSAbs_All,
 271                   SMDS_MeshElement::Filter* aFilter = NULL)
 272   {
 273     SMDS_MeshElement::NonNullFilter filter1;
 274     SMDS_MeshElement::TypeFilter    filter2( aType );
 275
 276     if ( aFilter == NULL )
 277       aFilter = ( aType == SMDSAbs_All ) ? (SMDS_MeshElement::Filter*) &filter1 : (SMDS_MeshElement::Filter*) &filter2;
 278
 279     SMDS_MeshElement::Filter & filter = *aFilter;
 280
 281     if ( aType == SMDSAbs_Node )
 282       for ( CORBA::ULong i = 0; i < IDs.length(); i++ ) {
 283         const SMDS_MeshElement * elem = aMesh->FindNode( IDs[i] );
 284         if ( filter( elem ))
 285           aMap.insert( aMap.end(), elem );
 286       }
 287     else
 288       for ( CORBA::ULong i = 0; i<IDs.length(); i++) {
 289         const SMDS_MeshElement * elem = aMesh->FindElement( IDs[i] );
 290         if ( filter( elem ))
 291           aMap.insert( aMap.end(), elem );
 292       }
 293   }
 294
 295   //================================================================================
 296   /*!
 297    * \brief Retrieve nodes from SMESH_IDSource
 298    */
 299   //================================================================================
 300
 301   void idSourceToNodeSet(SMESH::SMESH_IDSource_ptr  theObject,
 302                          const SMESHDS_Mesh*        theMeshDS,
 303                          TIDSortedNodeSet&          theNodeSet)
 304
 305   {
 306     if ( CORBA::is_nil( theObject ) )
 307       return;
 308     SMESH::array_of_ElementType_var types = theObject->GetTypes();
 309     SMESH::long_array_var     aElementsId = theObject->GetIDs();
 310     if ( types->length() == 1 && types[0] == SMESH::NODE)
 311     {
 312       for ( CORBA::ULong i = 0; i < aElementsId->length(); i++ )
 313         if ( const SMDS_MeshNode * n = theMeshDS->FindNode( aElementsId[i] ))
 314           theNodeSet.insert( theNodeSet.end(), n);
 315     }
 316     else if ( SMESH::DownCast<SMESH_Mesh_i*>( theObject ))
 317     {
 318       SMDS_NodeIteratorPtr nIt = theMeshDS->nodesIterator();
 319       while ( nIt->more( ))
 320         if ( const SMDS_MeshElement * elem = nIt->next() )
 321           theNodeSet.insert( elem->begin_nodes(), elem->end_nodes());
 322     }
 323     else
 324     {
 325       for ( CORBA::ULong i = 0; i < aElementsId->length(); i++ )
 326         if ( const SMDS_MeshElement * elem = theMeshDS->FindElement( aElementsId[i] ))
 327           theNodeSet.insert( elem->begin_nodes(), elem->end_nodes());
 328     }
 329   }
 330
 331   //================================================================================
 332   /*!
 333    * \brief Returns elements connected to the given elements
 334    */
 335   //================================================================================
 336
 337   void getElementsAround(const TIDSortedElemSet& theElements,
 338                          const SMESHDS_Mesh*     theMeshDS,
 339                          TIDSortedElemSet&       theElementsAround)
 340   {
 341     if ( theElements.empty() ) return;
 342
 343     SMDSAbs_ElementType elemType    = (*theElements.begin())->GetType();
 344     bool sameElemType = ( elemType == (*theElements.rbegin())->GetType() );
 345     if ( sameElemType &&
 346          theMeshDS->GetMeshInfo().NbElements( elemType ) == (int) theElements.size() )
 347       return; // all the elements are in theElements
 348
 349     if ( !sameElemType )
 350       elemType = SMDSAbs_All;
 351
 352     vector<bool> isNodeChecked( theMeshDS->NbNodes(), false );
 353
 354     TIDSortedElemSet::const_iterator elemIt = theElements.begin();
 355     for ( ; elemIt != theElements.end(); ++elemIt )
 356     {
 357       const SMDS_MeshElement* e = *elemIt;
 358       int i = e->NbCornerNodes();
 359       while ( --i != -1 )
 360       {
 361         const SMDS_MeshNode* n = e->GetNode( i );
 362         if ( !isNodeChecked[ n->GetID() ])
 363         {
 364           isNodeChecked[ n->GetID() ] = true;
 365           SMDS_ElemIteratorPtr invIt = n->GetInverseElementIterator(elemType);
 366           while ( invIt->more() )
 367           {
 368             const SMDS_MeshElement* elemAround = invIt->next();
 369             if ( !theElements.count( elemAround ))
 370               theElementsAround.insert( elemAround );
 371           }
 372         }
 373       }
 374     }
 375   }
 376
 377   //================================================================================
 378   /*!
 379    * \brief Return a string used to detect change of mesh part on which theElementSearcher
 380    * is going to be used
 381    */
 382   //================================================================================
 383
 384   string getPartIOR( SMESH::SMESH_IDSource_ptr theMeshPart, SMESH::ElementType type)
 385   {
 386     string partIOR = SMESH_Gen_i::GetORB()->object_to_string( theMeshPart );
 387     if ( SMESH_Group_i* group_i = SMESH::DownCast<SMESH_Group_i*>( theMeshPart ))
 388       // take into account passible group modification
 389       partIOR += SMESH_Comment( ((SMESHDS_Group*)group_i->GetGroupDS())->SMDSGroup().Tic() );
 390     partIOR += SMESH_Comment( type );
 391     return partIOR;
 392   }
 393
 394 } // namespace MeshEditor_I
 395
 396 using namespace MeshEditor_I;
 397
 398 //=============================================================================
 399 /*!
 400  *
 401  */
 402 //=============================================================================
 403
 404 SMESH_MeshEditor_i::SMESH_MeshEditor_i(SMESH_Mesh_i* theMesh, bool isPreview):
 405   myMesh_i( theMesh ),
 406   myMesh( &theMesh->GetImpl() ),
 407   myEditor( myMesh ),
 408   myIsPreviewMode ( isPreview ),
 409   myPreviewMesh( 0 ),
 410   myPreviewEditor( 0 )
 411 {
 412 }
 413
 414 //================================================================================
 415 /*!
 416  * \brief Destructor
 417  */
 418 //================================================================================
 419
 420 SMESH_MeshEditor_i::~SMESH_MeshEditor_i()
 421 {
 422   PortableServer::POA_var poa = SMESH_Gen_i::GetPOA();
 423   PortableServer::ObjectId_var anObjectId = poa->servant_to_id(this);
 424   poa->deactivate_object(anObjectId.in());
 425
 426   //deleteAuxIDSources();
 427   delete myPreviewMesh;   myPreviewMesh = 0;
 428   delete myPreviewEditor; myPreviewEditor = 0;
 429 }
 430
 431 //================================================================================
 432 /*!
 433  * \brief Returns the mesh
 434  */
 435 //================================================================================
 436
 437 SMESH::SMESH_Mesh_ptr SMESH_MeshEditor_i::GetMesh()
 438 {
 439   return myMesh_i->_this();
 440 }
 441
 442 //================================================================================
 443 /*!
 444  * \brief Clear members
 445  */
 446 //================================================================================
 447
 448 void SMESH_MeshEditor_i::initData(bool deleteSearchers)
 449 {
 450   if ( myIsPreviewMode ) {
 451     if ( myPreviewMesh ) myPreviewMesh->RemoveAll();
 452   }
 453   else {
 454     if ( deleteSearchers )
 455       TSearchersDeleter::Delete();
 456   }
 457   getEditor().GetError().reset();
 458   getEditor().ClearLastCreated();
 459 }
 460
 461 //================================================================================
 462 /*!
 463  * \brief Increment mesh modif time and optionally record that the performed
 464  *        modification may influence further mesh re-compute.
 465  *  \param [in] isReComputeSafe - true if the modification does not influence
 466  *              further mesh re-compute
 467  */
 468 //================================================================================
 469
 470 void SMESH_MeshEditor_i::declareMeshModified( bool isReComputeSafe )
 471 {
 472   myMesh->GetMeshDS()->Modified();
 473   if ( !isReComputeSafe )
 474     myMesh->SetIsModified( true );
 475 }
 476
 477 //================================================================================
 478 /*!
 479  * \brief Return either myEditor or myPreviewEditor depending on myIsPreviewMode.
 480  *        WARNING: in preview mode call getPreviewMesh() before getEditor()!
 481  */
 482 //================================================================================
 483
 484 ::SMESH_MeshEditor& SMESH_MeshEditor_i::getEditor()
 485 {
 486   if ( myIsPreviewMode && !myPreviewEditor ) {
 487     if ( !myPreviewMesh ) getPreviewMesh();
 488     myPreviewEditor = new ::SMESH_MeshEditor( myPreviewMesh );
 489   }
 490   return myIsPreviewMode ? *myPreviewEditor : myEditor;
 491 }
 492
 493 //================================================================================
 494 /*!
 495  * \brief Initialize and return myPreviewMesh
 496  *  \param previewElements - type of elements to show in preview
 497  *
 498  *  WARNING: call it once per method!
 499  */
 500 //================================================================================
 501
 502 TPreviewMesh * SMESH_MeshEditor_i::getPreviewMesh(SMDSAbs_ElementType previewElements)
 503 {
 504   if ( !myPreviewMesh || myPreviewMesh->myPreviewType != previewElements )
 505   {
 506     delete myPreviewEditor;
 507     myPreviewEditor = 0;
 508     delete myPreviewMesh;
 509     myPreviewMesh = new TPreviewMesh( previewElements );
 510   }
 511   myPreviewMesh->Clear();
 512   return myPreviewMesh;
 513 }
 514
 515 //================================================================================
 516 /*!
 517  * Return data of mesh edition preview
 518  */
 519 //================================================================================
 520
 521 SMESH::MeshPreviewStruct* SMESH_MeshEditor_i::GetPreviewData()
 522   throw (SALOME::SALOME_Exception)
 523 {
 524   SMESH_TRY;
 525   const bool hasBadElems = ( getEditor().GetError() && getEditor().GetError()->HasBadElems() );
 526
 527   if ( myIsPreviewMode || hasBadElems )
 528   {
 529     list<int> aNodesConnectivity;
 530     typedef map<int, int> TNodesMap;
 531     TNodesMap nodesMap;
 532
 533     SMESHDS_Mesh* aMeshDS;
 534     std::unique_ptr< SMESH_MeshPartDS > aMeshPartDS;
 535     if ( hasBadElems ) {
 536       const list<const SMDS_MeshElement*>& badElems =
 537         static_cast<SMESH_BadInputElements*>( getEditor().GetError().get() )->myBadElements;
 538       aMeshPartDS.reset( new SMESH_MeshPartDS( badElems ));
 539       aMeshDS = aMeshPartDS.get();
 540     }
 541     else {
 542       aMeshDS = getEditor().GetMeshDS();
 543     }
 544     myPreviewData = new SMESH::MeshPreviewStruct();
 545     myPreviewData->nodesXYZ.length(aMeshDS->NbNodes());
 546
 547
 548     SMDSAbs_ElementType previewType = SMDSAbs_All;
 549     if ( !hasBadElems )
 550       if (TPreviewMesh * aPreviewMesh = dynamic_cast< TPreviewMesh* >( getEditor().GetMesh() )) {
 551         previewType = aPreviewMesh->myPreviewType;
 552         switch ( previewType ) {
 553         case SMDSAbs_Edge  : break;
 554         case SMDSAbs_Face  : break;
 555         case SMDSAbs_Volume: break;
 556         default:;
 557           if ( aMeshDS->GetMeshInfo().NbElements() == 0 ) previewType = SMDSAbs_Node;
 558         }
 559       }
 560
 561     myPreviewData->elementTypes.length( aMeshDS->GetMeshInfo().NbElements( previewType ));
 562     int i = 0, j = 0;
 563     SMDS_ElemIteratorPtr itMeshElems = aMeshDS->elementsIterator(previewType);
 564
 565     while ( itMeshElems->more() ) {
 566       const SMDS_MeshElement* aMeshElem = itMeshElems->next();
 567       SMDS_NodeIteratorPtr itElemNodes =
 568         (( aMeshElem->GetEntityType() == SMDSEntity_Quad_Polygon ) ?
 569          aMeshElem->interlacedNodesIterator() :
 570          aMeshElem->nodeIterator() );
 571       while ( itElemNodes->more() ) {
 572         const SMDS_MeshNode* aMeshNode = itElemNodes->next();
 573         int aNodeID = aMeshNode->GetID();
 574         TNodesMap::iterator anIter = nodesMap.find(aNodeID);
 575         if ( anIter == nodesMap.end() ) {
 576           // filling the nodes coordinates
 577           myPreviewData->nodesXYZ[j].x = aMeshNode->X();
 578           myPreviewData->nodesXYZ[j].y = aMeshNode->Y();
 579           myPreviewData->nodesXYZ[j].z = aMeshNode->Z();
 580           anIter = nodesMap.insert( make_pair(aNodeID, j) ).first;
 581           j++;
 582         }
 583         aNodesConnectivity.push_back(anIter->second);
 584       }
 585
 586       // filling the elements types
 587       SMDSAbs_ElementType aType = aMeshElem->GetType();
 588       bool               isPoly = aMeshElem->IsPoly();
 589       myPreviewData->elementTypes[i].SMDS_ElementType = (SMESH::ElementType) aType;
 590       myPreviewData->elementTypes[i].isPoly           = isPoly;
 591       myPreviewData->elementTypes[i].nbNodesInElement = aMeshElem->NbNodes();
 592       i++;
 593     }
 594     myPreviewData->nodesXYZ.length( j );
 595
 596     // filling the elements connectivities
 597     list<int>::iterator aConnIter = aNodesConnectivity.begin();
 598     myPreviewData->elementConnectivities.length(aNodesConnectivity.size());
 599     for( int i = 0; aConnIter != aNodesConnectivity.end(); aConnIter++, i++ )
 600       myPreviewData->elementConnectivities[i] = *aConnIter;
 601   }
 602   return myPreviewData._retn();
 603
 604   SMESH_CATCH( SMESH::throwCorbaException );
 605   return 0;
 606 }
 607
 608 //================================================================================
 609 /*!
 610  * \brief Returns list of it's IDs of created nodes
 611  * \retval SMESH::long_array* - list of node ID
 612  */
 613 //================================================================================
 614
 615 SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedNodes()
 616   throw (SALOME::SALOME_Exception)
 617 {
 618   SMESH_TRY;
 619   SMESH::long_array_var myLastCreatedNodes = new SMESH::long_array();
 620
 621   const SMESH_SequenceOfElemPtr& aSeq = getEditor().GetLastCreatedNodes();
 622   myLastCreatedNodes->length( aSeq.size() );
 623   for ( size_t i = 0; i < aSeq.size(); i++)
 624     myLastCreatedNodes[i] = aSeq[i]->GetID();
 625
 626   return myLastCreatedNodes._retn();
 627   SMESH_CATCH( SMESH::throwCorbaException );
 628   return 0;
 629 }
 630
 631 //================================================================================
 632 /*!
 633  * \brief Returns list of it's IDs of created elements
 634  * \retval SMESH::long_array* - list of elements' ID
 635  */
 636 //================================================================================
 637
 638 SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedElems()
 639   throw (SALOME::SALOME_Exception)
 640 {
 641   SMESH_TRY;
 642   SMESH::long_array_var myLastCreatedElems = new SMESH::long_array();
 643
 644   const SMESH_SequenceOfElemPtr& aSeq = getEditor().GetLastCreatedElems();
 645   myLastCreatedElems->length( aSeq.size() );
 646   for ( size_t i = 0; i < aSeq.size(); i++ )
 647     myLastCreatedElems[i] = aSeq[i]->GetID();
 648
 649   return myLastCreatedElems._retn();
 650   SMESH_CATCH( SMESH::throwCorbaException );
 651   return 0;
 652 }
 653
 654 //=======================================================================
 655 //function : ClearLastCreated
 656 //purpose  : Clears sequences of last created elements and nodes
 657 //=======================================================================
 658
 659 void SMESH_MeshEditor_i::ClearLastCreated() throw (SALOME::SALOME_Exception)
 660 {
 661   SMESH_TRY;
 662   getEditor().ClearLastCreated();
 663   SMESH_CATCH( SMESH::throwCorbaException );
 664 }
 665
 666 //=======================================================================
 667 /*
 668  * Returns description of an error/warning occurred during the last operation
 669  * WARNING: ComputeError.code >= 100 and no corresponding enum in IDL API
 670  */
 671 //=======================================================================
 672
 673 SMESH::ComputeError* SMESH_MeshEditor_i::GetLastError()
 674   throw (SALOME::SALOME_Exception)
 675 {
 676   SMESH_TRY;
 677   SMESH::ComputeError_var errOut = new SMESH::ComputeError;
 678   SMESH_ComputeErrorPtr&  errIn  = getEditor().GetError();
 679   if ( errIn && !errIn->IsOK() )
 680   {
 681     errOut->code       = -( errIn->myName < 0 ? errIn->myName + 1: errIn->myName ); // -1 -> 0
 682     errOut->comment    = errIn->myComment.c_str();
 683     errOut->subShapeID = -1;
 684     errOut->hasBadMesh = errIn->HasBadElems();
 685   }
 686   else
 687   {
 688     errOut->code       = 0;
 689     errOut->subShapeID = -1;
 690     errOut->hasBadMesh = false;
 691   }
 692
 693   return errOut._retn();
 694   SMESH_CATCH( SMESH::throwCorbaException );
 695   return 0;
 696 }
 697
 698 //=======================================================================
 699 //function : MakeIDSource
 700 //purpose  : Wrap a sequence of ids in a SMESH_IDSource.
 701 //           Call UnRegister() as you fininsh using it!!
 702 //=======================================================================
 703
 704 struct SMESH_MeshEditor_i::_IDSource : public virtual POA_SMESH::SMESH_IDSource,
 705                                        public virtual SALOME::GenericObj_i
 706 {
 707   SMESH::long_array     _ids;
 708   SMESH::ElementType    _type;
 709   SMESH::SMESH_Mesh_ptr _mesh;
 710   SMESH::long_array* GetIDs()      { return new SMESH::long_array( _ids ); }
 711   SMESH::long_array* GetMeshInfo() { return 0; }
 712   SMESH::long_array* GetNbElementsByType()
 713   {
 714     SMESH::long_array_var aRes = new SMESH::long_array();
 715     aRes->length(SMESH::NB_ELEMENT_TYPES);
 716     for (int i = 0; i < SMESH::NB_ELEMENT_TYPES; i++)
 717       aRes[ i ] = ( i == _type ) ? _ids.length() : 0;
 718     return aRes._retn();
 719   }
 720   SMESH::SMESH_Mesh_ptr GetMesh()  { return SMESH::SMESH_Mesh::_duplicate( _mesh ); }
 721   bool IsMeshInfoCorrect()         { return true; }
 722   SMESH::array_of_ElementType* GetTypes()
 723   {
 724     SMESH::array_of_ElementType_var types = new SMESH::array_of_ElementType;
 725     if ( _ids.length() > 0 ) {
 726       types->length( 1 );
 727       types[0] = _type;
 728     }
 729     return types._retn();
 730   }
 731   SALOMEDS::TMPFile* GetVtkUgStream()
 732   {
 733     SALOMEDS::TMPFile_var SeqFile;
 734     return SeqFile._retn();
 735   }
 736 };
 737
 738 SMESH::SMESH_IDSource_ptr SMESH_MeshEditor_i::MakeIDSource(const SMESH::long_array& ids,
 739                                                            SMESH::ElementType       type)
 740 {
 741   _IDSource* idSrc = new _IDSource;
 742   idSrc->_mesh = myMesh_i->_this();
 743   idSrc->_ids  = ids;
 744   idSrc->_type = type;
 745   if ( type == SMESH::ALL && ids.length() > 0 )
 746     idSrc->_type = myMesh_i->GetElementType( ids[0], true );
 747
 748   SMESH::SMESH_IDSource_var anIDSourceVar = idSrc->_this();
 749
 750   return anIDSourceVar._retn();
 751 }
 752
 753 bool SMESH_MeshEditor_i::IsTemporaryIDSource( SMESH::SMESH_IDSource_ptr& idSource )
 754 {
 755   return SMESH::DownCast<SMESH_MeshEditor_i::_IDSource*>( idSource );
 756 }
 757
 758 CORBA::Long* SMESH_MeshEditor_i::GetTemporaryIDs( SMESH::SMESH_IDSource_ptr& idSource,
 759                                                   int&                       nbIds)
 760 {
 761   if ( _IDSource* tmpIdSource = SMESH::DownCast<SMESH_MeshEditor_i::_IDSource*>( idSource ))
 762   {
 763     nbIds = (int) tmpIdSource->_ids.length();
 764     return & tmpIdSource->_ids[0];
 765   }
 766   nbIds = 0;
 767   return 0;
 768 }
 769
 770 // void SMESH_MeshEditor_i::deleteAuxIDSources()
 771 // {
 772 //   std::list< _IDSource* >::iterator idSrcIt = myAuxIDSources.begin();
 773 //   for ( ; idSrcIt != myAuxIDSources.end(); ++idSrcIt )
 774 //     delete *idSrcIt;
 775 //   myAuxIDSources.clear();
 776 // }
 777
 778 //=============================================================================
 779 /*!
 780  *
 781  */
 782 //=============================================================================
 783
 784 CORBA::Boolean
 785 SMESH_MeshEditor_i::RemoveElements(const SMESH::long_array & IDsOfElements)
 786   throw (SALOME::SALOME_Exception)
 787 {
 788   SMESH_TRY;
 789   initData();
 790
 791   list< int > IdList;
 792
 793   for ( CORBA::ULong i = 0; i < IDsOfElements.length(); i++ )
 794     IdList.push_back( IDsOfElements[i] );
 795
 796   // Update Python script
 797   TPythonDump() << "isDone = " << this << ".RemoveElements( " << IDsOfElements << " )";
 798
 799   // Remove Elements
 800   bool ret = getEditor().Remove( IdList, false );
 801
 802   declareMeshModified( /*isReComputeSafe=*/ IDsOfElements.length() == 0 ); // issue 0020693
 803   return ret;
 804
 805   SMESH_CATCH( SMESH::throwCorbaException );
 806   return 0;
 807 }
 808
 809 //=============================================================================
 810 /*!
 811  *
 812  */
 813 //=============================================================================
 814
 815 CORBA::Boolean SMESH_MeshEditor_i::RemoveNodes(const SMESH::long_array & IDsOfNodes)
 816   throw (SALOME::SALOME_Exception)
 817 {
 818   SMESH_TRY;
 819   initData();
 820
 821   list< int > IdList;
 822   for ( CORBA::ULong i = 0; i < IDsOfNodes.length(); i++)
 823     IdList.push_back( IDsOfNodes[i] );
 824
 825   // Update Python script
 826   TPythonDump() << "isDone = " << this << ".RemoveNodes( " << IDsOfNodes << " )";
 827
 828   bool ret = getEditor().Remove( IdList, true );
 829
 830   declareMeshModified( /*isReComputeSafe=*/ !ret ); // issue 0020693
 831   return ret;
 832
 833   SMESH_CATCH( SMESH::throwCorbaException );
 834   return 0;
 835 }
 836
 837 //=============================================================================
 838 /*!
 839  *
 840  */
 841 //=============================================================================
 842
 843 CORBA::Long SMESH_MeshEditor_i::RemoveOrphanNodes()
 844   throw (SALOME::SALOME_Exception)
 845 {
 846   SMESH_TRY;
 847   initData();
 848
 849   // Update Python script
 850   TPythonDump() << "nbRemoved = " << this << ".RemoveOrphanNodes()";
 851
 852   // Create filter to find all orphan nodes
 853   SMESH::Controls::Filter::TIdSequence seq;
 854   SMESH::Controls::PredicatePtr predicate( new SMESH::Controls::FreeNodes() );
 855   SMESH::Controls::Filter::GetElementsId( getMeshDS(), predicate, seq );
 856
 857   // remove orphan nodes (if there are any)
 858   list< int > IdList( seq.begin(), seq.end() );
 859
 860   int nbNodesBefore = myMesh->NbNodes();
 861   getEditor().Remove( IdList, true );
 862   int nbNodesAfter = myMesh->NbNodes();
 863
 864   declareMeshModified( /*isReComputeSafe=*/ IdList.size() == 0 ); // issue 0020693
 865   return nbNodesBefore - nbNodesAfter;
 866
 867   SMESH_CATCH( SMESH::throwCorbaException );
 868   return 0;
 869 }
 870
 871 //=============================================================================
 872 /*!
 873  * Add a new node.
 874  */
 875 //=============================================================================
 876
 877 CORBA::Long SMESH_MeshEditor_i::AddNode(CORBA::Double x,CORBA::Double y, CORBA::Double z)
 878   throw (SALOME::SALOME_Exception)
 879 {
 880   SMESH_TRY;
 881   initData();
 882
 883   const SMDS_MeshNode* N = getMeshDS()->AddNode(x, y, z);
 884
 885   // Update Python script
 886   TPythonDump() << "nodeID = " << this << ".AddNode( "
 887                 << TVar( x ) << ", " << TVar( y ) << ", " << TVar( z )<< " )";
 888
 889   declareMeshModified( /*isReComputeSafe=*/false );
 890   return N->GetID();
 891
 892   SMESH_CATCH( SMESH::throwCorbaException );
 893   return 0;
 894 }
 895
 896 //=============================================================================
 897 /*!
 898  * Create 0D element on the given node.
 899  */
 900 //=============================================================================
 901
 902 CORBA::Long SMESH_MeshEditor_i::Add0DElement(CORBA::Long    IDOfNode,
 903                                              CORBA::Boolean DuplicateElements)
 904   throw (SALOME::SALOME_Exception)
 905 {
 906   SMESH_TRY;
 907   initData();
 908
 909   const SMDS_MeshNode* aNode = getMeshDS()->FindNode(IDOfNode);
 910   SMDS_ElemIteratorPtr it0D = aNode->GetInverseElementIterator( SMDSAbs_0DElement );
 911
 912   SMDS_MeshElement* elem = 0;
 913   if ( DuplicateElements || !it0D->more() )
 914     elem = getMeshDS()->Add0DElement(aNode);
 915
 916   // Update Python script
 917   TPythonDump() << "elem0d = " << this << ".Add0DElement( " << IDOfNode <<" )";
 918
 919   declareMeshModified( /*isReComputeSafe=*/false );
 920
 921   return elem ? elem->GetID() : 0;
 922
 923   SMESH_CATCH( SMESH::throwCorbaException );
 924   return 0;
 925 }
 926
 927 //=============================================================================
 928 /*!
 929  * Create a ball element on the given node.
 930  */
 931 //=============================================================================
 932
 933 CORBA::Long SMESH_MeshEditor_i::AddBall(CORBA::Long IDOfNode, CORBA::Double diameter)
 934   throw (SALOME::SALOME_Exception)
 935 {
 936   SMESH_TRY;
 937   initData();
 938
 939   if ( diameter < std::numeric_limits<double>::min() )
 940     THROW_SALOME_CORBA_EXCEPTION("Invalid diameter", SALOME::BAD_PARAM);
 941
 942   const SMDS_MeshNode* aNode = getMeshDS()->FindNode(IDOfNode);
 943   SMDS_MeshElement* elem = getMeshDS()->AddBall(aNode, diameter);
 944
 945   // Update Python script
 946   TPythonDump() << "ballElem = "
 947                 << this << ".AddBall( " << IDOfNode << ", " << diameter <<" )";
 948
 949   declareMeshModified( /*isReComputeSafe=*/false );
 950   return elem ? elem->GetID() : 0;
 951
 952   SMESH_CATCH( SMESH::throwCorbaException );
 953   return 0;
 954 }
 955
 956 //=============================================================================
 957 /*!
 958  * Create an edge, either linear and quadratic (this is determed
 959  *  by number of given nodes, two or three)
 960  */
 961 //=============================================================================
 962
 963 CORBA::Long SMESH_MeshEditor_i::AddEdge(const SMESH::long_array & IDsOfNodes)
 964   throw (SALOME::SALOME_Exception)
 965 {
 966   SMESH_TRY;
 967   initData();
 968
 969   int NbNodes = IDsOfNodes.length();
 970   SMDS_MeshElement* elem = 0;
 971   if (NbNodes == 2)
 972   {
 973     CORBA::Long index1 = IDsOfNodes[0];
 974     CORBA::Long index2 = IDsOfNodes[1];
 975     elem = getMeshDS()->AddEdge( getMeshDS()->FindNode(index1),
 976                                  getMeshDS()->FindNode(index2));
 977
 978     // Update Python script
 979     TPythonDump() << "edge = " << this << ".AddEdge([ "
 980                   << index1 << ", " << index2 <<" ])";
 981   }
 982   if (NbNodes == 3) {
 983     CORBA::Long n1 = IDsOfNodes[0];
 984     CORBA::Long n2 = IDsOfNodes[1];
 985     CORBA::Long n12 = IDsOfNodes[2];
 986     elem = getMeshDS()->AddEdge( getMeshDS()->FindNode(n1),
 987                                  getMeshDS()->FindNode(n2),
 988                                  getMeshDS()->FindNode(n12));
 989     // Update Python script
 990     TPythonDump() << "edgeID = " << this << ".AddEdge([ "
 991                   <<n1<<", "<<n2<<", "<<n12<<" ])";
 992   }
 993
 994   declareMeshModified( /*isReComputeSafe=*/false );
 995   return elem ? elem->GetID() : 0;
 996
 997   SMESH_CATCH( SMESH::throwCorbaException );
 998   return 0;
 999 }
1000
1001 //=============================================================================
1002 /*!
1003  *  AddFace
1004  */
1005 //=============================================================================
1006
1007 CORBA::Long SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes)
1008   throw (SALOME::SALOME_Exception)
1009 {
1010   SMESH_TRY;
1011   initData();
1012
1013   int NbNodes = IDsOfNodes.length();
1014   if (NbNodes < 3)
1015   {
1016     return 0;
1017   }
1018
1019   std::vector<const SMDS_MeshNode*> nodes (NbNodes);
1020   for (int i = 0; i < NbNodes; i++)
1021     nodes[i] = getMeshDS()->FindNode(IDsOfNodes[i]);
1022
1023   SMDS_MeshElement* elem = 0;
1024   switch (NbNodes) {
1025   case 3: elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2]); break;
1026   case 4: elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3]); break;
1027   case 6: elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
1028                                       nodes[4], nodes[5]); break;
1029   case 7: elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
1030                                       nodes[4], nodes[5], nodes[6]); break;
1031   case 8: elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
1032                                       nodes[4], nodes[5], nodes[6], nodes[7]); break;
1033   case 9: elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
1034                                       nodes[4], nodes[5], nodes[6], nodes[7],
1035                                       nodes[8] ); break;
1036   default: elem = getMeshDS()->AddPolygonalFace(nodes);
1037   }
1038
1039   // Update Python script
1040   TPythonDump() << "faceID = " << this << ".AddFace( " << IDsOfNodes << " )";
1041
1042   declareMeshModified( /*isReComputeSafe=*/false );
1043
1044   return elem ? elem->GetID() : 0;
1045
1046   SMESH_CATCH( SMESH::throwCorbaException );
1047   return 0;
1048 }
1049
1050 //=============================================================================
1051 /*!
1052  *  AddPolygonalFace
1053  */
1054 //=============================================================================
1055
1056 CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace (const SMESH::long_array & IDsOfNodes)
1057   throw (SALOME::SALOME_Exception)
1058 {
1059   SMESH_TRY;
1060   initData();
1061
1062   int NbNodes = IDsOfNodes.length();
1063   std::vector<const SMDS_MeshNode*> nodes (NbNodes);
1064   for (int i = 0; i < NbNodes; i++)
1065     if ( ! ( nodes[i] = getMeshDS()->FindNode( IDsOfNodes[i] )))
1066       return 0;
1067
1068   const SMDS_MeshElement* elem = getMeshDS()->AddPolygonalFace(nodes);
1069
1070   // Update Python script
1071   TPythonDump() <<"faceID = "<<this<<".AddPolygonalFace( "<<IDsOfNodes<<" )";
1072
1073   declareMeshModified( /*isReComputeSafe=*/false );
1074   return elem ? elem->GetID() : 0;
1075
1076   SMESH_CATCH( SMESH::throwCorbaException );
1077   return 0;
1078 }
1079
1080 //=============================================================================
1081 /*!
1082  *  AddQuadPolygonalFace
1083  */
1084 //=============================================================================
1085
1086 CORBA::Long SMESH_MeshEditor_i::AddQuadPolygonalFace (const SMESH::long_array & IDsOfNodes)
1087   throw (SALOME::SALOME_Exception)
1088 {
1089   SMESH_TRY;
1090   initData();
1091
1092   int NbNodes = IDsOfNodes.length();
1093   std::vector<const SMDS_MeshNode*> nodes (NbNodes);
1094   for (int i = 0; i < NbNodes; i++)
1095     nodes[i] = getMeshDS()->FindNode(IDsOfNodes[i]);
1096
1097   const SMDS_MeshElement* elem = getMeshDS()->AddQuadPolygonalFace(nodes);
1098
1099   // Update Python script
1100   TPythonDump() <<"faceID = "<<this<<".AddPolygonalFace( "<<IDsOfNodes<<" )";
1101
1102   declareMeshModified( /*isReComputeSafe=*/false );
1103   return elem ? elem->GetID() : 0;
1104
1105   SMESH_CATCH( SMESH::throwCorbaException );
1106   return 0;
1107 }
1108
1109 //=============================================================================
1110 /*!
1111  * Create volume, either linear and quadratic (this is determed
1112  *  by number of given nodes)
1113  */
1114 //=============================================================================
1115
1116 CORBA::Long SMESH_MeshEditor_i::AddVolume(const SMESH::long_array & IDsOfNodes)
1117   throw (SALOME::SALOME_Exception)
1118 {
1119   SMESH_TRY;
1120   initData();
1121
1122   int NbNodes = IDsOfNodes.length();
1123   vector< const SMDS_MeshNode*> n(NbNodes);
1124   for(int i=0;i<NbNodes;i++)
1125     n[i]= getMeshDS()->FindNode(IDsOfNodes[i]);
1126
1127   SMDS_MeshElement* elem = 0;
1128   switch(NbNodes)
1129   {
1130   case 4 :elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3]); break;
1131   case 5 :elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4]); break;
1132   case 6 :elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5]); break;
1133   case 8 :elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7]); break;
1134   case 10:elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],
1135                                         n[6],n[7],n[8],n[9]);
1136     break;
1137   case 12:elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],
1138                                         n[6],n[7],n[8],n[9],n[10],n[11]);
1139     break;
1140   case 13:elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],
1141                                         n[7],n[8],n[9],n[10],n[11],n[12]);
1142     break;
1143   case 15:elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],n[8],
1144                                         n[9],n[10],n[11],n[12],n[13],n[14]);
1145     break;
1146   case 20:elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],
1147                                         n[8],n[9],n[10],n[11],n[12],n[13],n[14],
1148                                         n[15],n[16],n[17],n[18],n[19]);
1149     break;
1150   case 18:elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],
1151                                         n[8],n[9],n[10],n[11],n[12],n[13],n[14],
1152                                         n[15],n[16],n[17]);
1153     break;
1154   case 27:elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],
1155                                         n[8],n[9],n[10],n[11],n[12],n[13],n[14],
1156                                         n[15],n[16],n[17],n[18],n[19],
1157                                         n[20],n[21],n[22],n[23],n[24],n[25],n[26]);
1158     break;
1159   }
1160
1161   // Update Python script
1162   TPythonDump() << "volID = " << this << ".AddVolume( " << IDsOfNodes << " )";
1163
1164   declareMeshModified( /*isReComputeSafe=*/false );
1165   return elem ? elem->GetID() : 0;
1166
1167   SMESH_CATCH( SMESH::throwCorbaException );
1168   return 0;
1169 }
1170
1171 //=============================================================================
1172 /*!
1173  *  AddPolyhedralVolume
1174  */
1175 //=============================================================================
1176 CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolume (const SMESH::long_array & IDsOfNodes,
1177                                                      const SMESH::long_array & Quantities)
1178   throw (SALOME::SALOME_Exception)
1179 {
1180   SMESH_TRY;
1181   initData();
1182
1183   int NbNodes = IDsOfNodes.length();
1184   std::vector<const SMDS_MeshNode*> n (NbNodes);
1185   for (int i = 0; i < NbNodes; i++)
1186     {
1187       const SMDS_MeshNode* aNode = getMeshDS()->FindNode(IDsOfNodes[i]);
1188       if (!aNode) return 0;
1189       n[i] = aNode;
1190     }
1191
1192   int NbFaces = Quantities.length();
1193   std::vector<int> q (NbFaces);
1194   for (int j = 0; j < NbFaces; j++)
1195     q[j] = Quantities[j];
1196
1197   const SMDS_MeshElement* elem = getMeshDS()->AddPolyhedralVolume(n, q);
1198
1199   // Update Python script
1200   TPythonDump() << "volID = " << this << ".AddPolyhedralVolume( "
1201                 << IDsOfNodes << ", " << Quantities << " )";
1202
1203   declareMeshModified( /*isReComputeSafe=*/false );
1204   return elem ? elem->GetID() : 0;
1205
1206   SMESH_CATCH( SMESH::throwCorbaException );
1207   return 0;
1208 }
1209
1210 //=============================================================================
1211 /*!
1212  *  AddPolyhedralVolumeByFaces
1213  */
1214 //=============================================================================
1215
1216 CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolumeByFaces (const SMESH::long_array & IdsOfFaces)
1217   throw (SALOME::SALOME_Exception)
1218 {
1219   SMESH_TRY;
1220   initData();
1221
1222   int NbFaces = IdsOfFaces.length();
1223   std::vector<const SMDS_MeshNode*> poly_nodes;
1224   std::vector<int> quantities (NbFaces);
1225
1226   for (int i = 0; i < NbFaces; i++) {
1227     const SMDS_MeshElement* aFace = getMeshDS()->FindElement(IdsOfFaces[i]);
1228     quantities[i] = aFace->NbNodes();
1229
1230     SMDS_ElemIteratorPtr It = aFace->nodesIterator();
1231     while (It->more()) {
1232       poly_nodes.push_back(static_cast<const SMDS_MeshNode *>(It->next()));
1233     }
1234   }
1235
1236   const SMDS_MeshElement* elem = getMeshDS()->AddPolyhedralVolume(poly_nodes, quantities);
1237
1238   // Update Python script
1239   TPythonDump() << "volID = " << this << ".AddPolyhedralVolumeByFaces( "
1240                 << IdsOfFaces << " )";
1241
1242   declareMeshModified( /*isReComputeSafe=*/false );
1243   return elem ? elem->GetID() : 0;
1244
1245   SMESH_CATCH( SMESH::throwCorbaException );
1246   return 0;
1247 }
1248
1249 //=============================================================================
1250 //
1251 // \brief Create 0D elements on all nodes of the given object.
1252 //  \param theObject object on whose nodes 0D elements will be created.
1253 //  \param theGroupName optional name of a group to add 0D elements created
1254 //         and/or found on nodes of \a theObject.
1255 //  \param DuplicateElements to add one more 0D element to a node or not.
1256 //  \return an object (a new group or a temporary SMESH_IDSource) holding
1257 //          ids of new and/or found 0D elements.
1258 //
1259 //=============================================================================
1260
1261 SMESH::SMESH_IDSource_ptr
1262 SMESH_MeshEditor_i::Create0DElementsOnAllNodes(SMESH::SMESH_IDSource_ptr theObject,
1263                                                const char*               theGroupName,
1264                                                CORBA::Boolean            theDuplicateElements)
1265   throw (SALOME::SALOME_Exception)
1266 {
1267   SMESH_TRY;
1268   initData();
1269
1270   SMESH::SMESH_IDSource_var result;
1271   TPythonDump pyDump;
1272
1273   TIDSortedElemSet elements, elems0D;
1274   if ( idSourceToSet( theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
1275     getEditor().Create0DElementsOnAllNodes( elements, elems0D, theDuplicateElements );
1276
1277   SMESH::long_array_var newElems = new SMESH::long_array;
1278   newElems->length( elems0D.size() );
1279   TIDSortedElemSet::iterator eIt = elems0D.begin();
1280   for ( size_t i = 0; i < elems0D.size(); ++i, ++eIt )
1281     newElems[ i ] = (*eIt)->GetID();
1282
1283   SMESH::SMESH_GroupBase_var groupToFill;
1284   if ( theGroupName && strlen( theGroupName ))
1285   {
1286     // Get existing group named theGroupName
1287     SMESH::ListOfGroups_var groups = myMesh_i->GetGroups();
1288     for (int i = 0, nbGroups = groups->length(); i < nbGroups; i++ ) {
1289       SMESH::SMESH_GroupBase_var group = groups[i];
1290       if ( !group->_is_nil() ) {
1291         CORBA::String_var name = group->GetName();
1292         if ( strcmp( name.in(), theGroupName ) == 0 && group->GetType() == SMESH::ELEM0D ) {
1293           groupToFill = group;
1294           break;
1295         }
1296       }
1297     }
1298     if ( groupToFill->_is_nil() )
1299       groupToFill = myMesh_i->CreateGroup( SMESH::ELEM0D, theGroupName );
1300     else if ( !SMESH::DownCast< SMESH_Group_i* > ( groupToFill ))
1301       groupToFill = myMesh_i->ConvertToStandalone( groupToFill );
1302   }
1303
1304   if ( SMESH_Group_i* group_i = SMESH::DownCast< SMESH_Group_i* > ( groupToFill ))
1305   {
1306     group_i->Add( newElems );
1307     result = SMESH::SMESH_IDSource::_narrow( groupToFill );
1308     pyDump << groupToFill;
1309   }
1310   else
1311   {
1312     result = MakeIDSource( newElems, SMESH::ELEM0D );
1313     pyDump << "elem0DIDs";
1314   }
1315
1316   pyDump << " = " << this << ".Create0DElementsOnAllNodes( "
1317          << theObject << ", '" << theGroupName << "' )";
1318
1319   return result._retn();
1320
1321   SMESH_CATCH( SMESH::throwCorbaException );
1322   return 0;
1323 }
1324
1325 //=============================================================================
1326 /*!
1327  * \brief Bind a node to a vertex
1328  * \param NodeID - node ID
1329  * \param VertexID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
1330  * \retval boolean - false if NodeID or VertexID is invalid
1331  */
1332 //=============================================================================
1333
1334 void SMESH_MeshEditor_i::SetNodeOnVertex(CORBA::Long NodeID, CORBA::Long VertexID)
1335   throw (SALOME::SALOME_Exception)
1336 {
1337   SMESH_TRY;
1338
1339   SMESHDS_Mesh * mesh = getMeshDS();
1340   SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
1341   if ( !node )
1342     THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);
1343
1344   if ( mesh->MaxShapeIndex() < VertexID )
1345     THROW_SALOME_CORBA_EXCEPTION("Invalid VertexID", SALOME::BAD_PARAM);
1346
1347   TopoDS_Shape shape = mesh->IndexToShape( VertexID );
1348   if ( shape.ShapeType() != TopAbs_VERTEX )
1349     THROW_SALOME_CORBA_EXCEPTION("Invalid VertexID", SALOME::BAD_PARAM);
1350
1351   mesh->SetNodeOnVertex( node, VertexID );
1352
1353   myMesh->SetIsModified( true );
1354
1355   SMESH_CATCH( SMESH::throwCorbaException );
1356 }
1357
1358 //=============================================================================
1359 /*!
1360  * \brief Store node position on an edge
1361  * \param NodeID - node ID
1362  * \param EdgeID - edge ID available through GEOM_Object.GetSubShapeIndices()[0]
1363  * \param paramOnEdge - parameter on edge where the node is located
1364  * \retval boolean - false if any parameter is invalid
1365  */
1366 //=============================================================================
1367
1368 void SMESH_MeshEditor_i::SetNodeOnEdge(CORBA::Long NodeID, CORBA::Long EdgeID,
1369                                        CORBA::Double paramOnEdge)
1370   throw (SALOME::SALOME_Exception)
1371 {
1372   SMESH_TRY;
1373
1374   SMESHDS_Mesh * mesh = getMeshDS();
1375   SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
1376   if ( !node )
1377     THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);
1378
1379   if ( mesh->MaxShapeIndex() < EdgeID )
1380     THROW_SALOME_CORBA_EXCEPTION("Invalid EdgeID", SALOME::BAD_PARAM);
1381
1382   TopoDS_Shape shape = mesh->IndexToShape( EdgeID );
1383   if ( shape.ShapeType() != TopAbs_EDGE )
1384     THROW_SALOME_CORBA_EXCEPTION("Invalid EdgeID", SALOME::BAD_PARAM);
1385
1386   Standard_Real f,l;
1387   BRep_Tool::Range( TopoDS::Edge( shape ), f,l);
1388   if ( paramOnEdge < f || paramOnEdge > l )
1389     THROW_SALOME_CORBA_EXCEPTION("Invalid paramOnEdge", SALOME::BAD_PARAM);
1390
1391   mesh->SetNodeOnEdge( node, EdgeID, paramOnEdge );
1392
1393   myMesh->SetIsModified( true );
1394
1395   SMESH_CATCH( SMESH::throwCorbaException );
1396 }
1397
1398 //=============================================================================
1399 /*!
1400  * \brief Store node position on a face
1401  * \param NodeID - node ID
1402  * \param FaceID - face ID available through GEOM_Object.GetSubShapeIndices()[0]
1403  * \param u - U parameter on face where the node is located
1404  * \param v - V parameter on face where the node is located
1405  * \retval boolean - false if any parameter is invalid
1406  */
1407 //=============================================================================
1408
1409 void SMESH_MeshEditor_i::SetNodeOnFace(CORBA::Long NodeID, CORBA::Long FaceID,
1410                                        CORBA::Double u, CORBA::Double v)
1411   throw (SALOME::SALOME_Exception)
1412 {
1413   SMESH_TRY;
1414   SMESHDS_Mesh * mesh = getMeshDS();
1415   SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
1416   if ( !node )
1417     THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);
1418
1419   if ( mesh->MaxShapeIndex() < FaceID )
1420     THROW_SALOME_CORBA_EXCEPTION("Invalid FaceID", SALOME::BAD_PARAM);
1421
1422   TopoDS_Shape shape = mesh->IndexToShape( FaceID );
1423   if ( shape.ShapeType() != TopAbs_FACE )
1424     THROW_SALOME_CORBA_EXCEPTION("Invalid FaceID", SALOME::BAD_PARAM);
1425
1426   BRepAdaptor_Surface surf( TopoDS::Face( shape ));
1427   bool isOut = ( u < surf.FirstUParameter() ||
1428                  u > surf.LastUParameter()  ||
1429                  v < surf.FirstVParameter() ||
1430                  v > surf.LastVParameter() );
1431
1432   if ( isOut ) {
1433 #ifdef _DEBUG_
1434     MESSAGE ( "FACE " << FaceID << " (" << u << "," << v << ") out of "
1435               << " u( " <<  surf.FirstUParameter()
1436               << "," <<  surf.LastUParameter()
1437               << ") v( " <<  surf.FirstVParameter()
1438               << "," <<  surf.LastVParameter() << ")" );
1439 #endif
1440     THROW_SALOME_CORBA_EXCEPTION("Invalid UV", SALOME::BAD_PARAM);
1441   }
1442
1443   mesh->SetNodeOnFace( node, FaceID, u, v );
1444   myMesh->SetIsModified( true );
1445
1446   SMESH_CATCH( SMESH::throwCorbaException );
1447 }
1448
1449 //=============================================================================
1450 /*!
1451  * \brief Bind a node to a solid
1452  * \param NodeID - node ID
1453  * \param SolidID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
1454  * \retval boolean - false if NodeID or SolidID is invalid
1455  */
1456 //=============================================================================
1457
1458 void SMESH_MeshEditor_i::SetNodeInVolume(CORBA::Long NodeID, CORBA::Long SolidID)
1459   throw (SALOME::SALOME_Exception)
1460 {
1461   SMESH_TRY;
1462   SMESHDS_Mesh * mesh = getMeshDS();
1463   SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
1464   if ( !node )
1465     THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);
1466
1467   if ( mesh->MaxShapeIndex() < SolidID )
1468     THROW_SALOME_CORBA_EXCEPTION("Invalid SolidID", SALOME::BAD_PARAM);
1469
1470   TopoDS_Shape shape = mesh->IndexToShape( SolidID );
1471   if ( shape.ShapeType() != TopAbs_SOLID &&
1472        shape.ShapeType() != TopAbs_SHELL)
1473     THROW_SALOME_CORBA_EXCEPTION("Invalid SolidID", SALOME::BAD_PARAM);
1474
1475   mesh->SetNodeInVolume( node, SolidID );
1476
1477   SMESH_CATCH( SMESH::throwCorbaException );
1478 }
1479
1480 //=============================================================================
1481 /*!
1482  * \brief Bind an element to a shape
1483  * \param ElementID - element ID
1484  * \param ShapeID - shape ID available through GEOM_Object.GetSubShapeIndices()[0]
1485  */
1486 //=============================================================================
1487
1488 void SMESH_MeshEditor_i::SetMeshElementOnShape(CORBA::Long ElementID,
1489                                                CORBA::Long ShapeID)
1490   throw (SALOME::SALOME_Exception)
1491 {
1492   SMESH_TRY;
1493   SMESHDS_Mesh * mesh = getMeshDS();
1494   SMDS_MeshElement* elem = const_cast<SMDS_MeshElement*>(mesh->FindElement(ElementID));
1495   if ( !elem )
1496     THROW_SALOME_CORBA_EXCEPTION("Invalid ElementID", SALOME::BAD_PARAM);
1497
1498   if ( mesh->MaxShapeIndex() < ShapeID || ShapeID < 1 )
1499     THROW_SALOME_CORBA_EXCEPTION("Invalid ShapeID", SALOME::BAD_PARAM);
1500
1501   TopoDS_Shape shape = mesh->IndexToShape( ShapeID );
1502   if ( shape.ShapeType() != TopAbs_EDGE &&
1503        shape.ShapeType() != TopAbs_FACE &&
1504        shape.ShapeType() != TopAbs_SOLID &&
1505        shape.ShapeType() != TopAbs_SHELL )
1506     THROW_SALOME_CORBA_EXCEPTION("Invalid shape type", SALOME::BAD_PARAM);
1507
1508   mesh->SetMeshElementOnShape( elem, ShapeID );
1509
1510   myMesh->SetIsModified( true );
1511
1512   SMESH_CATCH( SMESH::throwCorbaException );
1513 }
1514
1515 //=============================================================================
1516 /*!
1517  *
1518  */
1519 //=============================================================================
1520
1521 CORBA::Boolean SMESH_MeshEditor_i::InverseDiag(CORBA::Long NodeID1,
1522                                                CORBA::Long NodeID2)
1523   throw (SALOME::SALOME_Exception)
1524 {
1525   SMESH_TRY;
1526   initData();
1527
1528   const SMDS_MeshNode * n1 = getMeshDS()->FindNode( NodeID1 );
1529   const SMDS_MeshNode * n2 = getMeshDS()->FindNode( NodeID2 );
1530   if ( !n1 || !n2 )
1531     return false;
1532
1533   // Update Python script
1534   TPythonDump() << "isDone = " << this << ".InverseDiag( "
1535                 << NodeID1 << ", " << NodeID2 << " )";
1536
1537   int ret =  getEditor().InverseDiag ( n1, n2 );
1538
1539   declareMeshModified( /*isReComputeSafe=*/false );
1540   return ret;
1541
1542   SMESH_CATCH( SMESH::throwCorbaException );
1543   return 0;
1544 }
1545
1546 //=============================================================================
1547 /*!
1548  *
1549  */
1550 //=============================================================================
1551
1552 CORBA::Boolean SMESH_MeshEditor_i::DeleteDiag(CORBA::Long NodeID1,
1553                                               CORBA::Long NodeID2)
1554   throw (SALOME::SALOME_Exception)
1555 {
1556   SMESH_TRY;
1557   initData();
1558
1559   const SMDS_MeshNode * n1 = getMeshDS()->FindNode( NodeID1 );
1560   const SMDS_MeshNode * n2 = getMeshDS()->FindNode( NodeID2 );
1561   if ( !n1 || !n2 )
1562     return false;
1563
1564   // Update Python script
1565   TPythonDump() << "isDone = " << this << ".DeleteDiag( "
1566                 << NodeID1 << ", " << NodeID2 <<  " )";
1567
1568
1569   bool stat = getEditor().DeleteDiag ( n1, n2 );
1570
1571   declareMeshModified( /*isReComputeSafe=*/!stat );
1572
1573   return stat;
1574
1575   SMESH_CATCH( SMESH::throwCorbaException );
1576   return 0;
1577 }
1578
1579 //=============================================================================
1580 /*!
1581  *
1582  */
1583 //=============================================================================
1584
1585 CORBA::Boolean SMESH_MeshEditor_i::Reorient(const SMESH::long_array & IDsOfElements)
1586   throw (SALOME::SALOME_Exception)
1587 {
1588   SMESH_TRY;
1589   initData();
1590
1591   for ( CORBA::ULong i = 0; i < IDsOfElements.length(); i++ )
1592   {
1593     CORBA::Long index = IDsOfElements[i];
1594     const SMDS_MeshElement * elem = getMeshDS()->FindElement(index);
1595     if ( elem )
1596       getEditor().Reorient( elem );
1597   }
1598   // Update Python script
1599   TPythonDump() << "isDone = " << this << ".Reorient( " << IDsOfElements << " )";
1600
1601   declareMeshModified( /*isReComputeSafe=*/ IDsOfElements.length() == 0 );
1602   return true;
1603
1604   SMESH_CATCH( SMESH::throwCorbaException );
1605   return 0;
1606 }
1607
1608 //=============================================================================
1609 /*!
1610  *
1611  */
1612 //=============================================================================
1613
1614 CORBA::Boolean SMESH_MeshEditor_i::ReorientObject(SMESH::SMESH_IDSource_ptr theObject)
1615   throw (SALOME::SALOME_Exception)
1616 {
1617   SMESH_TRY;
1618   initData();
1619
1620   TPythonDump aTPythonDump; // suppress dump in Reorient()
1621
1622   prepareIdSource( theObject );
1623
1624   SMESH::long_array_var anElementsId = theObject->GetIDs();
1625   CORBA::Boolean isDone = Reorient(anElementsId);
1626
1627   // Update Python script
1628   aTPythonDump << "isDone = " << this << ".ReorientObject( " << theObject << " )";
1629
1630   declareMeshModified( /*isReComputeSafe=*/ anElementsId->length() == 0 );
1631   return isDone;
1632
1633   SMESH_CATCH( SMESH::throwCorbaException );
1634   return 0;
1635 }
1636
1637 //=======================================================================
1638 //function : Reorient2D
1639 //purpose  : Reorient faces contained in \a the2Dgroup.
1640 //           the2Dgroup   - the mesh or its part to reorient
1641 //           theDirection - desired direction of normal of \a theFace
1642 //           theFace      - ID of face whose orientation is checked.
1643 //           It can be < 1 then \a thePoint is used to find a face.
1644 //           thePoint     - is used to find a face if \a theFace < 1.
1645 //           return number of reoriented elements.
1646 //=======================================================================
1647
1648 CORBA::Long SMESH_MeshEditor_i::Reorient2D(SMESH::SMESH_IDSource_ptr the2Dgroup,
1649                                            const SMESH::DirStruct&   theDirection,
1650                                            CORBA::Long               theFace,
1651                                            const SMESH::PointStruct& thePoint)
1652   throw (SALOME::SALOME_Exception)
1653 {
1654   SMESH_TRY;
1655   initData(/*deleteSearchers=*/false);
1656
1657   TIDSortedElemSet elements;
1658   IDSource_Error error;
1659   idSourceToSet( the2Dgroup, getMeshDS(), elements, SMDSAbs_Face, /*emptyIfIsMesh=*/1, &error );
1660   if ( error == IDSource_EMPTY )
1661     return 0;
1662   if ( error == IDSource_INVALID )
1663     THROW_SALOME_CORBA_EXCEPTION("No faces in given group", SALOME::BAD_PARAM);
1664
1665
1666   const SMDS_MeshElement* face = 0;
1667   if ( theFace > 0 )
1668   {
1669     face = getMeshDS()->FindElement( theFace );
1670     if ( !face )
1671       THROW_SALOME_CORBA_EXCEPTION("Inexistent face given", SALOME::BAD_PARAM);
1672     if ( face->GetType() != SMDSAbs_Face )
1673       THROW_SALOME_CORBA_EXCEPTION("Wrong element type", SALOME::BAD_PARAM);
1674   }
1675   else
1676   {
1677     // create theElementSearcher if needed
1678     theSearchersDeleter.Set( myMesh, getPartIOR( the2Dgroup, SMESH::FACE ));
1679     if ( !theElementSearcher )
1680     {
1681       if ( elements.empty() ) // search in the whole mesh
1682       {
1683         if ( myMesh->NbFaces() == 0 )
1684           THROW_SALOME_CORBA_EXCEPTION("No faces in the mesh", SALOME::BAD_PARAM);
1685
1686         theElementSearcher = SMESH_MeshAlgos::GetElementSearcher( *getMeshDS() );
1687       }
1688       else
1689       {
1690         typedef SMDS_SetIterator<const SMDS_MeshElement*, TIDSortedElemSet::const_iterator > TIter;
1691         SMDS_ElemIteratorPtr elemsIt( new TIter( elements.begin(), elements.end() ));
1692
1693         theElementSearcher = SMESH_MeshAlgos::GetElementSearcher( *getMeshDS(), elemsIt);
1694       }
1695     }
1696     // find a face
1697     gp_Pnt p( thePoint.x, thePoint.y, thePoint.z );
1698     face = theElementSearcher->FindClosestTo( p, SMDSAbs_Face );
1699
1700     if ( !face )
1701       THROW_SALOME_CORBA_EXCEPTION("No face found by point", SALOME::INTERNAL_ERROR );
1702     if ( !elements.empty() && !elements.count( face ))
1703       THROW_SALOME_CORBA_EXCEPTION("Found face is not in the group", SALOME::BAD_PARAM );
1704   }
1705
1706   const SMESH::PointStruct * P = &theDirection.PS;
1707   gp_Vec dirVec( P->x, P->y, P->z );
1708   if ( dirVec.Magnitude() < std::numeric_limits< double >::min() )
1709     THROW_SALOME_CORBA_EXCEPTION("Zero size vector", SALOME::BAD_PARAM);
1710
1711   int nbReori = getEditor().Reorient2D( elements, dirVec, face );
1712
1713   if ( nbReori ) {
1714     declareMeshModified( /*isReComputeSafe=*/false );
1715   }
1716   TPythonDump() << this << ".Reorient2D( "
1717                 << the2Dgroup << ", "
1718                 << theDirection << ", "
1719                 << theFace << ", "
1720                 << thePoint << " )";
1721
1722   return nbReori;
1723
1724   SMESH_CATCH( SMESH::throwCorbaException );
1725   return 0;
1726 }
1727
1728 //=======================================================================
1729 //function : Reorient2DBy3D
1730 //purpose  : Reorient faces basing on orientation of adjacent volumes.
1731 //=======================================================================
1732
1733 CORBA::Long SMESH_MeshEditor_i::Reorient2DBy3D(const SMESH::ListOfIDSources& faceGroups,
1734                                                SMESH::SMESH_IDSource_ptr     volumeGroup,
1735                                                CORBA::Boolean                outsideNormal)
1736   throw (SALOME::SALOME_Exception)
1737 {
1738   SMESH_TRY;
1739   initData();
1740
1741   TIDSortedElemSet volumes;
1742   IDSource_Error volsError;
1743   idSourceToSet( volumeGroup, getMeshDS(), volumes, SMDSAbs_Volume, /*emptyIfMesh=*/1, &volsError);
1744
1745   int nbReori = 0;
1746   for ( size_t i = 0; i < faceGroups.length(); ++i )
1747   {
1748     SMESH::SMESH_IDSource_ptr faceGrp = faceGroups[i].in();
1749
1750     TIDSortedElemSet faces;
1751     IDSource_Error error;
1752     idSourceToSet( faceGrp, getMeshDS(), faces, SMDSAbs_Face, /*emptyIfIsMesh=*/1, &error );
1753     if ( error == IDSource_INVALID && faceGroups.length() == 1 )
1754       THROW_SALOME_CORBA_EXCEPTION("No faces in a given object", SALOME::BAD_PARAM);
1755     if ( error == IDSource_OK && volsError != IDSource_OK )
1756       THROW_SALOME_CORBA_EXCEPTION("No volumes in a given object", SALOME::BAD_PARAM);
1757
1758     nbReori += getEditor().Reorient2DBy3D( faces, volumes, outsideNormal );
1759
1760     if ( error != IDSource_EMPTY && faces.empty() ) // all faces in the mesh treated
1761       break;
1762   }
1763
1764   if ( nbReori ) {
1765     declareMeshModified( /*isReComputeSafe=*/false );
1766   }
1767   TPythonDump() << this << ".Reorient2DBy3D( "
1768                 << faceGroups << ", "
1769                 << volumeGroup << ", "
1770                 << outsideNormal << " )";
1771
1772   return nbReori;
1773
1774   SMESH_CATCH( SMESH::throwCorbaException );
1775   return 0;
1776 }
1777
1778 //=============================================================================
1779 /*!
1780  * \brief Fuse neighbour triangles into quadrangles.
1781  */
1782 //=============================================================================
1783
1784 CORBA::Boolean SMESH_MeshEditor_i::TriToQuad (const SMESH::long_array &   IDsOfElements,
1785                                               SMESH::NumericalFunctor_ptr Criterion,
1786                                               CORBA::Double               MaxAngle)
1787   throw (SALOME::SALOME_Exception)
1788 {
1789   SMESH_TRY;
1790   initData();
1791
1792   SMESHDS_Mesh* aMesh = getMeshDS();
1793   TIDSortedElemSet faces,copyFaces;
1794   SMDS_MeshElement::GeomFilter triaFilter(SMDSGeom_TRIANGLE);
1795   arrayToSet(IDsOfElements, aMesh, faces, SMDSAbs_Face, & triaFilter);
1796   TIDSortedElemSet* workElements = & faces;
1797
1798   if ( myIsPreviewMode ) {
1799     SMDSAbs_ElementType select =  SMDSAbs_Face;
1800     getPreviewMesh( SMDSAbs_Face )->Copy( faces, copyFaces, select );
1801     workElements = & copyFaces;
1802   }
1803
1804   SMESH::NumericalFunctor_i* aNumericalFunctor =
1805     dynamic_cast<SMESH::NumericalFunctor_i*>( SMESH_Gen_i::GetServant( Criterion ).in() );
1806   SMESH::Controls::NumericalFunctorPtr aCrit;
1807   if ( !aNumericalFunctor )
1808     aCrit.reset( new SMESH::Controls::MaxElementLength2D() );
1809   else
1810     aCrit = aNumericalFunctor->GetNumericalFunctor();
1811
1812   if ( !myIsPreviewMode ) {
1813     // Update Python script
1814     TPythonDump() << "isDone = " << this << ".TriToQuad( "
1815                   << IDsOfElements << ", " << aNumericalFunctor << ", " << TVar( MaxAngle ) << " )";
1816   }
1817
1818   bool stat = getEditor().TriToQuad( *workElements, aCrit, MaxAngle );
1819
1820   declareMeshModified( /*isReComputeSafe=*/!stat );
1821   return stat;
1822
1823   SMESH_CATCH( SMESH::throwCorbaException );
1824   return 0;
1825 }
1826
1827 //=============================================================================
1828 /*!
1829  * \brief Fuse neighbour triangles into quadrangles.
1830  */
1831 //=============================================================================
1832
1833 CORBA::Boolean SMESH_MeshEditor_i::TriToQuadObject (SMESH::SMESH_IDSource_ptr   theObject,
1834                                                     SMESH::NumericalFunctor_ptr Criterion,
1835                                                     CORBA::Double               MaxAngle)
1836   throw (SALOME::SALOME_Exception)
1837 {
1838   SMESH_TRY;
1839   initData();
1840
1841   TPythonDump aTPythonDump;  // suppress dump in TriToQuad()
1842
1843   prepareIdSource( theObject );
1844   SMESH::long_array_var anElementsId = theObject->GetIDs();
1845   CORBA::Boolean isDone = TriToQuad(anElementsId, Criterion, MaxAngle);
1846
1847   if ( !myIsPreviewMode ) {
1848     SMESH::NumericalFunctor_i* aNumericalFunctor =
1849       SMESH::DownCast<SMESH::NumericalFunctor_i*>( Criterion );
1850
1851     // Update Python script
1852     aTPythonDump << "isDone = " << this << ".TriToQuadObject("
1853                  << theObject << ", " << aNumericalFunctor << ", " << TVar( MaxAngle ) << " )";
1854   }
1855
1856   return isDone;
1857
1858   SMESH_CATCH( SMESH::throwCorbaException );
1859   return 0;
1860 }
1861
1862 //=============================================================================
1863 /*!
1864  * \brief Split quadrangles into triangles.
1865  */
1866 //=============================================================================
1867
1868 CORBA::Boolean SMESH_MeshEditor_i::QuadToTri (const SMESH::long_array &   IDsOfElements,
1869                                               SMESH::NumericalFunctor_ptr Criterion)
1870   throw (SALOME::SALOME_Exception)
1871 {
1872   SMESH_TRY;
1873   initData();
1874
1875   SMESHDS_Mesh* aMesh = getMeshDS();
1876   TIDSortedElemSet faces;
1877   arrayToSet(IDsOfElements, aMesh, faces, SMDSAbs_Face);
1878
1879   SMESH::NumericalFunctor_i* aNumericalFunctor =
1880     dynamic_cast<SMESH::NumericalFunctor_i*>( SMESH_Gen_i::GetServant( Criterion ).in() );
1881   SMESH::Controls::NumericalFunctorPtr aCrit;
1882   if ( !aNumericalFunctor )
1883     aCrit.reset( new SMESH::Controls::AspectRatio() );
1884   else
1885     aCrit = aNumericalFunctor->GetNumericalFunctor();
1886
1887
1888   // Update Python script
1889   TPythonDump() << "isDone = " << this << ".QuadToTri( " << IDsOfElements << ", " << aNumericalFunctor << " )";
1890
1891   CORBA::Boolean stat = getEditor().QuadToTri( faces, aCrit );
1892
1893   declareMeshModified( /*isReComputeSafe=*/false );
1894   return stat;
1895
1896   SMESH_CATCH( SMESH::throwCorbaException );
1897   return 0;
1898 }
1899
1900 //=============================================================================
1901 /*!
1902  * \brief Split quadrangles into triangles.
1903  */
1904 //=============================================================================
1905
1906 CORBA::Boolean SMESH_MeshEditor_i::QuadToTriObject (SMESH::SMESH_IDSource_ptr   theObject,
1907                                                     SMESH::NumericalFunctor_ptr Criterion)
1908   throw (SALOME::SALOME_Exception)
1909 {
1910   SMESH_TRY;
1911   initData();
1912
1913   TPythonDump aTPythonDump;  // suppress dump in QuadToTri()
1914
1915   prepareIdSource( theObject );
1916   SMESH::long_array_var anElementsId = theObject->GetIDs();
1917   CORBA::Boolean isDone = QuadToTri(anElementsId, Criterion);
1918
1919   SMESH::NumericalFunctor_i* aNumericalFunctor =
1920     SMESH::DownCast<SMESH::NumericalFunctor_i*>( Criterion );
1921
1922   // Update Python script
1923   aTPythonDump << "isDone = " << this << ".QuadToTriObject( " << theObject << ", " << aNumericalFunctor << " )";
1924
1925   declareMeshModified( /*isReComputeSafe=*/false );
1926   return isDone;
1927
1928   SMESH_CATCH( SMESH::throwCorbaException );
1929   return 0;
1930 }
1931
1932 //================================================================================
1933 /*!
1934  * \brief Split each of quadrangles into 4 triangles.
1935  *  \param [in] theObject - theQuads Container of quadrangles to split.
1936  */
1937 //================================================================================
1938
1939 void SMESH_MeshEditor_i::QuadTo4Tri (SMESH::SMESH_IDSource_ptr theObject)
1940   throw (SALOME::SALOME_Exception)
1941 {
1942   SMESH_TRY;
1943   initData();
1944
1945   TIDSortedElemSet faces;
1946   if ( !idSourceToSet( theObject, getMeshDS(), faces, SMDSAbs_Face, /*emptyIfIsMesh=*/true ) &&
1947        faces.empty() )
1948     THROW_SALOME_CORBA_EXCEPTION("No faces given", SALOME::BAD_PARAM);
1949
1950   getEditor().QuadTo4Tri( faces );
1951   TPythonDump() << this << ".QuadTo4Tri( " << theObject << " )";
1952
1953   SMESH_CATCH( SMESH::throwCorbaException );
1954 }
1955
1956 //=============================================================================
1957 /*!
1958  * \brief Split quadrangles into triangles.
1959  */
1960 //=============================================================================
1961
1962 CORBA::Boolean SMESH_MeshEditor_i::SplitQuad (const SMESH::long_array & IDsOfElements,
1963                                               CORBA::Boolean            Diag13)
1964   throw (SALOME::SALOME_Exception)
1965 {
1966   SMESH_TRY;
1967   initData();
1968
1969   SMESHDS_Mesh* aMesh = getMeshDS();
1970   TIDSortedElemSet faces;
1971   arrayToSet(IDsOfElements, aMesh, faces, SMDSAbs_Face);
1972
1973   // Update Python script
1974   TPythonDump() << "isDone = " << this << ".SplitQuad( "
1975                 << IDsOfElements << ", " << Diag13 << " )";
1976
1977   CORBA::Boolean stat = getEditor().QuadToTri( faces, Diag13 );
1978
1979   declareMeshModified( /*isReComputeSafe=*/ !stat );
1980   return stat;
1981
1982   SMESH_CATCH( SMESH::throwCorbaException );
1983   return 0;
1984 }
1985
1986 //=============================================================================
1987 /*!
1988  * \brief Split quadrangles into triangles.
1989  */
1990 //=============================================================================
1991
1992 CORBA::Boolean SMESH_MeshEditor_i::SplitQuadObject (SMESH::SMESH_IDSource_ptr theObject,
1993                                                     CORBA::Boolean            Diag13)
1994   throw (SALOME::SALOME_Exception)
1995 {
1996   SMESH_TRY;
1997   initData();
1998
1999   TPythonDump aTPythonDump;  // suppress dump in SplitQuad()
2000
2001   prepareIdSource( theObject );
2002   SMESH::long_array_var anElementsId = theObject->GetIDs();
2003   CORBA::Boolean isDone = SplitQuad(anElementsId, Diag13);
2004
2005   // Update Python script
2006   aTPythonDump << "isDone = " << this << ".SplitQuadObject( "
2007                << theObject << ", " << Diag13 << " )";
2008
2009   declareMeshModified( /*isReComputeSafe=*/!isDone );
2010   return isDone;
2011
2012   SMESH_CATCH( SMESH::throwCorbaException );
2013   return 0;
2014 }
2015
2016
2017 //=============================================================================
2018 /*!
2019  * Find better splitting of the given quadrangle.
2020  *  \param IDOfQuad  ID of the quadrangle to be split.
2021  *  \param Criterion A criterion to choose a diagonal for splitting.
2022  *  \return 1 if 1-3 diagonal is better, 2 if 2-4
2023  *          diagonal is better, 0 if error occurs.
2024  */
2025 //=============================================================================
2026
2027 CORBA::Long SMESH_MeshEditor_i::BestSplit (CORBA::Long                 IDOfQuad,
2028                                            SMESH::NumericalFunctor_ptr Criterion)
2029   throw (SALOME::SALOME_Exception)
2030 {
2031   SMESH_TRY;
2032   initData();
2033
2034   const SMDS_MeshElement* quad = getMeshDS()->FindElement(IDOfQuad);
2035   if (quad && quad->GetType() == SMDSAbs_Face && quad->NbNodes() == 4)
2036   {
2037     SMESH::NumericalFunctor_i* aNumericalFunctor =
2038       dynamic_cast<SMESH::NumericalFunctor_i*>(SMESH_Gen_i::GetServant(Criterion).in());
2039     SMESH::Controls::NumericalFunctorPtr aCrit;
2040     if (aNumericalFunctor)
2041       aCrit = aNumericalFunctor->GetNumericalFunctor();
2042     else
2043       aCrit.reset(new SMESH::Controls::AspectRatio());
2044
2045     int id = getEditor().BestSplit(quad, aCrit);
2046     declareMeshModified( /*isReComputeSafe=*/ id < 1 );
2047     return id;
2048   }
2049
2050   SMESH_CATCH( SMESH::throwCorbaException );
2051   return 0;
2052 }
2053
2054 //================================================================================
2055 /*!
2056  * \brief Split volumic elements into tetrahedrons
2057  */
2058 //================================================================================
2059
2060 void SMESH_MeshEditor_i::SplitVolumesIntoTetra (SMESH::SMESH_IDSource_ptr elems,
2061                                                 CORBA::Short              methodFlags)
2062   throw (SALOME::SALOME_Exception)
2063 {
2064   SMESH_TRY;
2065   initData();
2066
2067   ::SMESH_MeshEditor::TFacetOfElem elemSet;
2068   const int noneFacet = -1;
2069   SMDS_ElemIteratorPtr volIt = myMesh_i->GetElements( elems, SMESH::VOLUME );
2070   while( volIt->more() )
2071     elemSet.insert( elemSet.end(), make_pair( volIt->next(), noneFacet ));
2072
2073   getEditor().SplitVolumes( elemSet, int( methodFlags ));
2074   declareMeshModified( /*isReComputeSafe=*/true ); // it does not influence Compute()
2075
2076   TPythonDump() << this << ".SplitVolumesIntoTetra( "
2077                 << elems << ", " << methodFlags << " )";
2078
2079   SMESH_CATCH( SMESH::throwCorbaException );
2080 }
2081
2082 //================================================================================
2083 /*!
2084  * \brief Split hexahedra into triangular prisms
2085  *  \param elems - elements to split
2086  *  \param facetToSplitNormal - normal used to find a facet of hexahedron
2087  *         to split into triangles
2088  *  \param methodFlags - flags passing splitting method:
2089  *         1 - split the hexahedron into 2 prisms
2090  *         2 - split the hexahedron into 4 prisms
2091  */
2092 //================================================================================
2093
2094 void SMESH_MeshEditor_i::SplitHexahedraIntoPrisms( SMESH::SMESH_IDSource_ptr  elems,
2095                                                    const SMESH::PointStruct & startHexPoint,
2096                                                    const SMESH::DirStruct&    facetToSplitNormal,
2097                                                    CORBA::Short               methodFlags,
2098                                                    CORBA::Boolean             allDomains)
2099   throw (SALOME::SALOME_Exception)
2100 {
2101   SMESH_TRY;
2102   initData();
2103   prepareIdSource( elems );
2104
2105   gp_Ax1 facetNorm( gp_Pnt( startHexPoint.x,
2106                             startHexPoint.y,
2107                             startHexPoint.z ),
2108                     gp_Dir( facetToSplitNormal.PS.x,
2109                             facetToSplitNormal.PS.y,
2110                             facetToSplitNormal.PS.z ));
2111   TIDSortedElemSet elemSet;
2112   SMESH::long_array_var anElementsId = elems->GetIDs();
2113   SMDS_MeshElement::GeomFilter filter( SMDSGeom_HEXA );
2114   arrayToSet( anElementsId, getMeshDS(), elemSet, SMDSAbs_Volume, &filter );
2115
2116   ::SMESH_MeshEditor::TFacetOfElem elemFacets;
2117   while ( !elemSet.empty() )
2118   {
2119     getEditor().GetHexaFacetsToSplit( elemSet, facetNorm, elemFacets );
2120     if ( !allDomains )
2121       break;
2122
2123     ::SMESH_MeshEditor::TFacetOfElem::iterator ef = elemFacets.begin();
2124     for ( ; ef != elemFacets.end(); ++ef )
2125       elemSet.erase( ef->first );
2126   }
2127
2128   if ( methodFlags == 2 )
2129     methodFlags = int( ::SMESH_MeshEditor::HEXA_TO_4_PRISMS );
2130   else
2131     methodFlags = int( ::SMESH_MeshEditor::HEXA_TO_2_PRISMS );
2132
2133   getEditor().SplitVolumes( elemFacets, int( methodFlags ));
2134   declareMeshModified( /*isReComputeSafe=*/true ); // it does not influence Compute()
2135
2136   TPythonDump() << this << ".SplitHexahedraIntoPrisms( "
2137                 << elems << ", "
2138                 << startHexPoint << ", "
2139                 << facetToSplitNormal<< ", "
2140                 << methodFlags<< ", "
2141                 << allDomains << " )";
2142
2143   SMESH_CATCH( SMESH::throwCorbaException );
2144 }
2145
2146 //================================================================================
2147 /*!
2148  * \brief Split bi-quadratic elements into linear ones without creation of additional nodes:
2149  *   - bi-quadratic triangle will be split into 3 linear quadrangles;
2150  *   - bi-quadratic quadrangle will be split into 4 linear quadrangles;
2151  *   - tri-quadratic hexahedron will be split into 8 linear hexahedra.
2152  *   Quadratic elements of lower dimension  adjacent to the split bi-quadratic element
2153  *   will be split in order to keep the mesh conformal.
2154  *  \param elems - elements to split
2155  */
2156 //================================================================================
2157
2158 void SMESH_MeshEditor_i::SplitBiQuadraticIntoLinear(const SMESH::ListOfIDSources& theElems)
2159   throw (SALOME::SALOME_Exception)
2160 {
2161   SMESH_TRY;
2162   initData();
2163
2164   TIDSortedElemSet elemSet;
2165   for ( size_t i = 0; i < theElems.length(); ++i )
2166   {
2167     SMESH::SMESH_IDSource_ptr elems = theElems[i].in();
2168     SMESH::SMESH_Mesh_var      mesh = elems->GetMesh();
2169     if ( mesh->GetId() != myMesh_i->GetId() )
2170       THROW_SALOME_CORBA_EXCEPTION("Wrong mesh of IDSource", SALOME::BAD_PARAM);
2171
2172     idSourceToSet( elems, getMeshDS(), elemSet, SMDSAbs_All );
2173   }
2174   getEditor().SplitBiQuadraticIntoLinear( elemSet );
2175
2176   declareMeshModified( /*isReComputeSafe=*/true ); // it does not influence Compute()
2177
2178   TPythonDump() << this << ".SplitBiQuadraticIntoLinear( "
2179                 << theElems << " )";
2180
2181   SMESH_CATCH( SMESH::throwCorbaException );
2182 }
2183
2184 //=======================================================================
2185 //function : Smooth
2186 //purpose  :
2187 //=======================================================================
2188
2189 CORBA::Boolean
2190 SMESH_MeshEditor_i::Smooth(const SMESH::long_array &              IDsOfElements,
2191                            const SMESH::long_array &              IDsOfFixedNodes,
2192                            CORBA::Long                            MaxNbOfIterations,
2193                            CORBA::Double                          MaxAspectRatio,
2194                            SMESH::SMESH_MeshEditor::Smooth_Method Method)
2195   throw (SALOME::SALOME_Exception)
2196 {
2197   return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
2198                  MaxAspectRatio, Method, false );
2199 }
2200
2201
2202 //=======================================================================
2203 //function : SmoothParametric
2204 //purpose  :
2205 //=======================================================================
2206
2207 CORBA::Boolean
2208 SMESH_MeshEditor_i::SmoothParametric(const SMESH::long_array &              IDsOfElements,
2209                                      const SMESH::long_array &              IDsOfFixedNodes,
2210                                      CORBA::Long                            MaxNbOfIterations,
2211                                      CORBA::Double                          MaxAspectRatio,
2212                                      SMESH::SMESH_MeshEditor::Smooth_Method Method)
2213   throw (SALOME::SALOME_Exception)
2214 {
2215   return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
2216                  MaxAspectRatio, Method, true );
2217 }
2218
2219
2220 //=======================================================================
2221 //function : SmoothObject
2222 //purpose  :
2223 //=======================================================================
2224
2225 CORBA::Boolean
2226 SMESH_MeshEditor_i::SmoothObject(SMESH::SMESH_IDSource_ptr              theObject,
2227                                  const SMESH::long_array &              IDsOfFixedNodes,
2228                                  CORBA::Long                            MaxNbOfIterations,
2229                                  CORBA::Double                          MaxAspectRatio,
2230                                  SMESH::SMESH_MeshEditor::Smooth_Method Method)
2231   throw (SALOME::SALOME_Exception)
2232 {
2233   return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
2234                        MaxAspectRatio, Method, false);
2235 }
2236
2237
2238 //=======================================================================
2239 //function : SmoothParametricObject
2240 //purpose  :
2241 //=======================================================================
2242
2243 CORBA::Boolean
2244 SMESH_MeshEditor_i::SmoothParametricObject(SMESH::SMESH_IDSource_ptr              theObject,
2245                                            const SMESH::long_array &              IDsOfFixedNodes,
2246                                            CORBA::Long                            MaxNbOfIterations,
2247                                            CORBA::Double                          MaxAspectRatio,
2248                                            SMESH::SMESH_MeshEditor::Smooth_Method Method)
2249   throw (SALOME::SALOME_Exception)
2250 {
2251   return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
2252                        MaxAspectRatio, Method, true);
2253 }
2254
2255
2256 //=============================================================================
2257 /*!
2258  *
2259  */
2260 //=============================================================================
2261
2262 CORBA::Boolean
2263 SMESH_MeshEditor_i::smooth(const SMESH::long_array &              IDsOfElements,
2264                            const SMESH::long_array &              IDsOfFixedNodes,
2265                            CORBA::Long                            MaxNbOfIterations,
2266                            CORBA::Double                          MaxAspectRatio,
2267                            SMESH::SMESH_MeshEditor::Smooth_Method Method,
2268                            bool                                   IsParametric)
2269   throw (SALOME::SALOME_Exception)
2270 {
2271   SMESH_TRY;
2272   initData();
2273
2274   SMESHDS_Mesh* aMesh = getMeshDS();
2275
2276   TIDSortedElemSet elements;
2277   arrayToSet(IDsOfElements, aMesh, elements, SMDSAbs_Face);
2278
2279   set<const SMDS_MeshNode*> fixedNodes;
2280   for ( CORBA::ULong i = 0; i < IDsOfFixedNodes.length(); i++) {
2281     CORBA::Long index = IDsOfFixedNodes[i];
2282     const SMDS_MeshNode * node = aMesh->FindNode(index);
2283     if ( node )
2284       fixedNodes.insert( node );
2285   }
2286   ::SMESH_MeshEditor::SmoothMethod method = ::SMESH_MeshEditor::LAPLACIAN;
2287   if ( Method != SMESH::SMESH_MeshEditor::LAPLACIAN_SMOOTH )
2288     method = ::SMESH_MeshEditor::CENTROIDAL;
2289
2290   getEditor().Smooth(elements, fixedNodes, method,
2291                   MaxNbOfIterations, MaxAspectRatio, IsParametric );
2292
2293   declareMeshModified( /*isReComputeSafe=*/true ); // does not prevent re-compute
2294
2295   // Update Python script
2296   TPythonDump() << "isDone = " << this << "."
2297                 << (IsParametric ? "SmoothParametric( " : "Smooth( ")
2298                 << IDsOfElements << ", "     << IDsOfFixedNodes << ", "
2299                 << TVar( MaxNbOfIterations ) << ", " << TVar( MaxAspectRatio ) << ", "
2300                 << "SMESH.SMESH_MeshEditor."
2301                 << ( Method == SMESH::SMESH_MeshEditor::CENTROIDAL_SMOOTH ?
2302                      "CENTROIDAL_SMOOTH )" : "LAPLACIAN_SMOOTH )");
2303
2304   return true;
2305
2306   SMESH_CATCH( SMESH::throwCorbaException );
2307   return 0;
2308 }
2309
2310 //=============================================================================
2311 /*!
2312  *
2313  */
2314 //=============================================================================
2315
2316 CORBA::Boolean
2317 SMESH_MeshEditor_i::smoothObject(SMESH::SMESH_IDSource_ptr              theObject,
2318                                  const SMESH::long_array &              IDsOfFixedNodes,
2319                                  CORBA::Long                            MaxNbOfIterations,
2320                                  CORBA::Double                          MaxAspectRatio,
2321                                  SMESH::SMESH_MeshEditor::Smooth_Method Method,
2322                                  bool                                   IsParametric)
2323   throw (SALOME::SALOME_Exception)
2324 {
2325   SMESH_TRY;
2326   initData();
2327
2328   TPythonDump aTPythonDump;  // suppress dump in smooth()
2329
2330   prepareIdSource( theObject );
2331   SMESH::long_array_var anElementsId = theObject->GetIDs();
2332   CORBA::Boolean isDone = smooth (anElementsId, IDsOfFixedNodes, MaxNbOfIterations,
2333                                   MaxAspectRatio, Method, IsParametric);
2334
2335   // Update Python script
2336   aTPythonDump << "isDone = " << this << "."
2337                << (IsParametric ? "SmoothParametricObject( " : "SmoothObject( ")
2338                << theObject << ", " << IDsOfFixedNodes << ", "
2339                << TVar( MaxNbOfIterations ) << ", " << TVar( MaxAspectRatio ) << ", "
2340                << "SMESH.SMESH_MeshEditor."
2341                << ( Method == SMESH::SMESH_MeshEditor::CENTROIDAL_SMOOTH ?
2342                     "CENTROIDAL_SMOOTH )" : "LAPLACIAN_SMOOTH )");
2343
2344   return isDone;
2345
2346   SMESH_CATCH( SMESH::throwCorbaException );
2347   return 0;
2348 }
2349
2350 //=============================================================================
2351 /*!
2352  *
2353  */
2354 //=============================================================================
2355
2356 void SMESH_MeshEditor_i::RenumberNodes()
2357   throw (SALOME::SALOME_Exception)
2358 {
2359   SMESH_TRY;
2360   // Update Python script
2361   TPythonDump() << this << ".RenumberNodes()";
2362
2363   getMeshDS()->Renumber( true );
2364
2365   SMESH_CATCH( SMESH::throwCorbaException );
2366 }
2367
2368 //=============================================================================
2369 /*!
2370  *
2371  */
2372 //=============================================================================
2373
2374 void SMESH_MeshEditor_i::RenumberElements()
2375   throw (SALOME::SALOME_Exception)
2376 {
2377   SMESH_TRY;
2378   // Update Python script
2379   TPythonDump() << this << ".RenumberElements()";
2380
2381   getMeshDS()->Renumber( false );
2382
2383   SMESH_CATCH( SMESH::throwCorbaException );
2384 }
2385
2386 //=======================================================================
2387 /*!
2388  * \brief Return groups by their IDs
2389  */
2390 //=======================================================================
2391
2392 SMESH::ListOfGroups* SMESH_MeshEditor_i::getGroups(const std::list<int>* groupIDs)
2393   throw (SALOME::SALOME_Exception)
2394 {
2395   SMESH_TRY;
2396   if ( !groupIDs )
2397     return 0;
2398   myMesh_i->CreateGroupServants();
2399   return myMesh_i->GetGroups( *groupIDs );
2400
2401   SMESH_CATCH( SMESH::throwCorbaException );
2402   return 0;
2403 }
2404
2405 //=======================================================================
2406 //function : RotationSweepObjects
2407 //purpose  :
2408 //=======================================================================
2409
2410 SMESH::ListOfGroups*
2411 SMESH_MeshEditor_i::RotationSweepObjects(const SMESH::ListOfIDSources & theNodes,
2412                                          const SMESH::ListOfIDSources & theEdges,
2413                                          const SMESH::ListOfIDSources & theFaces,
2414                                          const SMESH::AxisStruct &      theAxis,
2415                                          CORBA::Double                  theAngleInRadians,
2416                                          CORBA::Long                    theNbOfSteps,
2417                                          CORBA::Double                  theTolerance,
2418                                          const bool                     theMakeGroups)
2419   throw (SALOME::SALOME_Exception)
2420 {
2421   SMESH_TRY;
2422   initData();
2423
2424   TIDSortedElemSet elemsNodes[2];
2425   for ( int i = 0, nb = theNodes.length(); i < nb; ++i ) {
2426     SMDS_ElemIteratorPtr nIt = myMesh_i->GetElements( theNodes[i], SMESH::NODE );
2427     while ( nIt->more() ) elemsNodes[1].insert( nIt->next() );
2428   }
2429   for ( int i = 0, nb = theEdges.length(); i < nb; ++i )
2430     idSourceToSet( theEdges[i], getMeshDS(), elemsNodes[0], SMDSAbs_Edge );
2431   for ( int i = 0, nb = theFaces.length(); i < nb; ++i )
2432     idSourceToSet( theFaces[i], getMeshDS(), elemsNodes[0], SMDSAbs_Face );
2433
2434   TIDSortedElemSet* workElements = & elemsNodes[0], copyElements[2];
2435   bool              makeWalls=true;
2436   if ( myIsPreviewMode )
2437   {
2438     SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
2439     TPreviewMesh * tmpMesh = getPreviewMesh();
2440     tmpMesh->Copy( elemsNodes[0], copyElements[0], select, avoid );
2441     tmpMesh->Copy( elemsNodes[1], copyElements[1], select, avoid );
2442     workElements = & copyElements[0];
2443     //makeWalls = false; -- faces are needed for preview
2444   }
2445
2446   TPythonDump aPythonDump; // it is here to prevent dump of getGroups()
2447
2448   gp_Ax1 Ax1 (gp_Pnt( theAxis.x,  theAxis.y,  theAxis.z ),
2449               gp_Vec( theAxis.vx, theAxis.vy, theAxis.vz ));
2450
2451   ::SMESH_MeshEditor::PGroupIDs groupIds =
2452       getEditor().RotationSweep (workElements, Ax1, theAngleInRadians,
2453                                  theNbOfSteps, theTolerance, theMakeGroups, makeWalls);
2454
2455   SMESH::ListOfGroups * aGroups = theMakeGroups ? getGroups( groupIds.get()) : 0;
2456
2457   declareMeshModified( /*isReComputeSafe=*/true ); // does not influence Compute()
2458
2459   if ( !myIsPreviewMode )
2460   {
2461     dumpGroupsList( aPythonDump, aGroups );
2462     aPythonDump << this<< ".RotationSweepObjects( "
2463                 << theNodes                  << ", "
2464                 << theEdges                  << ", "
2465                 << theFaces                  << ", "
2466                 << theAxis                   << ", "
2467                 << TVar( theAngleInRadians ) << ", "
2468                 << TVar( theNbOfSteps      ) << ", "
2469                 << TVar( theTolerance      ) << ", "
2470                 << theMakeGroups             << " )";
2471   }
2472   else
2473   {
2474     getPreviewMesh()->Remove( SMDSAbs_Volume );
2475   }
2476
2477   return aGroups ? aGroups : new SMESH::ListOfGroups;
2478
2479   SMESH_CATCH( SMESH::throwCorbaException );
2480   return 0;
2481 }
2482
2483 namespace MeshEditor_I
2484 {
2485   /*!
2486    * \brief Structure used to pass extrusion parameters to ::SMESH_MeshEditor
2487    */
2488   struct ExtrusionParams : public ::SMESH_MeshEditor::ExtrusParam
2489   {
2490     bool myIsExtrusionByNormal;
2491
2492     static int makeFlags( CORBA::Boolean MakeGroups,
2493                           CORBA::Boolean LinearVariation = false,
2494                           CORBA::Boolean ByAverageNormal = false,
2495                           CORBA::Boolean UseInputElemsOnly = false,
2496                           CORBA::Long    Flags = 0,
2497                           CORBA::Boolean MakeBoundary = true )
2498     {
2499       if ( MakeGroups       ) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_GROUPS;
2500       if ( ByAverageNormal  ) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_BY_AVG_NORMAL;
2501       if ( UseInputElemsOnly) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_USE_INPUT_ELEMS_ONLY;
2502       if ( LinearVariation  ) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_SCALE_LINEAR_VARIATION;
2503       if ( MakeBoundary     ) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_BOUNDARY;
2504       return Flags;
2505     }
2506     // standard params
2507     ExtrusionParams(const SMESH::DirStruct &    theDir,
2508                     CORBA::Long                 theNbOfSteps,
2509                     const SMESH::double_array & theScaleFactors,
2510                     CORBA::Boolean              theLinearVariation,
2511                     const SMESH::double_array & theBasePoint,
2512                     CORBA::Boolean              theMakeGroups):
2513       ::SMESH_MeshEditor::ExtrusParam ( gp_Vec( theDir.PS.x,
2514                                                 theDir.PS.y,
2515                                                 theDir.PS.z ),
2516                                         theNbOfSteps,
2517                                         toList( theScaleFactors ),
2518                                         TBasePoint( theBasePoint ),
2519                                         makeFlags( theMakeGroups, theLinearVariation )),
2520       myIsExtrusionByNormal( false )
2521     {
2522     }
2523     // advanced params
2524     ExtrusionParams(const SMESH::DirStruct &  theDir,
2525                     CORBA::Long               theNbOfSteps,
2526                     CORBA::Boolean            theMakeGroups,
2527                     CORBA::Long               theExtrFlags,
2528                     CORBA::Double             theSewTolerance):
2529       ::SMESH_MeshEditor::ExtrusParam ( gp_Vec( theDir.PS.x,
2530                                                 theDir.PS.y,
2531                                                 theDir.PS.z ),
2532                                         theNbOfSteps,
2533                                         std::list<double>(),
2534                                         0,
2535                                         makeFlags( theMakeGroups, false, false, false,
2536                                                    theExtrFlags, false ),
2537                                         theSewTolerance ),
2538       myIsExtrusionByNormal( false )
2539     {
2540     }
2541     // params for extrusion by normal
2542     ExtrusionParams(CORBA::Double  theStepSize,
2543                     CORBA::Long    theNbOfSteps,
2544                     CORBA::Short   theDim,
2545                     CORBA::Boolean theByAverageNormal,
2546                     CORBA::Boolean theUseInputElemsOnly,
2547                     CORBA::Boolean theMakeGroups ):
2548       ::SMESH_MeshEditor::ExtrusParam ( theStepSize,
2549                                         theNbOfSteps,
2550                                         makeFlags( theMakeGroups, false,
2551                                                    theByAverageNormal, theUseInputElemsOnly ),
2552                                         theDim),
2553       myIsExtrusionByNormal( true )
2554     {
2555     }
2556
2557     void SetNoGroups()
2558     {
2559       Flags() &= ~(::SMESH_MeshEditor::EXTRUSION_FLAG_GROUPS);
2560     }
2561
2562   private:
2563
2564     static std::list<double> toList( const SMESH::double_array & theScaleFactors )
2565     {
2566       std::list<double> scales;
2567       for ( CORBA::ULong i = 0; i < theScaleFactors.length(); ++i )
2568         scales.push_back( theScaleFactors[i] );
2569       return scales;
2570     }
2571
2572     // structure used to convert SMESH::double_array to gp_XYZ*
2573     struct TBasePoint
2574     {
2575       gp_XYZ *pp, p;
2576       TBasePoint( const SMESH::double_array & theBasePoint )
2577       {
2578         pp = 0;
2579         if ( theBasePoint.length() == 3 )
2580         {
2581           p.SetCoord( theBasePoint[0], theBasePoint[1], theBasePoint[2] );
2582           pp = &p;
2583         }
2584       }
2585       operator const gp_XYZ*() const { return pp; }
2586     };
2587   };
2588 }
2589
2590 //=======================================================================
2591 /*!
2592  * \brief Generate dim+1 elements by extrusion of elements along vector
2593  *  \param [in] edges - edges to extrude: a list including groups, sub-meshes or a mesh
2594  *  \param [in] faces - faces to extrude: a list including groups, sub-meshes or a mesh
2595  *  \param [in] nodes - nodes to extrude: a list including groups, sub-meshes or a mesh
2596  *  \param [in] stepVector - vector giving direction and distance of an extrusion step
2597  *  \param [in] nbOfSteps - number of elements to generate from one element
2598  *  \param [in] toMakeGroups - if true, new elements will be included into new groups
2599  *              corresponding to groups the input elements included in.
2600  *  \return ListOfGroups - new groups created if \a toMakeGroups is true
2601  */
2602 //=======================================================================
2603
2604 SMESH::ListOfGroups*
2605 SMESH_MeshEditor_i::ExtrusionSweepObjects(const SMESH::ListOfIDSources & theNodes,
2606                                           const SMESH::ListOfIDSources & theEdges,
2607                                           const SMESH::ListOfIDSources & theFaces,
2608                                           const SMESH::DirStruct &       theStepVector,
2609                                           CORBA::Long                    theNbOfSteps,
2610                                           const SMESH::double_array &    theScaleFactors,
2611                                           CORBA::Boolean                 theLinearVariation,
2612                                           const SMESH::double_array &    theBasePoint,
2613                                           CORBA::Boolean                 theToMakeGroups)
2614   throw (SALOME::SALOME_Exception)
2615 {
2616   SMESH_TRY;
2617   initData();
2618
2619   ExtrusionParams params( theStepVector, theNbOfSteps, theScaleFactors,
2620                           theLinearVariation, theBasePoint, theToMakeGroups );
2621
2622   TIDSortedElemSet elemsNodes[2];
2623   for ( int i = 0, nb = theNodes.length(); i < nb; ++i ) {
2624     SMDS_ElemIteratorPtr nIt = myMesh_i->GetElements( theNodes[i], SMESH::NODE );
2625     while ( nIt->more() ) elemsNodes[1].insert( nIt->next() );
2626   }
2627   for ( int i = 0, nb = theEdges.length(); i < nb; ++i )
2628     idSourceToSet( theEdges[i], getMeshDS(), elemsNodes[0], SMDSAbs_Edge );
2629   for ( int i = 0, nb = theFaces.length(); i < nb; ++i )
2630     idSourceToSet( theFaces[i], getMeshDS(), elemsNodes[0], SMDSAbs_Face );
2631
2632   TIDSortedElemSet* workElements = & elemsNodes[0], copyElements[2];
2633   SMDSAbs_ElementType previewType = SMDSAbs_All; //SMDSAbs_Face;
2634   if ( myIsPreviewMode )
2635   {
2636     // if ( (*elemsNodes.begin())->GetType() == SMDSAbs_Node )
2637     //   previewType = SMDSAbs_Edge;
2638
2639     SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
2640     TPreviewMesh * tmpMesh = getPreviewMesh( previewType );
2641     tmpMesh->Copy( elemsNodes[0], copyElements[0], select, avoid );
2642     tmpMesh->Copy( elemsNodes[1], copyElements[1], select, avoid );
2643     workElements = & copyElements[0];
2644
2645     params.SetNoGroups();
2646   }
2647   TPythonDump aPythonDump; // it is here to prevent dump of getGroups()
2648
2649   ::SMESH_MeshEditor::TTElemOfElemListMap aHistory;
2650   ::SMESH_MeshEditor::PGroupIDs groupIds =
2651       getEditor().ExtrusionSweep( workElements, params, aHistory );
2652
2653   SMESH::ListOfGroups * aGroups = theToMakeGroups ? getGroups( groupIds.get()) : 0;
2654
2655   declareMeshModified( /*isReComputeSafe=*/true ); // does not influence Compute()
2656
2657   if ( !myIsPreviewMode )
2658   {
2659     dumpGroupsList( aPythonDump, aGroups );
2660     aPythonDump << this<< ".ExtrusionSweepObjects( "
2661                 << theNodes             << ", "
2662                 << theEdges             << ", "
2663                 << theFaces             << ", "
2664                 << theStepVector        << ", "
2665                 << TVar( theNbOfSteps ) << ", "
2666                 << theToMakeGroups      << " )";
2667   }
2668   else
2669   {
2670     getPreviewMesh( previewType )->Remove( SMDSAbs_Volume );
2671   }
2672
2673   return aGroups ? aGroups : new SMESH::ListOfGroups;
2674
2675   SMESH_CATCH( SMESH::throwCorbaException );
2676   return 0;
2677 }
2678
2679 //=======================================================================
2680 //function : ExtrusionByNormal
2681 //purpose  :
2682 //=======================================================================
2683
2684 SMESH::ListOfGroups*
2685 SMESH_MeshEditor_i::ExtrusionByNormal(const SMESH::ListOfIDSources& objects,
2686                                       CORBA::Double                 stepSize,
2687                                       CORBA::Long                   nbOfSteps,
2688                                       CORBA::Boolean                byAverageNormal,
2689                                       CORBA::Boolean                useInputElemsOnly,
2690                                       CORBA::Boolean                makeGroups,
2691                                       CORBA::Short                  dim)
2692   throw (SALOME::SALOME_Exception)
2693 {
2694   SMESH_TRY;
2695   initData();
2696
2697   TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
2698
2699   ExtrusionParams params( stepSize, nbOfSteps, dim,
2700                           byAverageNormal, useInputElemsOnly, makeGroups );
2701
2702   SMDSAbs_ElementType elemType = ( dim == 1 ? SMDSAbs_Edge : SMDSAbs_Face );
2703   if ( objects.length() > 0 && !SMESH::DownCast<SMESH_Mesh_i*>( objects[0] ))
2704   {
2705     SMESH::array_of_ElementType_var elemTypes = objects[0]->GetTypes();
2706     if (( elemTypes->length() == 1 ) &&
2707         ( elemTypes[0] == SMESH::EDGE || elemTypes[0] == SMESH::FACE ))
2708       elemType = ( SMDSAbs_ElementType ) elemTypes[0];
2709   }
2710
2711   TIDSortedElemSet elemsNodes[2];
2712   for ( int i = 0, nb = objects.length(); i < nb; ++i )
2713     idSourceToSet( objects[i], getMeshDS(), elemsNodes[0], elemType );
2714
2715   TIDSortedElemSet* workElements = & elemsNodes[0], copyElements[2];
2716   SMDSAbs_ElementType previewType = SMDSAbs_Face;
2717   if ( myIsPreviewMode )
2718   {
2719     SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
2720     TPreviewMesh * tmpMesh = getPreviewMesh( previewType );
2721     tmpMesh->Copy( elemsNodes[0], copyElements[0], select, avoid );
2722     workElements = & copyElements[0];
2723
2724     params.SetNoGroups();
2725   }
2726
2727   ::SMESH_MeshEditor::TTElemOfElemListMap aHistory;
2728   ::SMESH_MeshEditor::PGroupIDs groupIds =
2729       getEditor().ExtrusionSweep( workElements, params, aHistory );
2730
2731   SMESH::ListOfGroups * aGroups = makeGroups ? getGroups( groupIds.get()) : 0;
2732
2733   if (!myIsPreviewMode) {
2734     dumpGroupsList(aPythonDump, aGroups);
2735     aPythonDump << this << ".ExtrusionByNormal( " << objects
2736                 << ", " << TVar( stepSize )
2737                 << ", " << TVar( nbOfSteps )
2738                 << ", " << byAverageNormal
2739                 << ", " << useInputElemsOnly
2740                 << ", " << makeGroups
2741                 << ", " << dim
2742                 << " )";
2743   }
2744   else
2745   {
2746     getPreviewMesh( previewType )->Remove( SMDSAbs_Volume );
2747   }
2748
2749   declareMeshModified( /*isReComputeSafe=*/true ); // does not influence Compute()
2750
2751   return aGroups ? aGroups : new SMESH::ListOfGroups;
2752
2753   SMESH_CATCH( SMESH::throwCorbaException );
2754   return 0;
2755 }
2756
2757 //=======================================================================
2758 //function : AdvancedExtrusion
2759 //purpose  :
2760 //=======================================================================
2761
2762 SMESH::ListOfGroups*
2763 SMESH_MeshEditor_i::AdvancedExtrusion(const SMESH::long_array & theIDsOfElements,
2764                                       const SMESH::DirStruct &  theStepVector,
2765                                       CORBA::Long               theNbOfSteps,
2766                                       CORBA::Long               theExtrFlags,
2767                                       CORBA::Double             theSewTolerance,
2768                                       CORBA::Boolean            theMakeGroups)
2769   throw (SALOME::SALOME_Exception)
2770 {
2771   SMESH_TRY;
2772   initData();
2773
2774   TPythonDump aPythonDump; // it is here to prevent dump of getGroups()
2775
2776   ExtrusionParams params( theStepVector, theNbOfSteps, theMakeGroups,
2777                           theExtrFlags, theSewTolerance );
2778
2779   TIDSortedElemSet elemsNodes[2];
2780   arrayToSet( theIDsOfElements, getMeshDS(), elemsNodes[0] );
2781
2782   ::SMESH_MeshEditor::TTElemOfElemListMap aHistory;
2783   ::SMESH_MeshEditor::PGroupIDs groupIds =
2784       getEditor().ExtrusionSweep( elemsNodes, params, aHistory );
2785
2786   SMESH::ListOfGroups * aGroups = theMakeGroups ? getGroups( groupIds.get()) : 0;
2787
2788   declareMeshModified( /*isReComputeSafe=*/true ); // does not influence Compute()
2789
2790   if ( !myIsPreviewMode ) {
2791     dumpGroupsList(aPythonDump, aGroups);
2792     aPythonDump << this << ".AdvancedExtrusion( "
2793                 << theIDsOfElements << ", "
2794                 << theStepVector << ", "
2795                 << theNbOfSteps << ", "
2796                 << theExtrFlags << ", "
2797                 << theSewTolerance << ", "
2798                 << theMakeGroups << " )";
2799   }
2800   else
2801   {
2802     getPreviewMesh()->Remove( SMDSAbs_Volume );
2803   }
2804
2805   return aGroups ? aGroups : new SMESH::ListOfGroups;
2806
2807   SMESH_CATCH( SMESH::throwCorbaException );
2808   return 0;
2809 }
2810
2811 //================================================================================
2812 /*!
2813  * \brief Convert extrusion error to IDL enum
2814  */
2815 //================================================================================
2816
2817 namespace
2818 {
2819 #define RETCASE(enm) case ::SMESH_MeshEditor::enm: return SMESH::SMESH_MeshEditor::enm;
2820
2821   SMESH::SMESH_MeshEditor::Extrusion_Error convExtrError( ::SMESH_MeshEditor::Extrusion_Error e )
2822   {
2823     switch ( e ) {
2824       RETCASE( EXTR_OK );
2825       RETCASE( EXTR_NO_ELEMENTS );
2826       RETCASE( EXTR_PATH_NOT_EDGE );
2827       RETCASE( EXTR_BAD_PATH_SHAPE );
2828       RETCASE( EXTR_BAD_STARTING_NODE );
2829       RETCASE( EXTR_BAD_ANGLES_NUMBER );
2830       RETCASE( EXTR_CANT_GET_TANGENT );
2831     }
2832     return SMESH::SMESH_MeshEditor::EXTR_OK;
2833   }
2834 }
2835
2836 //=======================================================================
2837 //function : extrusionAlongPath
2838 //purpose  :
2839 //=======================================================================
2840 SMESH::ListOfGroups*
2841 SMESH_MeshEditor_i::ExtrusionAlongPathObjects(const SMESH::ListOfIDSources & theNodes,
2842                                               const SMESH::ListOfIDSources & theEdges,
2843                                               const SMESH::ListOfIDSources & theFaces,
2844                                               SMESH::SMESH_IDSource_ptr      thePathMesh,
2845                                               GEOM::GEOM_Object_ptr          thePathShape,
2846                                               CORBA::Long                    theNodeStart,
2847                                               CORBA::Boolean                 theHasAngles,
2848                                               const SMESH::double_array &    theAngles,
2849                                               CORBA::Boolean                 theLinearVariation,
2850                                               CORBA::Boolean                 theHasRefPoint,
2851                                               const SMESH::PointStruct &     theRefPoint,
2852                                               bool                           theMakeGroups,
2853                                               SMESH::SMESH_MeshEditor::Extrusion_Error& theError)
2854   throw (SALOME::SALOME_Exception)
2855 {
2856   SMESH_TRY;
2857   initData();
2858
2859   SMESH::ListOfGroups_var aGroups = new SMESH::ListOfGroups;
2860
2861   theError = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
2862   if ( thePathMesh->_is_nil() )
2863     return aGroups._retn();
2864
2865   // get a sub-mesh
2866   SMESH_subMesh* aSubMesh = 0;
2867   SMESH_Mesh_i* aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( thePathMesh );
2868   if ( thePathShape->_is_nil() )
2869   {
2870     // thePathMesh should be either a sub-mesh or a mesh with 1D elements only
2871     if ( SMESH_subMesh_i* sm = SMESH::DownCast<SMESH_subMesh_i*>( thePathMesh ))
2872     {
2873       SMESH::SMESH_Mesh_var mesh = thePathMesh->GetMesh();
2874       aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
2875       if ( !aMeshImp ) return aGroups._retn();
2876       aSubMesh = aMeshImp->GetImpl().GetSubMeshContaining( sm->GetId() );
2877       if ( !aSubMesh ) return aGroups._retn();
2878     }
2879     else if ( !aMeshImp ||
2880               aMeshImp->NbEdges() != aMeshImp->NbElements() )
2881     {
2882       return aGroups._retn();
2883     }
2884   }
2885   else
2886   {
2887     if ( !aMeshImp ) return aGroups._retn();
2888     TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( thePathShape );
2889     aSubMesh = aMeshImp->GetImpl().GetSubMesh( aShape );
2890     if ( !aSubMesh /*|| !aSubMesh->GetSubMeshDS()*/ )
2891       return aGroups._retn();
2892   }
2893
2894   SMDS_MeshNode* nodeStart =
2895     (SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(theNodeStart);
2896   if ( !nodeStart ) {
2897     theError = SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE;
2898     return aGroups._retn();
2899   }
2900
2901   TIDSortedElemSet elemsNodes[2];
2902   for ( int i = 0, nb = theNodes.length(); i < nb; ++i ) {
2903     SMDS_ElemIteratorPtr nIt = myMesh_i->GetElements( theNodes[i], SMESH::NODE );
2904     while ( nIt->more() ) elemsNodes[1].insert( nIt->next() );
2905   }
2906   for ( int i = 0, nb = theEdges.length(); i < nb; ++i )
2907     idSourceToSet( theEdges[i], getMeshDS(), elemsNodes[0], SMDSAbs_Edge );
2908   for ( int i = 0, nb = theFaces.length(); i < nb; ++i )
2909     idSourceToSet( theFaces[i], getMeshDS(), elemsNodes[0], SMDSAbs_Face );
2910
2911   list<double> angles;
2912   for ( CORBA::ULong i = 0; i < theAngles.length(); i++ ) {
2913     angles.push_back( theAngles[i] );
2914   }
2915
2916   gp_Pnt refPnt( theRefPoint.x, theRefPoint.y, theRefPoint.z );
2917
2918   int nbOldGroups = myMesh->NbGroup();
2919
2920   TIDSortedElemSet* workElements = & elemsNodes[0], copyElements[2];
2921   if ( myIsPreviewMode )
2922   {
2923     SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
2924     TPreviewMesh * tmpMesh = getPreviewMesh();
2925     tmpMesh->Copy( elemsNodes[0], copyElements[0], select, avoid );
2926     tmpMesh->Copy( elemsNodes[1], copyElements[1], select, avoid );
2927     workElements = & copyElements[0];
2928     theMakeGroups = false;
2929   }
2930
2931   ::SMESH_MeshEditor::Extrusion_Error error;
2932   if ( !aSubMesh )
2933     error = getEditor().ExtrusionAlongTrack( workElements, &(aMeshImp->GetImpl()), nodeStart,
2934                                              theHasAngles, angles, theLinearVariation,
2935                                              theHasRefPoint, refPnt, theMakeGroups );
2936   else
2937     error = getEditor().ExtrusionAlongTrack( workElements, aSubMesh, nodeStart,
2938                                              theHasAngles, angles, theLinearVariation,
2939                                              theHasRefPoint, refPnt, theMakeGroups );
2940
2941   declareMeshModified( /*isReComputeSafe=*/true );
2942   theError = convExtrError( error );
2943
2944   TPythonDump aPythonDump; // it is here to prevent dump of getGroups()
2945   if ( theMakeGroups ) {
2946     list<int> groupIDs = myMesh->GetGroupIds();
2947     list<int>::iterator newBegin = groupIDs.begin();
2948     std::advance( newBegin, nbOldGroups ); // skip old groups
2949     groupIDs.erase( groupIDs.begin(), newBegin );
2950     aGroups = getGroups( & groupIDs );
2951     if ( ! &aGroups.in() ) aGroups = new SMESH::ListOfGroups;
2952   }
2953
2954   if ( !myIsPreviewMode ) {
2955     if ( aGroups->length() > 0 ) aPythonDump << "(" << aGroups << ", error) = ";
2956     else                         aPythonDump << "(_noGroups, error) = ";
2957     aPythonDump << this << ".ExtrusionAlongPathObjects( "
2958                 << theNodes            << ", "
2959                 << theEdges            << ", "
2960                 << theFaces            << ", "
2961                 << thePathMesh         << ", "
2962                 << thePathShape        << ", "
2963                 << theNodeStart        << ", "
2964                 << theHasAngles        << ", "
2965                 << TVar( theAngles )   << ", "
2966                 << theLinearVariation  << ", "
2967                 << theHasRefPoint      << ", "
2968                 << "SMESH.PointStruct( "
2969                 << TVar( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
2970                 << TVar( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
2971                 << TVar( theHasRefPoint ? theRefPoint.z : 0 ) << " ), "
2972                 << theMakeGroups       << " )";
2973   }
2974   else
2975   {
2976     getPreviewMesh()->Remove( SMDSAbs_Volume );
2977   }
2978
2979   return aGroups._retn();
2980
2981   SMESH_CATCH( SMESH::throwCorbaException );
2982   return 0;
2983 }
2984
2985 //================================================================================
2986 /*!
2987  * \brief Compute rotation angles for ExtrusionAlongPath as linear variation
2988  * of given angles along path steps
2989  * \param PathMesh mesh containing a 1D sub-mesh on the edge, along
2990  *                which proceeds the extrusion
2991  * \param PathShape is shape(edge); as the mesh can be complex, the edge
2992  *                 is used to define the sub-mesh for the path
2993  */
2994 //================================================================================
2995
2996 SMESH::double_array*
2997 SMESH_MeshEditor_i::LinearAnglesVariation(SMESH::SMESH_Mesh_ptr       thePathMesh,
2998                                           GEOM::GEOM_Object_ptr       thePathShape,
2999                                           const SMESH::double_array & theAngles)
3000 {
3001   SMESH::double_array_var aResult = new SMESH::double_array();
3002   int nbAngles = theAngles.length();
3003   if ( nbAngles > 0 && !thePathMesh->_is_nil() && !thePathShape->_is_nil() )
3004   {
3005     SMESH_Mesh_i* aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( thePathMesh );
3006     TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( thePathShape );
3007     SMESH_subMesh* aSubMesh = aMeshImp->GetImpl().GetSubMesh( aShape );
3008     if ( !aSubMesh || !aSubMesh->GetSubMeshDS())
3009       return aResult._retn();
3010     int nbSteps = aSubMesh->GetSubMeshDS()->NbElements();
3011     if ( nbSteps == nbAngles )
3012     {
3013       aResult.inout() = theAngles;
3014     }
3015     else
3016     {
3017       aResult->length( nbSteps );
3018       double rAn2St = double( nbAngles ) / double( nbSteps );
3019       double angPrev = 0, angle;
3020       for ( int iSt = 0; iSt < nbSteps; ++iSt )
3021       {
3022         double angCur = rAn2St * ( iSt+1 );
3023         double angCurFloor  = floor( angCur );
3024         double angPrevFloor = floor( angPrev );
3025         if ( angPrevFloor == angCurFloor )
3026           angle = rAn2St * theAngles[ int( angCurFloor ) ];
3027         else
3028         {
3029           int iP = int( angPrevFloor );
3030           double angPrevCeil = ceil(angPrev);
3031           angle = ( angPrevCeil - angPrev ) * theAngles[ iP ];
3032
3033           int iC = int( angCurFloor );
3034           if ( iC < nbAngles )
3035             angle += ( angCur - angCurFloor ) * theAngles[ iC ];
3036
3037           iP = int( angPrevCeil );
3038           while ( iC-- > iP )
3039             angle += theAngles[ iC ];
3040         }
3041         aResult[ iSt ] = angle;
3042         angPrev = angCur;
3043       }
3044     }
3045   }
3046   // Update Python script
3047   TPythonDump() << "rotAngles = " << theAngles;
3048   TPythonDump() << "rotAngles = " << this << ".LinearAnglesVariation( "
3049                 << thePathMesh  << ", "
3050                 << thePathShape << ", "
3051                 << "rotAngles )";
3052
3053   return aResult._retn();
3054 }
3055
3056 //=======================================================================
3057 //function : mirror
3058 //purpose  :
3059 //=======================================================================
3060
3061 SMESH::ListOfGroups*
3062 SMESH_MeshEditor_i::mirror(TIDSortedElemSet &                  theElements,
3063                            const SMESH::AxisStruct &           theAxis,
3064                            SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
3065                            CORBA::Boolean                      theCopy,
3066                            bool                                theMakeGroups,
3067                            ::SMESH_Mesh*                       theTargetMesh)
3068   throw (SALOME::SALOME_Exception)
3069 {
3070   SMESH_TRY;
3071   initData();
3072
3073   gp_Pnt P ( theAxis.x, theAxis.y, theAxis.z );
3074   gp_Vec V ( theAxis.vx, theAxis.vy, theAxis.vz );
3075
3076   if ( theTargetMesh )
3077     theCopy = false;
3078
3079   gp_Trsf aTrsf;
3080   switch ( theMirrorType ) {
3081   case  SMESH::SMESH_MeshEditor::POINT:
3082     aTrsf.SetMirror( P );
3083     break;
3084   case  SMESH::SMESH_MeshEditor::AXIS:
3085     aTrsf.SetMirror( gp_Ax1( P, V ));
3086     break;
3087   default:
3088     aTrsf.SetMirror( gp_Ax2( P, V ));
3089   }
3090
3091   TIDSortedElemSet  copyElements;
3092   TIDSortedElemSet* workElements = & theElements;
3093
3094   if ( myIsPreviewMode )
3095   {
3096     TPreviewMesh * tmpMesh = getPreviewMesh();
3097     tmpMesh->Copy( theElements, copyElements);
3098     if ( !theCopy && !theTargetMesh )
3099     {
3100       TIDSortedElemSet elemsAround, elemsAroundCopy;
3101       getElementsAround( theElements, getMeshDS(), elemsAround );
3102       tmpMesh->Copy( elemsAround, elemsAroundCopy);
3103     }
3104     workElements = & copyElements;
3105     theMakeGroups = false;
3106   }
3107
3108   ::SMESH_MeshEditor::PGroupIDs groupIds =
3109       getEditor().Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
3110
3111   if ( !myIsPreviewMode )
3112   {
3113     if ( theTargetMesh )
3114       theTargetMesh->GetMeshDS()->Modified();
3115     else
3116       declareMeshModified( /*isReComputeSafe=*/false );
3117   }
3118
3119   return theMakeGroups ? getGroups(groupIds.get()) : 0;
3120
3121   SMESH_CATCH( SMESH::throwCorbaException );
3122   return 0;
3123 }
3124
3125 //=======================================================================
3126 //function : Mirror
3127 //purpose  :
3128 //=======================================================================
3129
3130 void SMESH_MeshEditor_i::Mirror(const SMESH::long_array &           theIDsOfElements,
3131                                 const SMESH::AxisStruct &           theAxis,
3132                                 SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
3133                                 CORBA::Boolean                      theCopy)
3134   throw (SALOME::SALOME_Exception)
3135 {
3136   if ( !myIsPreviewMode ) {
3137     TPythonDump() << this << ".Mirror( "
3138                   << theIDsOfElements              << ", "
3139                   << theAxis                       << ", "
3140                   << mirrorTypeName(theMirrorType) << ", "
3141                   << theCopy                       << " )";
3142   }
3143   if ( theIDsOfElements.length() > 0 )
3144   {
3145     TIDSortedElemSet elements;
3146     arrayToSet(theIDsOfElements, getMeshDS(), elements);
3147     mirror(elements, theAxis, theMirrorType, theCopy, false);
3148   }
3149 }
3150
3151
3152 //=======================================================================
3153 //function : MirrorObject
3154 //purpose  :
3155 //=======================================================================
3156
3157 void SMESH_MeshEditor_i::MirrorObject(SMESH::SMESH_IDSource_ptr           theObject,
3158                                       const SMESH::AxisStruct &           theAxis,
3159                                       SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
3160                                       CORBA::Boolean                      theCopy)
3161   throw (SALOME::SALOME_Exception)
3162 {
3163   if ( !myIsPreviewMode ) {
3164     TPythonDump() << this << ".MirrorObject( "
3165                   << theObject                     << ", "
3166                   << theAxis                       << ", "
3167                   << mirrorTypeName(theMirrorType) << ", "
3168                   << theCopy                       << " )";
3169   }
3170   TIDSortedElemSet elements;
3171
3172   bool emptyIfIsMesh = myIsPreviewMode ? false : true;
3173
3174   if (idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
3175     mirror(elements, theAxis, theMirrorType, theCopy, false);
3176 }
3177
3178 //=======================================================================
3179 //function : MirrorMakeGroups
3180 //purpose  :
3181 //=======================================================================
3182
3183 SMESH::ListOfGroups*
3184 SMESH_MeshEditor_i::MirrorMakeGroups(const SMESH::long_array&            theIDsOfElements,
3185                                      const SMESH::AxisStruct&            theMirror,
3186                                      SMESH::SMESH_MeshEditor::MirrorType theMirrorType)
3187   throw (SALOME::SALOME_Exception)
3188 {
3189   TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
3190
3191   SMESH::ListOfGroups * aGroups = 0;
3192   if ( theIDsOfElements.length() > 0 )
3193   {
3194     TIDSortedElemSet elements;
3195     arrayToSet(theIDsOfElements, getMeshDS(), elements);
3196     aGroups = mirror(elements, theMirror, theMirrorType, true, true);
3197   }
3198   if (!myIsPreviewMode) {
3199     dumpGroupsList(aPythonDump, aGroups);
3200     aPythonDump << this << ".MirrorMakeGroups( "
3201                 << theIDsOfElements              << ", "
3202                 << theMirror                     << ", "
3203                 << mirrorTypeName(theMirrorType) << " )";
3204   }
3205   return aGroups;
3206 }
3207
3208 //=======================================================================
3209 //function : MirrorObjectMakeGroups
3210 //purpose  :
3211 //=======================================================================
3212
3213 SMESH::ListOfGroups*
3214 SMESH_MeshEditor_i::MirrorObjectMakeGroups(SMESH::SMESH_IDSource_ptr           theObject,
3215                                            const SMESH::AxisStruct&            theMirror,
3216                                            SMESH::SMESH_MeshEditor::MirrorType theMirrorType)
3217   throw (SALOME::SALOME_Exception)
3218 {
3219   TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
3220
3221   SMESH::ListOfGroups * aGroups = 0;
3222   TIDSortedElemSet elements;
3223   if ( idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
3224     aGroups = mirror(elements, theMirror, theMirrorType, true, true);
3225
3226   if (!myIsPreviewMode)
3227   {
3228     dumpGroupsList(aPythonDump,aGroups);
3229     aPythonDump << this << ".MirrorObjectMakeGroups( "
3230                 << theObject                     << ", "
3231                 << theMirror                     << ", "
3232                 << mirrorTypeName(theMirrorType) << " )";
3233   }
3234   return aGroups;
3235 }
3236
3237 //=======================================================================
3238 //function : MirrorMakeMesh
3239 //purpose  :
3240 //=======================================================================
3241
3242 SMESH::SMESH_Mesh_ptr
3243 SMESH_MeshEditor_i::MirrorMakeMesh(const SMESH::long_array&            theIDsOfElements,
3244                                    const SMESH::AxisStruct&            theMirror,
3245                                    SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
3246                                    CORBA::Boolean                      theCopyGroups,
3247                                    const char*                         theMeshName)
3248   throw (SALOME::SALOME_Exception)
3249 {
3250   SMESH_Mesh_i* mesh_i;
3251   SMESH::SMESH_Mesh_var mesh;
3252   { // open new scope to dump "MakeMesh" command
3253     // and then "GetGroups" using SMESH_Mesh::GetGroups()
3254
3255     TPythonDump pydump; // to prevent dump at mesh creation
3256
3257     mesh = makeMesh( theMeshName );
3258     mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
3259     if (mesh_i && theIDsOfElements.length() > 0 )
3260     {
3261       TIDSortedElemSet elements;
3262       arrayToSet(theIDsOfElements, getMeshDS(), elements);
3263       mirror(elements, theMirror, theMirrorType,
3264              false, theCopyGroups, & mesh_i->GetImpl());
3265       mesh_i->CreateGroupServants();
3266     }
3267
3268     if (!myIsPreviewMode) {
3269       pydump << mesh << " = " << this << ".MirrorMakeMesh( "
3270              << theIDsOfElements              << ", "
3271              << theMirror                     << ", "
3272              << mirrorTypeName(theMirrorType) << ", "
3273              << theCopyGroups                 << ", '"
3274              << theMeshName                   << "' )";
3275     }
3276   }
3277
3278   //dump "GetGroups"
3279   if (!myIsPreviewMode && mesh_i)
3280     mesh_i->GetGroups();
3281
3282   return mesh._retn();
3283 }
3284
3285 //=======================================================================
3286 //function : MirrorObjectMakeMesh
3287 //purpose  :
3288 //=======================================================================
3289
3290 SMESH::SMESH_Mesh_ptr
3291 SMESH_MeshEditor_i::MirrorObjectMakeMesh(SMESH::SMESH_IDSource_ptr           theObject,
3292                                          const SMESH::AxisStruct&            theMirror,
3293                                          SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
3294                                          CORBA::Boolean                      theCopyGroups,
3295                                          const char*                         theMeshName)
3296   throw (SALOME::SALOME_Exception)
3297 {
3298   SMESH_Mesh_i* mesh_i;
3299   SMESH::SMESH_Mesh_var mesh;
3300   { // open new scope to dump "MakeMesh" command
3301     // and then "GetGroups" using SMESH_Mesh::GetGroups()
3302
3303     TPythonDump pydump; // to prevent dump at mesh creation
3304
3305     mesh = makeMesh( theMeshName );
3306     mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
3307     TIDSortedElemSet elements;
3308     if ( mesh_i &&
3309          idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
3310     {
3311       mirror(elements, theMirror, theMirrorType,
3312              false, theCopyGroups, & mesh_i->GetImpl());
3313       mesh_i->CreateGroupServants();
3314     }
3315     if (!myIsPreviewMode) {
3316       pydump << mesh << " = " << this << ".MirrorObjectMakeMesh( "
3317              << theObject                     << ", "
3318              << theMirror                     << ", "
3319              << mirrorTypeName(theMirrorType) << ", "
3320              << theCopyGroups                 << ", '"
3321              << theMeshName                   << "' )";
3322     }
3323   }
3324
3325   //dump "GetGroups"
3326   if (!myIsPreviewMode && mesh_i)
3327     mesh_i->GetGroups();
3328
3329   return mesh._retn();
3330 }
3331
3332 //=======================================================================
3333 //function : translate
3334 //purpose  :
3335 //=======================================================================
3336
3337 SMESH::ListOfGroups*
3338 SMESH_MeshEditor_i::translate(TIDSortedElemSet        & theElements,
3339                               const SMESH::DirStruct &  theVector,
3340                               CORBA::Boolean            theCopy,
3341                               bool                      theMakeGroups,
3342                               ::SMESH_Mesh*             theTargetMesh)
3343   throw (SALOME::SALOME_Exception)
3344 {
3345   SMESH_TRY;
3346   initData();
3347
3348   if ( theTargetMesh )
3349     theCopy = false;
3350
3351   gp_Trsf aTrsf;
3352   const SMESH::PointStruct * P = &theVector.PS;
3353   aTrsf.SetTranslation( gp_Vec( P->x, P->y, P->z ));
3354
3355   TIDSortedElemSet  copyElements;
3356   TIDSortedElemSet* workElements = &theElements;
3357
3358   if ( myIsPreviewMode )
3359   {
3360     TPreviewMesh * tmpMesh = getPreviewMesh();
3361     tmpMesh->Copy( theElements, copyElements);
3362     if ( !theCopy && !theTargetMesh )
3363     {
3364       TIDSortedElemSet elemsAround, elemsAroundCopy;
3365       getElementsAround( theElements, getMeshDS(), elemsAround );
3366       tmpMesh->Copy( elemsAround, elemsAroundCopy);
3367     }
3368     workElements = & copyElements;
3369     theMakeGroups = false;
3370   }
3371
3372   ::SMESH_MeshEditor::PGroupIDs groupIds =
3373       getEditor().Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
3374
3375   if ( !myIsPreviewMode )
3376   {
3377     if ( theTargetMesh )
3378       theTargetMesh->GetMeshDS()->Modified();
3379     else
3380       declareMeshModified( /*isReComputeSafe=*/false );
3381   }
3382
3383   return theMakeGroups ? getGroups(groupIds.get()) : 0;
3384
3385   SMESH_CATCH( SMESH::throwCorbaException );
3386   return 0;
3387 }
3388
3389 //=======================================================================
3390 //function : Translate
3391 //purpose  :
3392 //=======================================================================
3393
3394 void SMESH_MeshEditor_i::Translate(const SMESH::long_array & theIDsOfElements,
3395                                    const SMESH::DirStruct &  theVector,
3396                                    CORBA::Boolean            theCopy)
3397   throw (SALOME::SALOME_Exception)
3398 {
3399   if (!myIsPreviewMode) {
3400     TPythonDump() << this << ".Translate( "
3401                   << theIDsOfElements << ", "
3402                   << theVector        << ", "
3403                   << theCopy          << " )";
3404   }
3405   if (theIDsOfElements.length()) {
3406     TIDSortedElemSet elements;
3407     arrayToSet(theIDsOfElements, getMeshDS(), elements);
3408     translate(elements, theVector, theCopy, false);
3409   }
3410 }
3411
3412 //=======================================================================
3413 //function : TranslateObject
3414 //purpose  :
3415 //=======================================================================
3416
3417 void SMESH_MeshEditor_i::TranslateObject(SMESH::SMESH_IDSource_ptr theObject,
3418                                          const SMESH::DirStruct &  theVector,
3419                                          CORBA::Boolean            theCopy)
3420   throw (SALOME::SALOME_Exception)
3421 {
3422   if (!myIsPreviewMode) {
3423     TPythonDump() << this << ".TranslateObject( "
3424                   << theObject << ", "
3425                   << theVector << ", "
3426                   << theCopy   << " )";
3427   }
3428   TIDSortedElemSet elements;
3429
3430   bool emptyIfIsMesh = myIsPreviewMode ? false : true;
3431
3432   if (idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
3433     translate(elements, theVector, theCopy, false);
3434 }
3435
3436 //=======================================================================
3437 //function : TranslateMakeGroups
3438 //purpose  :
3439 //=======================================================================
3440
3441 SMESH::ListOfGroups*
3442 SMESH_MeshEditor_i::TranslateMakeGroups(const SMESH::long_array& theIDsOfElements,
3443                                         const SMESH::DirStruct&  theVector)
3444   throw (SALOME::SALOME_Exception)
3445 {
3446   TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
3447
3448   SMESH::ListOfGroups * aGroups = 0;
3449   if (theIDsOfElements.length()) {
3450     TIDSortedElemSet elements;
3451     arrayToSet(theIDsOfElements, getMeshDS(), elements);
3452     aGroups = translate(elements,theVector,true,true);
3453   }
3454   if (!myIsPreviewMode) {
3455     dumpGroupsList(aPythonDump, aGroups);
3456     aPythonDump << this << ".TranslateMakeGroups( "
3457                 << theIDsOfElements << ", "
3458                 << theVector        << " )";
3459   }
3460   return aGroups;
3461 }
3462
3463 //=======================================================================
3464 //function : TranslateObjectMakeGroups
3465 //purpose  :
3466 //=======================================================================
3467
3468 SMESH::ListOfGroups*
3469 SMESH_MeshEditor_i::TranslateObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
3470                                               const SMESH::DirStruct&   theVector)
3471   throw (SALOME::SALOME_Exception)
3472 {
3473   TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
3474
3475   SMESH::ListOfGroups * aGroups = 0;
3476   TIDSortedElemSet elements;
3477   if (idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
3478     aGroups = translate(elements, theVector, true, true);
3479
3480   if (!myIsPreviewMode) {
3481     dumpGroupsList(aPythonDump, aGroups);
3482     aPythonDump << this << ".TranslateObjectMakeGroups( "
3483                 << theObject << ", "
3484                 << theVector << " )";
3485   }
3486   return aGroups;
3487 }
3488
3489 //=======================================================================
3490 //function : TranslateMakeMesh
3491 //purpose  :
3492 //=======================================================================
3493
3494 SMESH::SMESH_Mesh_ptr
3495 SMESH_MeshEditor_i::TranslateMakeMesh(const SMESH::long_array& theIDsOfElements,
3496                                       const SMESH::DirStruct&  theVector,
3497                                       CORBA::Boolean           theCopyGroups,
3498                                       const char*              theMeshName)
3499   throw (SALOME::SALOME_Exception)
3500 {
3501   SMESH_Mesh_i* mesh_i;
3502   SMESH::SMESH_Mesh_var mesh;
3503
3504   { // open new scope to dump "MakeMesh" command
3505     // and then "GetGroups" using SMESH_Mesh::GetGroups()
3506
3507     TPythonDump pydump; // to prevent dump at mesh creation
3508
3509     mesh = makeMesh( theMeshName );
3510     mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
3511
3512     if ( mesh_i && theIDsOfElements.length() )
3513     {
3514