src/SMESH_I/SMESH_MeshEditor_i.cxx

   1 //  SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
   2 //
   3 //  Copyright (C) 2003  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.
  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 //
  23 //
  24 //  File   : SMESH_MeshEditor_i.cxx
  25 //  Author : Nicolas REJNERI
  26 //  Module : SMESH
  27 //  $Header$
  28
  29 #include "SMESH_MeshEditor_i.hxx"
  30
  31 #include "SMDS_MeshEdge.hxx"
  32 #include "SMDS_MeshFace.hxx"
  33 #include "SMDS_MeshVolume.hxx"
  34
  35 #include "SMESH_MeshEditor.hxx"
  36
  37 #include "SMESH_Gen_i.hxx"
  38 #include "SMESH_Filter_i.hxx"
  39 #include "SMESH_PythonDump.hxx"
  40
  41 #include "utilities.h"
  42
  43 #include <gp_Ax1.hxx>
  44 #include <gp_Ax2.hxx>
  45 #include <gp_Vec.hxx>
  46
  47 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
  48 #define NO_CAS_CATCH
  49 #endif
  50
  51 #include <Standard_Failure.hxx>
  52
  53 #ifdef NO_CAS_CATCH
  54 #include <Standard_ErrorHandler.hxx>
  55 #else
  56 #include "CASCatch.hxx"
  57 #endif
  58
  59 #include <sstream>
  60
  61 typedef map<const SMDS_MeshElement*,
  62             list<const SMDS_MeshElement*> > TElemOfElemListMap;
  63
  64 using namespace std;
  65 using SMESH::TPythonDump;
  66
  67 //=============================================================================
  68 /*!
  69  *
  70  */
  71 //=============================================================================
  72
  73 SMESH_MeshEditor_i::SMESH_MeshEditor_i(SMESH_Mesh* theMesh)
  74 {
  75         _myMesh = theMesh;
  76 }
  77
  78 //=============================================================================
  79 /*!
  80  *
  81  */
  82 //=============================================================================
  83
  84 CORBA::Boolean
  85   SMESH_MeshEditor_i::RemoveElements(const SMESH::long_array & IDsOfElements)
  86 {
  87   myLastCreatedElems = new SMESH::long_array();
  88   myLastCreatedNodes = new SMESH::long_array();
  89
  90   ::SMESH_MeshEditor anEditor( _myMesh );
  91   list< int > IdList;
  92
  93   for (int i = 0; i < IDsOfElements.length(); i++)
  94     IdList.push_back( IDsOfElements[i] );
  95
  96   // Update Python script
  97   TPythonDump() << "isDone = " << this << ".RemoveElements( " << IDsOfElements << " )";
  98 #ifdef _DEBUG_
  99   TPythonDump() << "print 'RemoveElements: ', isDone";
 100 #endif
 101   // Remove Elements
 102   return anEditor.Remove( IdList, false );
 103 }
 104
 105 //=============================================================================
 106 /*!
 107  *
 108  */
 109 //=============================================================================
 110
 111 CORBA::Boolean SMESH_MeshEditor_i::RemoveNodes(const SMESH::long_array & IDsOfNodes)
 112 {
 113   myLastCreatedElems = new SMESH::long_array();
 114   myLastCreatedNodes = new SMESH::long_array();
 115
 116   ::SMESH_MeshEditor anEditor( _myMesh );
 117   list< int > IdList;
 118   for (int i = 0; i < IDsOfNodes.length(); i++)
 119     IdList.push_back( IDsOfNodes[i] );
 120
 121   // Update Python script
 122   TPythonDump() << "isDone = " << this << ".RemoveNodes( " << IDsOfNodes << " )";
 123 #ifdef _DEBUG_
 124   TPythonDump() << "print 'RemoveNodes: ', isDone";
 125 #endif
 126
 127   return anEditor.Remove( IdList, true );
 128 }
 129
 130 //=============================================================================
 131 /*!
 132  *
 133  */
 134 //=============================================================================
 135
 136 CORBA::Long SMESH_MeshEditor_i::AddEdge(const SMESH::long_array & IDsOfNodes)
 137 {
 138   myLastCreatedElems = new SMESH::long_array();
 139   myLastCreatedNodes = new SMESH::long_array();
 140
 141   int NbNodes = IDsOfNodes.length();
 142   SMDS_MeshElement* elem = 0;
 143   if (NbNodes == 2)
 144   {
 145     CORBA::Long index1 = IDsOfNodes[0];
 146     CORBA::Long index2 = IDsOfNodes[1];
 147     elem = GetMeshDS()->AddEdge(GetMeshDS()->FindNode(index1), GetMeshDS()->FindNode(index2));
 148
 149     // Update Python script
 150     TPythonDump() << "edge = " << this << ".AddEdge([ "
 151                   << index1 << ", " << index2 <<" ])";
 152   }
 153   if (NbNodes == 3) {
 154     CORBA::Long n1 = IDsOfNodes[0];
 155     CORBA::Long n2 = IDsOfNodes[1];
 156     CORBA::Long n12 = IDsOfNodes[2];
 157     elem = GetMeshDS()->AddEdge(GetMeshDS()->FindNode(n1),
 158                                 GetMeshDS()->FindNode(n2),
 159                                 GetMeshDS()->FindNode(n12));
 160     // Update Python script
 161     TPythonDump() << "edgeID = " << this << ".AddEdge([ "
 162                   <<n1<<", "<<n2<<", "<<n12<<" ])";
 163   }
 164
 165   if(elem)
 166     return elem->GetID();
 167
 168   return 0;
 169 }
 170
 171 //=============================================================================
 172 /*!
 173  *
 174  */
 175 //=============================================================================
 176
 177 CORBA::Long SMESH_MeshEditor_i::AddNode(CORBA::Double x,
 178                                         CORBA::Double y, CORBA::Double z)
 179 {
 180   myLastCreatedElems = new SMESH::long_array();
 181   myLastCreatedNodes = new SMESH::long_array();
 182
 183   const SMDS_MeshNode* N = GetMeshDS()->AddNode(x, y, z);
 184
 185   // Update Python script
 186   TPythonDump() << "nodeID = " << this << ".AddNode( "
 187                 << x << ", " << y << ", " << z << " )";
 188
 189   return N->GetID();
 190 }
 191
 192 //=============================================================================
 193 /*!
 194  *  AddFace
 195  */
 196 //=============================================================================
 197
 198 CORBA::Long SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes)
 199 {
 200   myLastCreatedElems = new SMESH::long_array();
 201   myLastCreatedNodes = new SMESH::long_array();
 202
 203   int NbNodes = IDsOfNodes.length();
 204   if (NbNodes < 3)
 205   {
 206     return false;
 207   }
 208
 209   std::vector<const SMDS_MeshNode*> nodes (NbNodes);
 210   for (int i = 0; i < NbNodes; i++)
 211     nodes[i] = GetMeshDS()->FindNode(IDsOfNodes[i]);
 212
 213   SMDS_MeshElement* elem = 0;
 214   if (NbNodes == 3) {
 215     elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2]);
 216   }
 217   else if (NbNodes == 4) {
 218     elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3]);
 219   }
 220   else if (NbNodes == 6) {
 221     elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
 222                                 nodes[4], nodes[5]);
 223   }
 224   else if (NbNodes == 8) {
 225     elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
 226                                 nodes[4], nodes[5], nodes[6], nodes[7]);
 227   }
 228
 229   // Update Python script
 230   TPythonDump() << "faceID = " << this << ".AddFace( " << IDsOfNodes << " )";
 231
 232   if(elem)
 233     return elem->GetID();
 234
 235   return 0;
 236 }
 237
 238 //=============================================================================
 239 /*!
 240  *  AddPolygonalFace
 241  */
 242 //=============================================================================
 243 CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace
 244                                    (const SMESH::long_array & IDsOfNodes)
 245 {
 246   myLastCreatedElems = new SMESH::long_array();
 247   myLastCreatedNodes = new SMESH::long_array();
 248
 249   int NbNodes = IDsOfNodes.length();
 250   std::vector<const SMDS_MeshNode*> nodes (NbNodes);
 251   for (int i = 0; i < NbNodes; i++)
 252     nodes[i] = GetMeshDS()->FindNode(IDsOfNodes[i]);
 253
 254   const SMDS_MeshElement* elem = GetMeshDS()->AddPolygonalFace(nodes);
 255
 256   // Update Python script
 257   TPythonDump() <<"faceID = "<<this<<".AddPolygonalFace( "<<IDsOfNodes<<" )";
 258 #ifdef _DEBUG_
 259   TPythonDump() << "print 'AddPolygonalFace: ', faceID";
 260 #endif
 261
 262   if(elem)
 263     return elem->GetID();
 264
 265   return 0;
 266 }
 267
 268 //=============================================================================
 269 /*!
 270  *
 271  */
 272 //=============================================================================
 273
 274 CORBA::Long SMESH_MeshEditor_i::AddVolume(const SMESH::long_array & IDsOfNodes)
 275 {
 276   myLastCreatedElems = new SMESH::long_array();
 277   myLastCreatedNodes = new SMESH::long_array();
 278
 279   int NbNodes = IDsOfNodes.length();
 280   vector< const SMDS_MeshNode*> n(NbNodes);
 281   for(int i=0;i<NbNodes;i++)
 282     n[i]=GetMeshDS()->FindNode(IDsOfNodes[i]);
 283
 284   SMDS_MeshElement* elem = 0;
 285   switch(NbNodes)
 286   {
 287   case 4 :elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3]); break;
 288   case 5 :elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4]); break;
 289   case 6 :elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5]); break;
 290   case 8 :elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7]); break;
 291   case 10:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],
 292                                         n[6],n[7],n[8],n[9]);
 293     break;
 294   case 13:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],
 295                                         n[7],n[8],n[9],n[10],n[11],n[12]);
 296     break;
 297   case 15:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],n[8],
 298                                         n[9],n[10],n[11],n[12],n[13],n[14]);
 299     break;
 300   case 20:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],
 301                                         n[8],n[9],n[10],n[11],n[12],n[13],n[14],
 302                                         n[15],n[16],n[17],n[18],n[19]);
 303     break;
 304   }
 305
 306   // Update Python script
 307   TPythonDump() << "volID = " << this << ".AddVolume( " << IDsOfNodes << " )";
 308 #ifdef _DEBUG_
 309   TPythonDump() << "print 'AddVolume: ', volID";
 310 #endif
 311
 312   if(elem)
 313     return elem->GetID();
 314
 315   return 0;
 316 }
 317
 318 //=============================================================================
 319 /*!
 320  *  AddPolyhedralVolume
 321  */
 322 //=============================================================================
 323 CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolume
 324                                    (const SMESH::long_array & IDsOfNodes,
 325                                     const SMESH::long_array & Quantities)
 326 {
 327   myLastCreatedElems = new SMESH::long_array();
 328   myLastCreatedNodes = new SMESH::long_array();
 329
 330   int NbNodes = IDsOfNodes.length();
 331   std::vector<const SMDS_MeshNode*> n (NbNodes);
 332   for (int i = 0; i < NbNodes; i++)
 333     n[i] = GetMeshDS()->FindNode(IDsOfNodes[i]);
 334
 335   int NbFaces = Quantities.length();
 336   std::vector<int> q (NbFaces);
 337   for (int j = 0; j < NbFaces; j++)
 338     q[j] = Quantities[j];
 339
 340   const SMDS_MeshElement* elem = GetMeshDS()->AddPolyhedralVolume(n, q);
 341
 342   // Update Python script
 343   TPythonDump() << "volID = " << this << ".AddPolyhedralVolume( "
 344                 << IDsOfNodes << ", " << Quantities << " )";
 345 #ifdef _DEBUG_
 346   TPythonDump() << "print 'AddPolyhedralVolume: ', volID";
 347 #endif
 348
 349   if(elem)
 350     return elem->GetID();
 351
 352   return 0;
 353 }
 354
 355 //=============================================================================
 356 /*!
 357  *  AddPolyhedralVolumeByFaces
 358  */
 359 //=============================================================================
 360 CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolumeByFaces
 361                                    (const SMESH::long_array & IdsOfFaces)
 362 {
 363   myLastCreatedElems = new SMESH::long_array();
 364   myLastCreatedNodes = new SMESH::long_array();
 365
 366   int NbFaces = IdsOfFaces.length();
 367   std::vector<const SMDS_MeshNode*> poly_nodes;
 368   std::vector<int> quantities (NbFaces);
 369
 370   for (int i = 0; i < NbFaces; i++) {
 371     const SMDS_MeshElement* aFace = GetMeshDS()->FindElement(IdsOfFaces[i]);
 372     quantities[i] = aFace->NbNodes();
 373
 374     SMDS_ElemIteratorPtr It = aFace->nodesIterator();
 375     while (It->more()) {
 376       poly_nodes.push_back(static_cast<const SMDS_MeshNode *>(It->next()));
 377     }
 378   }
 379
 380   const SMDS_MeshElement* elem = GetMeshDS()->AddPolyhedralVolume(poly_nodes, quantities);
 381
 382   // Update Python script
 383   TPythonDump() << "volID = " << this << ".AddPolyhedralVolumeByFaces( "
 384                 << IdsOfFaces << " )";
 385 #ifdef _DEBUG_
 386   TPythonDump() << "print 'AddPolyhedralVolume: ', volID";
 387 #endif
 388
 389   if(elem)
 390     return elem->GetID();
 391
 392   return 0;
 393 }
 394
 395 //=============================================================================
 396 /*!
 397  *
 398  */
 399 //=============================================================================
 400
 401 CORBA::Boolean SMESH_MeshEditor_i::MoveNode(CORBA::Long   NodeID,
 402                                             CORBA::Double x,
 403                                             CORBA::Double y,
 404                                             CORBA::Double z)
 405 {
 406   myLastCreatedElems = new SMESH::long_array();
 407   myLastCreatedNodes = new SMESH::long_array();
 408
 409   const SMDS_MeshNode * node = GetMeshDS()->FindNode( NodeID );
 410   if ( !node )
 411     return false;
 412
 413   GetMeshDS()->MoveNode(node, x, y, z);
 414
 415   // Update Python script
 416   TPythonDump() << "isDone = " << this << ".MoveNode( "
 417                 << NodeID << ", " << x << ", " << y << ", " << z << " )";
 418
 419   return true;
 420 }
 421
 422 //=============================================================================
 423 /*!
 424  *
 425  */
 426 //=============================================================================
 427
 428 CORBA::Boolean SMESH_MeshEditor_i::InverseDiag(CORBA::Long NodeID1,
 429                                                CORBA::Long NodeID2)
 430 {
 431   myLastCreatedElems = new SMESH::long_array();
 432   myLastCreatedNodes = new SMESH::long_array();
 433
 434   const SMDS_MeshNode * n1 = GetMeshDS()->FindNode( NodeID1 );
 435   const SMDS_MeshNode * n2 = GetMeshDS()->FindNode( NodeID2 );
 436   if ( !n1 || !n2 )
 437     return false;
 438
 439   // Update Python script
 440   TPythonDump() << "isDone = " << this << ".InverseDiag( "
 441                 << NodeID1 << ", " << NodeID2 << " )";
 442
 443   ::SMESH_MeshEditor aMeshEditor( _myMesh );
 444   return aMeshEditor.InverseDiag ( n1, n2 );
 445 }
 446
 447 //=============================================================================
 448 /*!
 449  *
 450  */
 451 //=============================================================================
 452
 453 CORBA::Boolean SMESH_MeshEditor_i::DeleteDiag(CORBA::Long NodeID1,
 454                                               CORBA::Long NodeID2)
 455 {
 456   myLastCreatedElems = new SMESH::long_array();
 457   myLastCreatedNodes = new SMESH::long_array();
 458
 459   const SMDS_MeshNode * n1 = GetMeshDS()->FindNode( NodeID1 );
 460   const SMDS_MeshNode * n2 = GetMeshDS()->FindNode( NodeID2 );
 461   if ( !n1 || !n2 )
 462     return false;
 463
 464   // Update Python script
 465   TPythonDump() << "isDone = " << this << ".DeleteDiag( "
 466                 << NodeID1 << ", " << NodeID2 <<  " )";
 467
 468   ::SMESH_MeshEditor aMeshEditor( _myMesh );
 469
 470   bool stat = aMeshEditor.DeleteDiag ( n1, n2 );
 471
 472   UpdateLastResult(aMeshEditor);
 473
 474   return stat;
 475 }
 476
 477 //=============================================================================
 478 /*!
 479  *
 480  */
 481 //=============================================================================
 482
 483 CORBA::Boolean SMESH_MeshEditor_i::Reorient(const SMESH::long_array & IDsOfElements)
 484 {
 485   myLastCreatedElems = new SMESH::long_array();
 486   myLastCreatedNodes = new SMESH::long_array();
 487
 488   ::SMESH_MeshEditor anEditor( _myMesh );
 489   for (int i = 0; i < IDsOfElements.length(); i++)
 490   {
 491     CORBA::Long index = IDsOfElements[i];
 492     const SMDS_MeshElement * elem = GetMeshDS()->FindElement(index);
 493     if ( elem )
 494       anEditor.Reorient( elem );
 495   }
 496   // Update Python script
 497   TPythonDump() << "isDone = " << this << ".Reorient( " << IDsOfElements << " )";
 498
 499   return true;
 500 }
 501
 502
 503 //=============================================================================
 504 /*!
 505  *
 506  */
 507 //=============================================================================
 508
 509 CORBA::Boolean SMESH_MeshEditor_i::ReorientObject(SMESH::SMESH_IDSource_ptr theObject)
 510 {
 511   myLastCreatedElems = new SMESH::long_array();
 512   myLastCreatedNodes = new SMESH::long_array();
 513
 514   SMESH::long_array_var anElementsId = theObject->GetIDs();
 515   CORBA::Boolean isDone = Reorient(anElementsId);
 516
 517   // Clear python line, created by Reorient()
 518   SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
 519   aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
 520
 521   // Update Python script
 522   TPythonDump() << "isDone = " << this << ".ReorientObject( " << theObject << " )";
 523
 524   return isDone;
 525 }
 526
 527 namespace
 528 {
 529   //================================================================================
 530   /*!
 531    * \brief function for conversion long_array to TIDSortedElemSet
 532     * \param IDs - array of IDs
 533     * \param aMesh - mesh
 534     * \param aMap - collection to fill
 535     * \param aType - element type
 536    */
 537   //================================================================================
 538
 539   void ToMap(const SMESH::long_array & IDs,
 540              const SMESHDS_Mesh*       aMesh,
 541              TIDSortedElemSet&         aMap,
 542              const SMDSAbs_ElementType aType = SMDSAbs_All )
 543   {
 544     for (int i=0; i<IDs.length(); i++) {
 545       CORBA::Long ind = IDs[i];
 546       const SMDS_MeshElement * elem = aMesh->FindElement(ind);
 547       if ( elem && ( aType == SMDSAbs_All || elem->GetType() == aType ))
 548         aMap.insert( elem );
 549     }
 550   }
 551 }
 552
 553 //=============================================================================
 554 /*!
 555  *
 556  */
 557 //=============================================================================
 558 CORBA::Boolean SMESH_MeshEditor_i::TriToQuad (const SMESH::long_array &   IDsOfElements,
 559                                               SMESH::NumericalFunctor_ptr Criterion,
 560                                               CORBA::Double               MaxAngle)
 561 {
 562   myLastCreatedElems = new SMESH::long_array();
 563   myLastCreatedNodes = new SMESH::long_array();
 564
 565   SMESHDS_Mesh* aMesh = GetMeshDS();
 566   TIDSortedElemSet faces;
 567   ToMap(IDsOfElements, aMesh, faces, SMDSAbs_Face);
 568
 569   SMESH::NumericalFunctor_i* aNumericalFunctor =
 570     dynamic_cast<SMESH::NumericalFunctor_i*>( SMESH_Gen_i::GetServant( Criterion ).in() );
 571   SMESH::Controls::NumericalFunctorPtr aCrit;
 572   if ( !aNumericalFunctor )
 573     aCrit.reset( new SMESH::Controls::AspectRatio() );
 574   else
 575     aCrit = aNumericalFunctor->GetNumericalFunctor();
 576
 577   // Update Python script
 578   TPythonDump() << "isDone = " << this << ".TriToQuad( "
 579                 << IDsOfElements << ", " << aNumericalFunctor << ", " << MaxAngle << " )";
 580 #ifdef _DEBUG_
 581   TPythonDump() << "print 'TriToQuad: ', isDone";
 582 #endif
 583
 584   ::SMESH_MeshEditor anEditor( _myMesh );
 585
 586   bool stat = anEditor.TriToQuad( faces, aCrit, MaxAngle );
 587
 588   UpdateLastResult(anEditor);
 589
 590   return stat;
 591 }
 592
 593
 594 //=============================================================================
 595 /*!
 596  *
 597  */
 598 //=============================================================================
 599 CORBA::Boolean SMESH_MeshEditor_i::TriToQuadObject (SMESH::SMESH_IDSource_ptr   theObject,
 600                                                     SMESH::NumericalFunctor_ptr Criterion,
 601                                                     CORBA::Double               MaxAngle)
 602 {
 603   myLastCreatedElems = new SMESH::long_array();
 604   myLastCreatedNodes = new SMESH::long_array();
 605
 606   SMESH::long_array_var anElementsId = theObject->GetIDs();
 607   CORBA::Boolean isDone = TriToQuad(anElementsId, Criterion, MaxAngle);
 608
 609   // Clear python line(s), created by TriToQuad()
 610   SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
 611   aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
 612 #ifdef _DEBUG_
 613   aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
 614 #endif
 615
 616   SMESH::NumericalFunctor_i* aNumericalFunctor =
 617     SMESH::DownCast<SMESH::NumericalFunctor_i*>( Criterion );
 618
 619   // Update Python script
 620   TPythonDump() << "isDone = " << this << ".TriToQuadObject("
 621                 << theObject << ", " << aNumericalFunctor << ", " << MaxAngle << " )";
 622 #ifdef _DEBUG_
 623   TPythonDump() << "print 'TriToQuadObject: ', isDone";
 624 #endif
 625
 626   return isDone;
 627 }
 628
 629
 630 //=============================================================================
 631 /*!
 632  *
 633  */
 634 //=============================================================================
 635 CORBA::Boolean SMESH_MeshEditor_i::QuadToTri (const SMESH::long_array &   IDsOfElements,
 636                                               SMESH::NumericalFunctor_ptr Criterion)
 637 {
 638   myLastCreatedElems = new SMESH::long_array();
 639   myLastCreatedNodes = new SMESH::long_array();
 640
 641   SMESHDS_Mesh* aMesh = GetMeshDS();
 642   TIDSortedElemSet faces;
 643   ToMap(IDsOfElements, aMesh, faces, SMDSAbs_Face);
 644
 645   SMESH::NumericalFunctor_i* aNumericalFunctor =
 646     dynamic_cast<SMESH::NumericalFunctor_i*>( SMESH_Gen_i::GetServant( Criterion ).in() );
 647   SMESH::Controls::NumericalFunctorPtr aCrit;
 648   if ( !aNumericalFunctor )
 649     aCrit.reset( new SMESH::Controls::AspectRatio() );
 650   else
 651     aCrit = aNumericalFunctor->GetNumericalFunctor();
 652
 653
 654   // Update Python script
 655   TPythonDump() << "isDone = " << this << ".QuadToTri( " << IDsOfElements << ", " << aNumericalFunctor << " )";
 656 #ifdef _DEBUG_
 657   TPythonDump() << "print 'QuadToTri: ', isDone";
 658 #endif
 659
 660   ::SMESH_MeshEditor anEditor( _myMesh );
 661   CORBA::Boolean stat = anEditor.QuadToTri( faces, aCrit );
 662
 663   UpdateLastResult(anEditor);
 664
 665   return stat;
 666 }
 667
 668
 669 //=============================================================================
 670 /*!
 671  *
 672  */
 673 //=============================================================================
 674 CORBA::Boolean SMESH_MeshEditor_i::QuadToTriObject (SMESH::SMESH_IDSource_ptr   theObject,
 675                                                     SMESH::NumericalFunctor_ptr Criterion)
 676 {
 677   myLastCreatedElems = new SMESH::long_array();
 678   myLastCreatedNodes = new SMESH::long_array();
 679
 680   SMESH::long_array_var anElementsId = theObject->GetIDs();
 681   CORBA::Boolean isDone = QuadToTri(anElementsId, Criterion);
 682
 683   // Clear python line(s), created by QuadToTri()
 684   SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
 685   aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
 686 #ifdef _DEBUG_
 687   aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
 688 #endif
 689
 690   SMESH::NumericalFunctor_i* aNumericalFunctor =
 691     SMESH::DownCast<SMESH::NumericalFunctor_i*>( Criterion );
 692
 693   // Update Python script
 694   TPythonDump() << "isDone = " << this << ".QuadToTriObject( " << theObject << ", " << aNumericalFunctor << " )";
 695 #ifdef _DEBUG_
 696   TPythonDump() << "print 'QuadToTriObject: ', isDone";
 697 #endif
 698
 699   return isDone;
 700 }
 701
 702
 703 //=============================================================================
 704 /*!
 705  *
 706  */
 707 //=============================================================================
 708 CORBA::Boolean SMESH_MeshEditor_i::SplitQuad (const SMESH::long_array & IDsOfElements,
 709                                               CORBA::Boolean            Diag13)
 710 {
 711   myLastCreatedElems = new SMESH::long_array();
 712   myLastCreatedNodes = new SMESH::long_array();
 713
 714   SMESHDS_Mesh* aMesh = GetMeshDS();
 715   TIDSortedElemSet faces;
 716   ToMap(IDsOfElements, aMesh, faces, SMDSAbs_Face);
 717
 718   // Update Python script
 719   TPythonDump() << "isDone = " << this << ".SplitQuad( "
 720                 << IDsOfElements << ", " << Diag13 << " )";
 721 #ifdef _DEBUG_
 722   TPythonDump() << "print 'SplitQuad: ', isDone";
 723 #endif
 724
 725   ::SMESH_MeshEditor anEditor( _myMesh );
 726   CORBA::Boolean stat = anEditor.QuadToTri( faces, Diag13 );
 727
 728   UpdateLastResult(anEditor);
 729
 730   return stat;
 731 }
 732
 733
 734 //=============================================================================
 735 /*!
 736  *
 737  */
 738 //=============================================================================
 739 CORBA::Boolean SMESH_MeshEditor_i::SplitQuadObject (SMESH::SMESH_IDSource_ptr theObject,
 740                                                     CORBA::Boolean            Diag13)
 741 {
 742   myLastCreatedElems = new SMESH::long_array();
 743   myLastCreatedNodes = new SMESH::long_array();
 744
 745   SMESH::long_array_var anElementsId = theObject->GetIDs();
 746   CORBA::Boolean isDone = SplitQuad(anElementsId, Diag13);
 747
 748   // Clear python line(s), created by SplitQuad()
 749   SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
 750   aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
 751 #ifdef _DEBUG_
 752   aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
 753 #endif
 754
 755   // Update Python script
 756   TPythonDump() << "isDone = " << this << ".SplitQuadObject( "
 757                 << theObject << ", " << Diag13 << " )";
 758 #ifdef _DEBUG_
 759   TPythonDump() << "print 'SplitQuadObject: ', isDone";
 760 #endif
 761
 762   return isDone;
 763 }
 764
 765
 766 //=============================================================================
 767 /*!
 768  *  BestSplit
 769  */
 770 //=============================================================================
 771 CORBA::Long SMESH_MeshEditor_i::BestSplit (CORBA::Long                 IDOfQuad,
 772                                            SMESH::NumericalFunctor_ptr Criterion)
 773 {
 774   const SMDS_MeshElement* quad = GetMeshDS()->FindElement(IDOfQuad);
 775   if (quad && quad->GetType() == SMDSAbs_Face && quad->NbNodes() == 4)
 776   {
 777     SMESH::NumericalFunctor_i* aNumericalFunctor =
 778       dynamic_cast<SMESH::NumericalFunctor_i*>(SMESH_Gen_i::GetServant(Criterion).in());
 779     SMESH::Controls::NumericalFunctorPtr aCrit;
 780     if (aNumericalFunctor)
 781       aCrit = aNumericalFunctor->GetNumericalFunctor();
 782     else
 783       aCrit.reset(new SMESH::Controls::AspectRatio());
 784
 785     ::SMESH_MeshEditor anEditor (_myMesh);
 786     return anEditor.BestSplit(quad, aCrit);
 787   }
 788   return -1;
 789 }
 790
 791
 792 //=======================================================================
 793 //function : Smooth
 794 //purpose  :
 795 //=======================================================================
 796
 797 CORBA::Boolean
 798   SMESH_MeshEditor_i::Smooth(const SMESH::long_array &              IDsOfElements,
 799                              const SMESH::long_array &              IDsOfFixedNodes,
 800                              CORBA::Long                            MaxNbOfIterations,
 801                              CORBA::Double                          MaxAspectRatio,
 802                              SMESH::SMESH_MeshEditor::Smooth_Method Method)
 803 {
 804   return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
 805                 MaxAspectRatio, Method, false );
 806 }
 807
 808
 809 //=======================================================================
 810 //function : SmoothParametric
 811 //purpose  :
 812 //=======================================================================
 813
 814 CORBA::Boolean
 815   SMESH_MeshEditor_i::SmoothParametric(const SMESH::long_array &              IDsOfElements,
 816                                        const SMESH::long_array &              IDsOfFixedNodes,
 817                                        CORBA::Long                            MaxNbOfIterations,
 818                                        CORBA::Double                          MaxAspectRatio,
 819                                        SMESH::SMESH_MeshEditor::Smooth_Method Method)
 820 {
 821   return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
 822                 MaxAspectRatio, Method, true );
 823 }
 824
 825
 826 //=======================================================================
 827 //function : SmoothObject
 828 //purpose  :
 829 //=======================================================================
 830
 831 CORBA::Boolean
 832   SMESH_MeshEditor_i::SmoothObject(SMESH::SMESH_IDSource_ptr              theObject,
 833                                    const SMESH::long_array &              IDsOfFixedNodes,
 834                                    CORBA::Long                            MaxNbOfIterations,
 835                                    CORBA::Double                          MaxAspectRatio,
 836                                    SMESH::SMESH_MeshEditor::Smooth_Method Method)
 837 {
 838   return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
 839                        MaxAspectRatio, Method, false);
 840 }
 841
 842
 843 //=======================================================================
 844 //function : SmoothParametricObject
 845 //purpose  :
 846 //=======================================================================
 847
 848 CORBA::Boolean
 849   SMESH_MeshEditor_i::SmoothParametricObject(SMESH::SMESH_IDSource_ptr              theObject,
 850                                    const SMESH::long_array &              IDsOfFixedNodes,
 851                                    CORBA::Long                            MaxNbOfIterations,
 852                                    CORBA::Double                          MaxAspectRatio,
 853                                    SMESH::SMESH_MeshEditor::Smooth_Method Method)
 854 {
 855   return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
 856                        MaxAspectRatio, Method, true);
 857 }
 858
 859
 860 //=============================================================================
 861 /*!
 862  *
 863  */
 864 //=============================================================================
 865
 866 CORBA::Boolean
 867   SMESH_MeshEditor_i::smooth(const SMESH::long_array &              IDsOfElements,
 868                              const SMESH::long_array &              IDsOfFixedNodes,
 869                              CORBA::Long                            MaxNbOfIterations,
 870                              CORBA::Double                          MaxAspectRatio,
 871                              SMESH::SMESH_MeshEditor::Smooth_Method Method,
 872                              bool                                   IsParametric)
 873 {
 874   myLastCreatedElems = new SMESH::long_array();
 875   myLastCreatedNodes = new SMESH::long_array();
 876
 877   SMESHDS_Mesh* aMesh = GetMeshDS();
 878
 879   TIDSortedElemSet elements;
 880   ToMap(IDsOfElements, aMesh, elements, SMDSAbs_Face);
 881
 882   set<const SMDS_MeshNode*> fixedNodes;
 883   for (int i = 0; i < IDsOfFixedNodes.length(); i++) {
 884     CORBA::Long index = IDsOfFixedNodes[i];
 885     const SMDS_MeshNode * node = aMesh->FindNode(index);
 886     if ( node )
 887       fixedNodes.insert( node );
 888   }
 889   ::SMESH_MeshEditor::SmoothMethod method = ::SMESH_MeshEditor::LAPLACIAN;
 890   if ( Method != SMESH::SMESH_MeshEditor::LAPLACIAN_SMOOTH )
 891     method = ::SMESH_MeshEditor::CENTROIDAL;
 892
 893   ::SMESH_MeshEditor anEditor( _myMesh );
 894   anEditor.Smooth(elements, fixedNodes, method,
 895                   MaxNbOfIterations, MaxAspectRatio, IsParametric );
 896
 897   UpdateLastResult(anEditor);
 898
 899   // Update Python script
 900   TPythonDump() << "isDone = " << this << "."
 901                 << (IsParametric ? "SmoothParametric( " : "Smooth( ")
 902                 << IDsOfElements << ", "     << IDsOfFixedNodes << ", "
 903                 << MaxNbOfIterations << ", " << MaxAspectRatio << ", "
 904                 << "SMESH.SMESH_MeshEditor."
 905                 << ( Method == SMESH::SMESH_MeshEditor::CENTROIDAL_SMOOTH ?
 906                      "CENTROIDAL_SMOOTH )" : "LAPLACIAN_SMOOTH )");
 907 #ifdef _DEBUG_
 908   TPythonDump() << "print 'Smooth: ', isDone";
 909 #endif
 910
 911   return true;
 912 }
 913
 914
 915 //=============================================================================
 916 /*!
 917  *
 918  */
 919 //=============================================================================
 920
 921 CORBA::Boolean
 922 SMESH_MeshEditor_i::smoothObject(SMESH::SMESH_IDSource_ptr              theObject,
 923                                  const SMESH::long_array &              IDsOfFixedNodes,
 924                                  CORBA::Long                            MaxNbOfIterations,
 925                                  CORBA::Double                          MaxAspectRatio,
 926                                  SMESH::SMESH_MeshEditor::Smooth_Method Method,
 927                                  bool                                   IsParametric)
 928 {
 929   myLastCreatedElems = new SMESH::long_array();
 930   myLastCreatedNodes = new SMESH::long_array();
 931
 932   SMESH::long_array_var anElementsId = theObject->GetIDs();
 933   CORBA::Boolean isDone = smooth (anElementsId, IDsOfFixedNodes, MaxNbOfIterations,
 934                                   MaxAspectRatio, Method, IsParametric);
 935
 936   // Clear python line(s), created by Smooth()
 937   SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
 938   aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
 939 #ifdef _DEBUG_
 940   aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
 941 #endif
 942
 943   // Update Python script
 944   TPythonDump() << "isDone = " << this << "."
 945                 << (IsParametric ? "SmoothParametricObject( " : "SmoothObject( ")
 946                 << theObject << ", " << IDsOfFixedNodes << ", "
 947                 << MaxNbOfIterations << ", " << MaxAspectRatio << ", "
 948                 << "SMESH.SMESH_MeshEditor."
 949                 << ( Method == SMESH::SMESH_MeshEditor::CENTROIDAL_SMOOTH ?
 950                      "CENTROIDAL_SMOOTH )" : "LAPLACIAN_SMOOTH )");
 951 #ifdef _DEBUG_
 952   TPythonDump() << "print 'SmoothObject: ', isDone";
 953 #endif
 954
 955   return isDone;
 956 }
 957
 958
 959 //=============================================================================
 960 /*!
 961  *
 962  */
 963 //=============================================================================
 964
 965 void SMESH_MeshEditor_i::RenumberNodes()
 966 {
 967   // Update Python script
 968   TPythonDump() << this << ".RenumberNodes()";
 969
 970   GetMeshDS()->Renumber( true );
 971 }
 972
 973
 974 //=============================================================================
 975 /*!
 976  *
 977  */
 978 //=============================================================================
 979
 980 void SMESH_MeshEditor_i::RenumberElements()
 981 {
 982   // Update Python script
 983   TPythonDump() << this << ".RenumberElements()";
 984
 985   GetMeshDS()->Renumber( false );
 986 }
 987
 988
 989 //=======================================================================
 990 //function : RotationSweep
 991 //purpose  :
 992 //=======================================================================
 993
 994 void SMESH_MeshEditor_i::RotationSweep(const SMESH::long_array & theIDsOfElements,
 995                                        const SMESH::AxisStruct & theAxis,
 996                                        CORBA::Double             theAngleInRadians,
 997                                        CORBA::Long               theNbOfSteps,
 998                                        CORBA::Double             theTolerance)
 999 {
1000   myLastCreatedElems = new SMESH::long_array();
1001   myLastCreatedNodes = new SMESH::long_array();
1002
1003   SMESHDS_Mesh* aMesh = GetMeshDS();
1004
1005   TIDSortedElemSet elements;
1006   ToMap(theIDsOfElements, aMesh, elements);
1007
1008   gp_Ax1 Ax1 (gp_Pnt( theAxis.x, theAxis.y, theAxis.z ),
1009               gp_Vec( theAxis.vx, theAxis.vy, theAxis.vz ));
1010
1011   ::SMESH_MeshEditor anEditor( _myMesh );
1012   anEditor.RotationSweep (elements, Ax1, theAngleInRadians,
1013                           theNbOfSteps, theTolerance);
1014
1015   UpdateLastResult(anEditor);
1016
1017   // Update Python script
1018   TPythonDump() << "axis = " << theAxis;
1019   TPythonDump() << this << ".RotationSweep( "
1020                 << theIDsOfElements
1021                 << ", axis, "
1022                 << theAngleInRadians << ", "
1023                 << theNbOfSteps << ", "
1024                 << theTolerance << " )";
1025 }
1026
1027 //=======================================================================
1028 //function : RotationSweepObject
1029 //purpose  :
1030 //=======================================================================
1031
1032 void SMESH_MeshEditor_i::RotationSweepObject(SMESH::SMESH_IDSource_ptr theObject,
1033                                              const SMESH::AxisStruct & theAxis,
1034                                              CORBA::Double             theAngleInRadians,
1035                                              CORBA::Long               theNbOfSteps,
1036                                              CORBA::Double             theTolerance)
1037 {
1038   myLastCreatedElems = new SMESH::long_array();
1039   myLastCreatedNodes = new SMESH::long_array();
1040
1041   SMESH::long_array_var anElementsId = theObject->GetIDs();
1042   RotationSweep(anElementsId, theAxis, theAngleInRadians, theNbOfSteps, theTolerance);
1043
1044   // Clear python line, created by RotationSweep()
1045   SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
1046   aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
1047
1048   // Update Python script
1049   TPythonDump() << this << ".RotationSweepObject( "
1050                 << theObject
1051                 << ", axis, "
1052                 << theAngleInRadians << ", "
1053                 << theNbOfSteps << ", "
1054                 << theTolerance << " )";
1055 }
1056
1057 //=======================================================================
1058 //function : ExtrusionSweep
1059 //purpose  :
1060 //=======================================================================
1061
1062 void SMESH_MeshEditor_i::ExtrusionSweep(const SMESH::long_array & theIDsOfElements,
1063                                         const SMESH::DirStruct &  theStepVector,
1064                                         CORBA::Long               theNbOfSteps)
1065 {
1066   myLastCreatedElems = new SMESH::long_array();
1067   myLastCreatedNodes = new SMESH::long_array();
1068
1069 #ifdef NO_CAS_CATCH
1070   try {
1071     OCC_CATCH_SIGNALS;
1072 #else
1073   CASCatch_TRY {
1074 #endif
1075     SMESHDS_Mesh* aMesh = GetMeshDS();
1076
1077     TIDSortedElemSet elements;
1078     ToMap(theIDsOfElements, aMesh, elements);
1079
1080     const SMESH::PointStruct * P = &theStepVector.PS;
1081     gp_Vec stepVec( P->x, P->y, P->z );
1082
1083     TElemOfElemListMap aHystory;
1084     ::SMESH_MeshEditor anEditor( _myMesh );
1085     anEditor.ExtrusionSweep (elements, stepVec, theNbOfSteps, aHystory);
1086
1087     UpdateLastResult(anEditor);
1088
1089     // Update Python script
1090     TPythonDump() << "stepVector = " << theStepVector;
1091     TPythonDump() << this << ".ExtrusionSweep( "
1092                   << theIDsOfElements << ", stepVector, " << theNbOfSteps << " )";
1093
1094 #ifdef NO_CAS_CATCH
1095   } catch(Standard_Failure) {
1096 #else
1097   } CASCatch_CATCH(Standard_Failure) {
1098 #endif
1099     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1100     INFOS( "SMESH_MeshEditor_i::ExtrusionSweep fails - "<< aFail->GetMessageString() );
1101   }
1102 }
1103
1104
1105 //=======================================================================
1106 //function : ExtrusionSweepObject
1107 //purpose  :
1108 //=======================================================================
1109
1110 void SMESH_MeshEditor_i::ExtrusionSweepObject(SMESH::SMESH_IDSource_ptr theObject,
1111                                               const SMESH::DirStruct &  theStepVector,
1112                                               CORBA::Long               theNbOfSteps)
1113 {
1114   myLastCreatedElems = new SMESH::long_array();
1115   myLastCreatedNodes = new SMESH::long_array();
1116
1117   SMESH::long_array_var anElementsId = theObject->GetIDs();
1118   ExtrusionSweep(anElementsId, theStepVector, theNbOfSteps);
1119
1120   // Clear python line, created by ExtrusionSweep()
1121   SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
1122   aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
1123
1124   // Update Python script
1125   TPythonDump() << this << ".ExtrusionSweepObject( "
1126                 << theObject << ", stepVector, " << theNbOfSteps << " )";
1127 }
1128
1129 //=======================================================================
1130 //function : ExtrusionSweepObject1D
1131 //purpose  :
1132 //=======================================================================
1133
1134 void SMESH_MeshEditor_i::ExtrusionSweepObject1D(SMESH::SMESH_IDSource_ptr theObject,
1135                                                 const SMESH::DirStruct &  theStepVector,
1136                                                 CORBA::Long               theNbOfSteps)
1137 {
1138   myLastCreatedElems = new SMESH::long_array();
1139   myLastCreatedNodes = new SMESH::long_array();
1140
1141   SMESHDS_Mesh* aMesh = GetMeshDS();
1142
1143   SMESH::long_array_var allElementsId = theObject->GetIDs();
1144
1145   TIDSortedElemSet elements;
1146   ToMap(allElementsId, aMesh, elements);
1147
1148   const SMESH::PointStruct * P = &theStepVector.PS;
1149   gp_Vec stepVec( P->x, P->y, P->z );
1150
1151   ::SMESH_MeshEditor anEditor( _myMesh );
1152   //anEditor.ExtrusionSweep (elements, stepVec, theNbOfSteps);
1153   TElemOfElemListMap aHystory;
1154   anEditor.ExtrusionSweep (elements, stepVec, theNbOfSteps, aHystory);
1155
1156   UpdateLastResult(anEditor);
1157
1158   // Update Python script
1159   TPythonDump() << "stepVector = " << theStepVector;
1160   TPythonDump() << this << ".ExtrusionSweepObject1D( "
1161                 << theObject << ", stepVector, " << theNbOfSteps << " )";
1162 }
1163
1164 //=======================================================================
1165 //function : ExtrusionSweepObject2D
1166 //purpose  :
1167 //=======================================================================
1168
1169 void SMESH_MeshEditor_i::ExtrusionSweepObject2D(SMESH::SMESH_IDSource_ptr theObject,
1170                                                 const SMESH::DirStruct &  theStepVector,
1171                                                 CORBA::Long               theNbOfSteps)
1172 {
1173   myLastCreatedElems = new SMESH::long_array();
1174   myLastCreatedNodes = new SMESH::long_array();
1175
1176   SMESHDS_Mesh* aMesh = GetMeshDS();
1177
1178   SMESH::long_array_var allElementsId = theObject->GetIDs();
1179
1180   TIDSortedElemSet elements;
1181   ToMap(allElementsId, aMesh, elements);
1182
1183   const SMESH::PointStruct * P = &theStepVector.PS;
1184   gp_Vec stepVec( P->x, P->y, P->z );
1185
1186   ::SMESH_MeshEditor anEditor( _myMesh );
1187   //anEditor.ExtrusionSweep (elements, stepVec, theNbOfSteps);
1188   TElemOfElemListMap aHystory;
1189   anEditor.ExtrusionSweep (elements, stepVec, theNbOfSteps, aHystory);
1190
1191   UpdateLastResult(anEditor);
1192
1193   // Update Python script
1194   TPythonDump() << "stepVector = " << theStepVector;
1195   TPythonDump() << this << ".ExtrusionSweepObject2D( "
1196                 << theObject << ", stepVector, " << theNbOfSteps << " )";
1197 }
1198
1199
1200 //=======================================================================
1201 //function : AdvancedExtrusion
1202 //purpose  :
1203 //=======================================================================
1204
1205 void SMESH_MeshEditor_i::AdvancedExtrusion(const SMESH::long_array & theIDsOfElements,
1206                                            const SMESH::DirStruct &  theStepVector,
1207                                            CORBA::Long               theNbOfSteps,
1208                                            CORBA::Long               theExtrFlags,
1209                                            CORBA::Double             theSewTolerance)
1210 {
1211   myLastCreatedElems = new SMESH::long_array();
1212   myLastCreatedNodes = new SMESH::long_array();
1213
1214   SMESHDS_Mesh* aMesh = GetMeshDS();
1215
1216   TIDSortedElemSet elements;
1217   ToMap(theIDsOfElements, aMesh, elements);
1218
1219   const SMESH::PointStruct * P = &theStepVector.PS;
1220   gp_Vec stepVec( P->x, P->y, P->z );
1221
1222   ::SMESH_MeshEditor anEditor( _myMesh );
1223   TElemOfElemListMap aHystory;
1224   anEditor.ExtrusionSweep (elements, stepVec, theNbOfSteps, aHystory,
1225                            theExtrFlags, theSewTolerance);
1226
1227   UpdateLastResult(anEditor);
1228
1229   // Update Python script
1230   TPythonDump() << "stepVector = " << theStepVector;
1231   TPythonDump() << this << ".AdvancedExtrusion("
1232                 << theIDsOfElements
1233                 << ", stepVector, "
1234                 << theNbOfSteps << ","
1235                 << theExtrFlags << ", "
1236                 << theSewTolerance <<  " )";
1237 }
1238
1239
1240 #define RETCASE(enm) case ::SMESH_MeshEditor::enm: return SMESH::SMESH_MeshEditor::enm;
1241
1242 static SMESH::SMESH_MeshEditor::Extrusion_Error convExtrError( const::SMESH_MeshEditor::Extrusion_Error e )
1243 {
1244   switch ( e ) {
1245   RETCASE( EXTR_OK );
1246   RETCASE( EXTR_NO_ELEMENTS );
1247   RETCASE( EXTR_PATH_NOT_EDGE );
1248   RETCASE( EXTR_BAD_PATH_SHAPE );
1249   RETCASE( EXTR_BAD_STARTING_NODE );
1250   RETCASE( EXTR_BAD_ANGLES_NUMBER );
1251   RETCASE( EXTR_CANT_GET_TANGENT );
1252   }
1253   return SMESH::SMESH_MeshEditor::EXTR_OK;
1254 }
1255
1256 //=======================================================================
1257 //function : ExtrusionAlongPath
1258 //purpose  :
1259 //=======================================================================
1260
1261 SMESH::SMESH_MeshEditor::Extrusion_Error
1262   SMESH_MeshEditor_i::ExtrusionAlongPath(const SMESH::long_array &   theIDsOfElements,
1263                                          SMESH::SMESH_Mesh_ptr       thePathMesh,
1264                                          GEOM::GEOM_Object_ptr       thePathShape,
1265                                          CORBA::Long                 theNodeStart,
1266                                          CORBA::Boolean              theHasAngles,
1267                                          const SMESH::double_array & theAngles,
1268                                          CORBA::Boolean              theHasRefPoint,
1269                                          const SMESH::PointStruct &  theRefPoint)
1270 {
1271   myLastCreatedElems = new SMESH::long_array();
1272   myLastCreatedNodes = new SMESH::long_array();
1273
1274   SMESHDS_Mesh*  aMesh = GetMeshDS();
1275
1276   if ( thePathMesh->_is_nil() || thePathShape->_is_nil() )
1277     return SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
1278
1279   SMESH_Mesh_i* aMeshImp = dynamic_cast<SMESH_Mesh_i*>( SMESH_Gen_i::GetServant( thePathMesh ).in() );
1280   TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( thePathShape );
1281   SMESH_subMesh* aSubMesh = aMeshImp->GetImpl().GetSubMesh( aShape );
1282
1283   if ( !aSubMesh || !aSubMesh->GetSubMeshDS())
1284     return SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
1285
1286   SMDS_MeshNode* nodeStart = (SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(theNodeStart);
1287   if ( !nodeStart )
1288     return SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE;
1289
1290   TIDSortedElemSet elements;
1291   ToMap(theIDsOfElements, aMesh, elements);
1292
1293   list<double> angles;
1294   for (int i = 0; i < theAngles.length(); i++) {
1295     angles.push_back( theAngles[i] );
1296   }
1297
1298   gp_Pnt refPnt( theRefPoint.x, theRefPoint.y, theRefPoint.z );
1299
1300   // Update Python script
1301   TPythonDump() << "refPoint = SMESH.PointStruct( "
1302                 << refPnt.X() << ", "
1303                 << refPnt.Y() << ", "
1304                 << refPnt.Z() << " )";
1305   TPythonDump() << "error = " << this << ".ExtrusionAlongPath( "
1306                 << theIDsOfElements << ", "
1307                 << thePathMesh  <<  ", "
1308                 << thePathShape <<  ", "
1309                 << theNodeStart << ", "
1310                 << theHasAngles << ", "
1311                 << theAngles << ", "
1312                 << theHasRefPoint << ", refPoint )";
1313
1314   ::SMESH_MeshEditor anEditor( _myMesh );
1315   SMESH::SMESH_MeshEditor::Extrusion_Error error =
1316     convExtrError( anEditor.ExtrusionAlongTrack( elements, aSubMesh, nodeStart,
1317                                                 theHasAngles, angles,
1318                                                 theHasRefPoint, refPnt ) );
1319
1320   UpdateLastResult(anEditor);
1321
1322   return error;
1323 }
1324
1325 //=======================================================================
1326 //function : ExtrusionAlongPathObject
1327 //purpose  :
1328 //=======================================================================
1329
1330 SMESH::SMESH_MeshEditor::Extrusion_Error
1331 SMESH_MeshEditor_i::ExtrusionAlongPathObject(SMESH::SMESH_IDSource_ptr   theObject,
1332                                              SMESH::SMESH_Mesh_ptr       thePathMesh,
1333                                              GEOM::GEOM_Object_ptr       thePathShape,
1334                                              CORBA::Long                 theNodeStart,
1335                                              CORBA::Boolean              theHasAngles,
1336                                              const SMESH::double_array & theAngles,
1337                                              CORBA::Boolean              theHasRefPoint,
1338                                              const SMESH::PointStruct &  theRefPoint)
1339 {
1340   myLastCreatedElems = new SMESH::long_array();
1341   myLastCreatedNodes = new SMESH::long_array();
1342
1343   SMESH::long_array_var anElementsId = theObject->GetIDs();
1344   SMESH::SMESH_MeshEditor::Extrusion_Error error = ExtrusionAlongPath
1345     (anElementsId, thePathMesh, thePathShape, theNodeStart,
1346      theHasAngles, theAngles, theHasRefPoint, theRefPoint);
1347
1348   // Clear python line, created by ExtrusionAlongPath()
1349   SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
1350   aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
1351
1352   // Update Python script
1353   TPythonDump() << "error = " << this << ".ExtrusionAlongPathObject( "
1354                 << theObject    << ", "
1355                 << thePathMesh  << ", "
1356                 << thePathShape << ", "
1357                 << theNodeStart << ", "
1358                 << theHasAngles << ", "
1359                 << theAngles << ", "
1360                 << theHasRefPoint << ", refPoint )";
1361
1362   return error;
1363 }
1364
1365 //=======================================================================
1366 //function : Mirror
1367 //purpose  :
1368 //=======================================================================
1369
1370 void SMESH_MeshEditor_i::Mirror(const SMESH::long_array &           theIDsOfElements,
1371                                 const SMESH::AxisStruct &           theAxis,
1372                                 SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
1373                                 CORBA::Boolean                      theCopy)
1374 {
1375   myLastCreatedElems = new SMESH::long_array();
1376   myLastCreatedNodes = new SMESH::long_array();
1377
1378   SMESHDS_Mesh* aMesh = GetMeshDS();
1379
1380   TIDSortedElemSet elements;
1381   ToMap(theIDsOfElements, aMesh, elements);
1382
1383   gp_Pnt P ( theAxis.x, theAxis.y, theAxis.z );
1384   gp_Vec V ( theAxis.vx, theAxis.vy, theAxis.vz );
1385
1386   gp_Trsf aTrsf;
1387   TCollection_AsciiString typeStr;
1388   switch ( theMirrorType ) {
1389   case  SMESH::SMESH_MeshEditor::POINT:
1390     aTrsf.SetMirror( P );
1391     typeStr = "SMESH.SMESH_MeshEditor.POINT";
1392     break;
1393   case  SMESH::SMESH_MeshEditor::AXIS:
1394     aTrsf.SetMirror( gp_Ax1( P, V ));
1395     typeStr = "SMESH.SMESH_MeshEditor.AXIS";
1396     break;
1397   default:
1398     aTrsf.SetMirror( gp_Ax2( P, V ));
1399     typeStr = "SMESH.SMESH_MeshEditor.PLANE";
1400   }
1401
1402   // Update Python script
1403   TPythonDump() << this << ".Mirror( "
1404                 << theIDsOfElements << ", "
1405                 << theAxis           << ", "
1406                 << typeStr           << ", "
1407                 << theCopy           << " )";
1408
1409   ::SMESH_MeshEditor anEditor( _myMesh );
1410   anEditor.Transform (elements, aTrsf, theCopy);
1411
1412   if(theCopy) {
1413     UpdateLastResult(anEditor);
1414   }
1415 }
1416
1417
1418 //=======================================================================
1419 //function : MirrorObject
1420 //purpose  :
1421 //=======================================================================
1422
1423 void SMESH_MeshEditor_i::MirrorObject(SMESH::SMESH_IDSource_ptr           theObject,
1424                                       const SMESH::AxisStruct &           theAxis,
1425                                       SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
1426                                       CORBA::Boolean                      theCopy)
1427 {
1428   myLastCreatedElems = new SMESH::long_array();
1429   myLastCreatedNodes = new SMESH::long_array();
1430
1431   SMESH::long_array_var anElementsId = theObject->GetIDs();
1432   Mirror(anElementsId, theAxis, theMirrorType, theCopy);
1433
1434   // Clear python line, created by Mirror()
1435   SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
1436   aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
1437
1438   // Update Python script
1439   TCollection_AsciiString typeStr;
1440   switch ( theMirrorType ) {
1441   case  SMESH::SMESH_MeshEditor::POINT:
1442     typeStr = "SMESH.SMESH_MeshEditor.POINT";
1443     break;
1444   case  SMESH::SMESH_MeshEditor::AXIS:
1445     typeStr = "SMESH.SMESH_MeshEditor.AXIS";
1446     break;
1447   default:
1448     typeStr = "SMESH.SMESH_MeshEditor.PLANE";
1449   }
1450   TPythonDump() << "axis = " << theAxis;
1451   TPythonDump() << this << ".MirrorObject( "
1452                 << theObject << ", "
1453                 << "axis, "
1454                 << typeStr << ", "
1455                 << theCopy << " )";
1456 }
1457
1458 //=======================================================================
1459 //function : Translate
1460 //purpose  :
1461 //=======================================================================
1462
1463 void SMESH_MeshEditor_i::Translate(const SMESH::long_array & theIDsOfElements,
1464                                    const SMESH::DirStruct &  theVector,
1465                                    CORBA::Boolean            theCopy)
1466 {
1467   myLastCreatedElems = new SMESH::long_array();
1468   myLastCreatedNodes = new SMESH::long_array();
1469
1470   SMESHDS_Mesh* aMesh = GetMeshDS();
1471
1472   TIDSortedElemSet elements;
1473   ToMap(theIDsOfElements, aMesh, elements);
1474
1475   gp_Trsf aTrsf;
1476   const SMESH::PointStruct * P = &theVector.PS;
1477   aTrsf.SetTranslation( gp_Vec( P->x, P->y, P->z ));
1478
1479   ::SMESH_MeshEditor anEditor( _myMesh );
1480   anEditor.Transform (elements, aTrsf, theCopy);
1481
1482   if(theCopy) {
1483     UpdateLastResult(anEditor);
1484   }
1485
1486   // Update Python script
1487   TPythonDump() << "vector = " << theVector;
1488   TPythonDump() << this << ".Translate( "
1489                 << theIDsOfElements
1490                 << ", vector, "
1491                 << theCopy << " )";
1492 }
1493
1494 //=======================================================================
1495 //function : TranslateObject
1496 //purpose  :
1497 //=======================================================================
1498
1499 void SMESH_MeshEditor_i::TranslateObject(SMESH::SMESH_IDSource_ptr theObject,
1500                                          const SMESH::DirStruct &  theVector,
1501                                          CORBA::Boolean            theCopy)
1502 {
1503   myLastCreatedElems = new SMESH::long_array();
1504   myLastCreatedNodes = new SMESH::long_array();
1505
1506   SMESH::long_array_var anElementsId = theObject->GetIDs();
1507   Translate(anElementsId, theVector, theCopy);
1508
1509   // Clear python line, created by Translate()
1510   SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
1511   aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
1512
1513   // Update Python script
1514   TPythonDump() << this << ".TranslateObject( "
1515                 << theObject
1516                 << ", vector, "
1517                 << theCopy << " )";
1518 }
1519
1520 //=======================================================================
1521 //function : Rotate
1522 //purpose  :
1523 //=======================================================================
1524
1525 void SMESH_MeshEditor_i::Rotate(const SMESH::long_array & theIDsOfElements,
1526                                 const SMESH::AxisStruct & theAxis,
1527                                 CORBA::Double             theAngle,
1528                                 CORBA::Boolean            theCopy)
1529 {
1530   myLastCreatedElems = new SMESH::long_array();
1531   myLastCreatedNodes = new SMESH::long_array();
1532
1533   SMESHDS_Mesh* aMesh = GetMeshDS();
1534
1535   TIDSortedElemSet elements;
1536   ToMap(theIDsOfElements, aMesh, elements);
1537
1538   gp_Pnt P ( theAxis.x, theAxis.y, theAxis.z );
1539   gp_Vec V ( theAxis.vx, theAxis.vy, theAxis.vz );
1540
1541   gp_Trsf aTrsf;
1542   aTrsf.SetRotation( gp_Ax1( P, V ), theAngle);
1543
1544   ::SMESH_MeshEditor anEditor( _myMesh );
1545   anEditor.Transform (elements, aTrsf, theCopy);
1546
1547   if(theCopy) {
1548     UpdateLastResult(anEditor);
1549   }
1550
1551   // Update Python script
1552   TPythonDump() << "axis = " << theAxis;
1553   TPythonDump() << this << ".Rotate( "
1554                 << theIDsOfElements
1555                 << ", axis, "
1556                 << theAngle << ", "
1557                 << theCopy << " )";
1558 }
1559
1560 //=======================================================================
1561 //function : RotateObject
1562 //purpose  :
1563 //=======================================================================
1564
1565 void SMESH_MeshEditor_i::RotateObject(SMESH::SMESH_IDSource_ptr theObject,
1566                                       const SMESH::AxisStruct & theAxis,
1567                                       CORBA::Double             theAngle,
1568                                       CORBA::Boolean            theCopy)
1569 {
1570   myLastCreatedElems = new SMESH::long_array();
1571   myLastCreatedNodes = new SMESH::long_array();
1572
1573   SMESH::long_array_var anElementsId = theObject->GetIDs();
1574   Rotate(anElementsId, theAxis, theAngle, theCopy);
1575
1576   // Clear python line, created by Rotate()
1577   SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
1578   aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
1579
1580   // Update Python script
1581   TPythonDump() << this << ".RotateObject( "
1582                 << theObject
1583                 << ", axis, "
1584                 << theAngle << ", "
1585                 << theCopy << " )";
1586 }
1587
1588 //=======================================================================
1589 //function : FindCoincidentNodes
1590 //purpose  :
1591 //=======================================================================
1592
1593 void SMESH_MeshEditor_i::FindCoincidentNodes (CORBA::Double                  Tolerance,
1594                                               SMESH::array_of_long_array_out GroupsOfNodes)
1595 {
1596   myLastCreatedElems = new SMESH::long_array();
1597   myLastCreatedNodes = new SMESH::long_array();
1598
1599   ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
1600   ::SMESH_MeshEditor anEditor( _myMesh );
1601   set<const SMDS_MeshNode*> nodes; // no input nodes
1602   anEditor.FindCoincidentNodes( nodes, Tolerance, aListOfListOfNodes );
1603
1604   GroupsOfNodes = new SMESH::array_of_long_array;
1605   GroupsOfNodes->length( aListOfListOfNodes.size() );
1606   ::SMESH_MeshEditor::TListOfListOfNodes::iterator llIt = aListOfListOfNodes.begin();
1607   for ( CORBA::Long i = 0; llIt != aListOfListOfNodes.end(); llIt++, i++ ) {
1608     list< const SMDS_MeshNode* >& aListOfNodes = *llIt;
1609     list< const SMDS_MeshNode* >::iterator lIt = aListOfNodes.begin();;
1610     SMESH::long_array& aGroup = GroupsOfNodes[ i ];
1611     aGroup.length( aListOfNodes.size() );
1612     for ( int j = 0; lIt != aListOfNodes.end(); lIt++, j++ )
1613       aGroup[ j ] = (*lIt)->GetID();
1614   }
1615   // Update Python script
1616   TPythonDump() << "coincident_nodes = " << this << ".FindCoincidentNodes( "
1617                 << Tolerance << " )";
1618 }
1619
1620 //=======================================================================
1621 //function : MergeNodes
1622 //purpose  :
1623 //=======================================================================
1624
1625 void SMESH_MeshEditor_i::MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes)
1626 {
1627   myLastCreatedElems = new SMESH::long_array();
1628   myLastCreatedNodes = new SMESH::long_array();
1629
1630   SMESHDS_Mesh* aMesh = GetMeshDS();
1631
1632   TPythonDump aTPythonDump;
1633   aTPythonDump << this << ".MergeNodes([";
1634   ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
1635   for (int i = 0; i < GroupsOfNodes.length(); i++)
1636   {
1637     const SMESH::long_array& aNodeGroup = GroupsOfNodes[ i ];
1638     aListOfListOfNodes.push_back( list< const SMDS_MeshNode* >() );
1639     list< const SMDS_MeshNode* >& aListOfNodes = aListOfListOfNodes.back();
1640     for ( int j = 0; j < aNodeGroup.length(); j++ )
1641     {
1642       CORBA::Long index = aNodeGroup[ j ];
1643       const SMDS_MeshNode * node = aMesh->FindNode(index);
1644       if ( node )
1645         aListOfNodes.push_back( node );
1646     }
1647     if ( aListOfNodes.size() < 2 )
1648       aListOfListOfNodes.pop_back();
1649
1650     if ( i > 0 ) aTPythonDump << ", ";
1651     aTPythonDump << aNodeGroup;
1652   }
1653   ::SMESH_MeshEditor anEditor( _myMesh );
1654   anEditor.MergeNodes( aListOfListOfNodes );
1655
1656   // Update Python script
1657   aTPythonDump <<  "])";
1658 }
1659
1660 //=======================================================================
1661 //function : MergeEqualElements
1662 //purpose  :
1663 //=======================================================================
1664
1665 void SMESH_MeshEditor_i::MergeEqualElements()
1666 {
1667   myLastCreatedElems = new SMESH::long_array();
1668   myLastCreatedNodes = new SMESH::long_array();
1669
1670   ::SMESH_MeshEditor anEditor( _myMesh );
1671   anEditor.MergeEqualElements();
1672
1673   // Update Python script
1674   TPythonDump() << this << ".MergeEqualElements()";
1675 }
1676
1677 //=======================================================================
1678 //function : operator
1679 //purpose  :
1680 //=======================================================================
1681
1682 #define RETCASE(enm) case ::SMESH_MeshEditor::enm: return SMESH::SMESH_MeshEditor::enm;
1683
1684 static SMESH::SMESH_MeshEditor::Sew_Error convError( const::SMESH_MeshEditor::Sew_Error e )
1685 {
1686   switch ( e ) {
1687   RETCASE( SEW_OK );
1688   RETCASE( SEW_BORDER1_NOT_FOUND );
1689   RETCASE( SEW_BORDER2_NOT_FOUND );
1690   RETCASE( SEW_BOTH_BORDERS_NOT_FOUND );
1691   RETCASE( SEW_BAD_SIDE_NODES );
1692   RETCASE( SEW_VOLUMES_TO_SPLIT );
1693   RETCASE( SEW_DIFF_NB_OF_ELEMENTS );
1694   RETCASE( SEW_TOPO_DIFF_SETS_OF_ELEMENTS );
1695   RETCASE( SEW_BAD_SIDE1_NODES );
1696   RETCASE( SEW_BAD_SIDE2_NODES );
1697   }
1698   return SMESH::SMESH_MeshEditor::SEW_OK;
1699 }
1700
1701 //=======================================================================
1702 //function : SewFreeBorders
1703 //purpose  :
1704 //=======================================================================
1705
1706 SMESH::SMESH_MeshEditor::Sew_Error
1707   SMESH_MeshEditor_i::SewFreeBorders(CORBA::Long FirstNodeID1,
1708                                      CORBA::Long SecondNodeID1,
1709                                      CORBA::Long LastNodeID1,
1710                                      CORBA::Long FirstNodeID2,
1711                                      CORBA::Long SecondNodeID2,
1712                                      CORBA::Long LastNodeID2,
1713                                      CORBA::Boolean CreatePolygons,
1714                                      CORBA::Boolean CreatePolyedrs)
1715 {
1716   myLastCreatedElems = new SMESH::long_array();
1717   myLastCreatedNodes = new SMESH::long_array();
1718
1719   SMESHDS_Mesh* aMesh = GetMeshDS();
1720
1721   const SMDS_MeshNode* aBorderFirstNode  = aMesh->FindNode( FirstNodeID1  );
1722   const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeID1 );
1723   const SMDS_MeshNode* aBorderLastNode   = aMesh->FindNode( LastNodeID1   );
1724   const SMDS_MeshNode* aSide2FirstNode   = aMesh->FindNode( FirstNodeID2  );
1725   const SMDS_MeshNode* aSide2SecondNode  = aMesh->FindNode( SecondNodeID2 );
1726   const SMDS_MeshNode* aSide2ThirdNode   = aMesh->FindNode( LastNodeID2   );
1727
1728   if (!aBorderFirstNode ||
1729       !aBorderSecondNode||
1730       !aBorderLastNode)
1731     return SMESH::SMESH_MeshEditor::SEW_BORDER1_NOT_FOUND;
1732   if (!aSide2FirstNode  ||
1733       !aSide2SecondNode ||
1734       !aSide2ThirdNode)
1735     return SMESH::SMESH_MeshEditor::SEW_BORDER2_NOT_FOUND;
1736
1737   // Update Python script
1738   TPythonDump() << "error = " << this << ".SewFreeBorders( "
1739                 << FirstNodeID1  << ", "
1740                 << SecondNodeID1 << ", "
1741                 << LastNodeID1   << ", "
1742                 << FirstNodeID2  << ", "
1743                 << SecondNodeID2 << ", "
1744                 << LastNodeID2   << ", "
1745                 << CreatePolygons<< ", "
1746                 << CreatePolyedrs<< " )";
1747
1748   ::SMESH_MeshEditor anEditor( _myMesh );
1749   SMESH::SMESH_MeshEditor::Sew_Error error =
1750     convError( anEditor.SewFreeBorder (aBorderFirstNode,
1751                                        aBorderSecondNode,
1752                                        aBorderLastNode,
1753                                        aSide2FirstNode,
1754                                        aSide2SecondNode,
1755                                        aSide2ThirdNode,
1756                                        true,
1757                                        CreatePolygons,
1758                                        CreatePolyedrs) );
1759
1760   UpdateLastResult(anEditor);
1761
1762   return error;
1763 }
1764
1765
1766 //=======================================================================
1767 //function : SewConformFreeBorders
1768 //purpose  :
1769 //=======================================================================
1770
1771 SMESH::SMESH_MeshEditor::Sew_Error
1772 SMESH_MeshEditor_i::SewConformFreeBorders(CORBA::Long FirstNodeID1,
1773                                           CORBA::Long SecondNodeID1,
1774                                           CORBA::Long LastNodeID1,
1775                                           CORBA::Long FirstNodeID2,
1776                                           CORBA::Long SecondNodeID2)
1777 {
1778   myLastCreatedElems = new SMESH::long_array();
1779   myLastCreatedNodes = new SMESH::long_array();
1780
1781   SMESHDS_Mesh* aMesh = GetMeshDS();
1782
1783   const SMDS_MeshNode* aBorderFirstNode  = aMesh->FindNode( FirstNodeID1  );
1784   const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeID1 );
1785   const SMDS_MeshNode* aBorderLastNode   = aMesh->FindNode( LastNodeID1   );
1786   const SMDS_MeshNode* aSide2FirstNode   = aMesh->FindNode( FirstNodeID2  );
1787   const SMDS_MeshNode* aSide2SecondNode  = aMesh->FindNode( SecondNodeID2 );
1788   const SMDS_MeshNode* aSide2ThirdNode   = 0;
1789
1790   if (!aBorderFirstNode ||
1791       !aBorderSecondNode||
1792       !aBorderLastNode )
1793     return SMESH::SMESH_MeshEditor::SEW_BORDER1_NOT_FOUND;
1794   if (!aSide2FirstNode  ||
1795       !aSide2SecondNode)
1796     return SMESH::SMESH_MeshEditor::SEW_BORDER2_NOT_FOUND;
1797
1798   // Update Python script
1799   TPythonDump() << "error = " << this << ".SewConformFreeBorders( "
1800                 << FirstNodeID1  << ", "
1801                 << SecondNodeID1 << ", "
1802                 << LastNodeID1   << ", "
1803                 << FirstNodeID2  << ", "
1804                 << SecondNodeID2 << " )";
1805
1806   ::SMESH_MeshEditor anEditor( _myMesh );
1807   SMESH::SMESH_MeshEditor::Sew_Error error =
1808     convError( anEditor.SewFreeBorder (aBorderFirstNode,
1809                                        aBorderSecondNode,
1810                                        aBorderLastNode,
1811                                        aSide2FirstNode,
1812                                        aSide2SecondNode,
1813                                        aSide2ThirdNode,
1814                                        true,
1815                                        false, false) );
1816
1817   UpdateLastResult(anEditor);
1818
1819   return error;
1820 }
1821
1822
1823 //=======================================================================
1824 //function : SewBorderToSide
1825 //purpose  :
1826 //=======================================================================
1827
1828 SMESH::SMESH_MeshEditor::Sew_Error
1829 SMESH_MeshEditor_i::SewBorderToSide(CORBA::Long FirstNodeIDOnFreeBorder,
1830                                     CORBA::Long SecondNodeIDOnFreeBorder,
1831                                     CORBA::Long LastNodeIDOnFreeBorder,
1832                                     CORBA::Long FirstNodeIDOnSide,
1833                                     CORBA::Long LastNodeIDOnSide,
1834                                     CORBA::Boolean CreatePolygons,
1835                                     CORBA::Boolean CreatePolyedrs)
1836 {
1837   myLastCreatedElems = new SMESH::long_array();
1838   myLastCreatedNodes = new SMESH::long_array();
1839
1840   SMESHDS_Mesh* aMesh = GetMeshDS();
1841
1842   const SMDS_MeshNode* aBorderFirstNode  = aMesh->FindNode( FirstNodeIDOnFreeBorder  );
1843   const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeIDOnFreeBorder );
1844   const SMDS_MeshNode* aBorderLastNode   = aMesh->FindNode( LastNodeIDOnFreeBorder   );
1845   const SMDS_MeshNode* aSide2FirstNode   = aMesh->FindNode( FirstNodeIDOnSide  );
1846   const SMDS_MeshNode* aSide2SecondNode  = aMesh->FindNode( LastNodeIDOnSide );
1847   const SMDS_MeshNode* aSide2ThirdNode   = 0;
1848
1849   if (!aBorderFirstNode ||
1850       !aBorderSecondNode||
1851       !aBorderLastNode  )
1852     return SMESH::SMESH_MeshEditor::SEW_BORDER1_NOT_FOUND;
1853   if (!aSide2FirstNode  ||
1854       !aSide2SecondNode)
1855     return SMESH::SMESH_MeshEditor::SEW_BAD_SIDE_NODES;
1856
1857   // Update Python script
1858   TPythonDump() << "error = " << this << ".SewBorderToSide( "
1859                 << FirstNodeIDOnFreeBorder  << ", "
1860                 << SecondNodeIDOnFreeBorder << ", "
1861                 << LastNodeIDOnFreeBorder   << ", "
1862                 << FirstNodeIDOnSide        << ", "
1863                 << LastNodeIDOnSide         << ", "
1864                 << CreatePolygons           << ", "
1865                 << CreatePolyedrs           << ") ";
1866
1867   ::SMESH_MeshEditor anEditor( _myMesh );
1868   SMESH::SMESH_MeshEditor::Sew_Error error =
1869     convError( anEditor.SewFreeBorder (aBorderFirstNode,
1870                                        aBorderSecondNode,
1871                                        aBorderLastNode,
1872                                        aSide2FirstNode,
1873                                        aSide2SecondNode,
1874                                        aSide2ThirdNode,
1875                                        false,
1876                                        CreatePolygons,
1877                                        CreatePolyedrs) );
1878
1879   UpdateLastResult(anEditor);
1880
1881   return error;
1882 }
1883
1884
1885 //=======================================================================
1886 //function : SewSideElements
1887 //purpose  :
1888 //=======================================================================
1889
1890 SMESH::SMESH_MeshEditor::Sew_Error
1891 SMESH_MeshEditor_i::SewSideElements(const SMESH::long_array& IDsOfSide1Elements,
1892                                     const SMESH::long_array& IDsOfSide2Elements,
1893                                     CORBA::Long NodeID1OfSide1ToMerge,
1894                                     CORBA::Long NodeID1OfSide2ToMerge,
1895                                     CORBA::Long NodeID2OfSide1ToMerge,
1896                                     CORBA::Long NodeID2OfSide2ToMerge)
1897 {
1898   myLastCreatedElems = new SMESH::long_array();
1899   myLastCreatedNodes = new SMESH::long_array();
1900
1901   SMESHDS_Mesh* aMesh = GetMeshDS();
1902
1903   const SMDS_MeshNode* aFirstNode1ToMerge  = aMesh->FindNode( NodeID1OfSide1ToMerge );
1904   const SMDS_MeshNode* aFirstNode2ToMerge  = aMesh->FindNode( NodeID1OfSide2ToMerge );
1905   const SMDS_MeshNode* aSecondNode1ToMerge = aMesh->FindNode( NodeID2OfSide1ToMerge );
1906   const SMDS_MeshNode* aSecondNode2ToMerge = aMesh->FindNode( NodeID2OfSide2ToMerge );
1907
1908   if (!aFirstNode1ToMerge ||
1909       !aFirstNode2ToMerge )
1910     return SMESH::SMESH_MeshEditor::SEW_BAD_SIDE1_NODES;
1911   if (!aSecondNode1ToMerge||
1912       !aSecondNode2ToMerge)
1913     return SMESH::SMESH_MeshEditor::SEW_BAD_SIDE2_NODES;
1914
1915   TIDSortedElemSet aSide1Elems, aSide2Elems;
1916   ToMap(IDsOfSide1Elements, aMesh, aSide1Elems);
1917   ToMap(IDsOfSide2Elements, aMesh, aSide2Elems);
1918
1919   // Update Python script
1920   TPythonDump() << "error = " << this << ".SewSideElements( "
1921                 << IDsOfSide1Elements << ", "
1922                 << IDsOfSide2Elements << ", "
1923                 << NodeID1OfSide1ToMerge << ", "
1924                 << NodeID1OfSide2ToMerge << ", "
1925                 << NodeID2OfSide1ToMerge << ", "
1926                 << NodeID2OfSide2ToMerge << ")";
1927
1928   ::SMESH_MeshEditor anEditor( _myMesh );
1929   SMESH::SMESH_MeshEditor::Sew_Error error =
1930     convError( anEditor.SewSideElements (aSide1Elems, aSide2Elems,
1931                                          aFirstNode1ToMerge,
1932                                          aFirstNode2ToMerge,
1933                                          aSecondNode1ToMerge,
1934                                          aSecondNode2ToMerge));
1935
1936   UpdateLastResult(anEditor);
1937
1938   return error;
1939 }
1940
1941 //================================================================================
1942 /*!
1943  * \brief Set new nodes for given element
1944   * \param ide - element id
1945   * \param newIDs - new node ids
1946   * \retval CORBA::Boolean - true if result is OK
1947  */
1948 //================================================================================
1949
1950 CORBA::Boolean SMESH_MeshEditor_i::ChangeElemNodes(CORBA::Long ide,
1951                                                    const SMESH::long_array& newIDs)
1952 {
1953   myLastCreatedElems = new SMESH::long_array();
1954   myLastCreatedNodes = new SMESH::long_array();
1955
1956   const SMDS_MeshElement* elem = GetMeshDS()->FindElement(ide);
1957   if(!elem) return false;
1958
1959   int nbn = newIDs.length();
1960   int i=0;
1961   const SMDS_MeshNode* aNodes [nbn];
1962   int nbn1=-1;
1963   for(; i<nbn; i++) {
1964     const SMDS_MeshNode* aNode = GetMeshDS()->FindNode(newIDs[i]);
1965     if(aNode) {
1966       nbn1++;
1967       aNodes[nbn1] = aNode;
1968     }
1969   }
1970   // Update Python script
1971   TPythonDump() << "isDone = " << this << ".ChangeElemNodes( "
1972                 << ide << ", " << newIDs << " )";
1973 #ifdef _DEBUG_
1974   TPythonDump() << "print 'ChangeElemNodes: ', isDone";
1975 #endif
1976
1977   return GetMeshDS()->ChangeElementNodes( elem, aNodes, nbn1+1 );
1978 }
1979
1980 //================================================================================
1981 /*!
1982  * \brief Update myLastCreatedNodes and myLastCreatedElems
1983   * \param anEditor - it contains last modification results
1984  */
1985 //================================================================================
1986
1987 void SMESH_MeshEditor_i::UpdateLastResult(::SMESH_MeshEditor& anEditor)
1988 {
1989   // add new elements into myLastCreatedNodes
1990   SMESH_SequenceOfElemPtr aSeq = anEditor.GetLastCreatedNodes();
1991   SMESH::long_array_var aResult = new SMESH::long_array;
1992   aResult->length(aSeq.Length());
1993   int i=0;
1994   for(; i<aSeq.Length(); i++) {
1995     aResult[i] = aSeq.Value(i+1)->GetID();
1996   }
1997   myLastCreatedNodes = aResult._retn();
1998   // add new elements into myLastCreatedElems
1999   aSeq = anEditor.GetLastCreatedElems();
2000   aResult = new SMESH::long_array;
2001   aResult->length(aSeq.Length());
2002   i=0;
2003   for(; i<aSeq.Length(); i++) {
2004     aResult[i] = aSeq.Value(i+1)->GetID();
2005   }
2006   myLastCreatedElems = aResult._retn();
2007 }
2008
2009 //================================================================================
2010 /*!
2011  * \brief Returns list of it's IDs of created nodes
2012   * \retval SMESH::long_array* - list of node ID
2013  */
2014 //================================================================================
2015
2016 SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedNodes()
2017 {
2018   return myLastCreatedNodes;
2019 }
2020
2021 //================================================================================
2022 /*!
2023  * \brief Returns list of it's IDs of created elements
2024   * \retval SMESH::long_array* - list of elements' ID
2025  */
2026 //================================================================================
2027
2028 SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedElems()
2029 {
2030   return myLastCreatedElems;
2031 }
2032
2033
2034 //=======================================================================
2035 //function : ConvertToQuadratic
2036 //purpose  :
2037 //=======================================================================
2038
2039 void SMESH_MeshEditor_i::ConvertToQuadratic(CORBA::Boolean theForce3d)
2040 {
2041   ::SMESH_MeshEditor anEditor( _myMesh );
2042   anEditor.ConvertToQuadratic(theForce3d);
2043  // Update Python script
2044   TPythonDump() << this << ".ConvertToQuadratic( "
2045                 << theForce3d << " )";
2046 }
2047
2048 //=======================================================================
2049 //function : ConvertFromQuadratic
2050 //purpose  :
2051 //=======================================================================
2052
2053 CORBA::Boolean SMESH_MeshEditor_i::ConvertFromQuadratic()
2054 {
2055   ::SMESH_MeshEditor anEditor( _myMesh );
2056   CORBA::Boolean isDone = anEditor.ConvertFromQuadratic();
2057   // Update Python script
2058   TPythonDump() << this << ".ConvertFromQuadratic()";
2059   return isDone;
2060 }