]> SALOME platform Git repositories - modules/smesh.git/blob - src/SMESH_I/SMESH_MeshEditor_i.cxx
Salome HOME
- extra comment
[modules/smesh.git] / src / SMESH_I / SMESH_MeshEditor_i.cxx
1 //  Copyright (C) 2007-2008  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.
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 //  SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
23 //  File   : SMESH_MeshEditor_i.cxx
24 //  Author : Nicolas REJNERI
25 //  Module : SMESH
26
27 #include "SMESH_MeshEditor_i.hxx"
28
29 #include "SMDS_MeshEdge.hxx"
30 #include "SMDS_MeshFace.hxx"
31 #include "SMDS_MeshVolume.hxx"
32 #include "SMDS_PolyhedralVolumeOfNodes.hxx"
33 #include "SMESH_MeshEditor.hxx"
34 #include "SMESH_subMeshEventListener.hxx"
35 #include "SMESH_Gen_i.hxx"
36 #include "SMESH_Filter_i.hxx"
37 #include "SMESH_subMesh_i.hxx"
38 #include "SMESH_Group_i.hxx"
39 #include "SMESH_PythonDump.hxx"
40
41 #include "utilities.h"
42 #include "Utils_ExceptHandlers.hxx"
43 #include "Utils_CorbaException.hxx"
44
45 #include <BRepAdaptor_Surface.hxx>
46 #include <BRep_Tool.hxx>
47 #include <TopExp_Explorer.hxx>
48 #include <TopoDS.hxx>
49 #include <TopoDS_Edge.hxx>
50 #include <TopoDS_Face.hxx>
51 #include <gp_Ax1.hxx>
52 #include <gp_Ax2.hxx>
53 #include <gp_Vec.hxx>
54
55 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
56 #define NO_CAS_CATCH
57 #endif
58
59 #include <Standard_Failure.hxx>
60
61 #ifdef NO_CAS_CATCH
62 #include <Standard_ErrorHandler.hxx>
63 #endif
64
65 #include <sstream>
66
67 #define cast2Node(elem) static_cast<const SMDS_MeshNode*>( elem )
68
69 using namespace std;
70 using SMESH::TPythonDump;
71
72 namespace {
73
74   //=============================================================================
75   /*!
76    * \brief Mesh to apply modifications for preview purposes
77    */
78   //=============================================================================
79
80   struct TPreviewMesh: public SMESH_Mesh
81   {
82     SMDSAbs_ElementType myPreviewType; // type to show
83     //!< Constructor
84     TPreviewMesh(SMDSAbs_ElementType previewElements = SMDSAbs_All) {
85       _isShapeToMesh = (_id =_studyId =_idDoc = 0);
86       _myMeshDS  = new SMESHDS_Mesh( _id, true );
87       myPreviewType = previewElements;
88     }
89     //!< Destructor
90     virtual ~TPreviewMesh() { delete _myMeshDS; }
91     //!< Copy a set of elements
92     void Copy(const TIDSortedElemSet & theElements,
93               TIDSortedElemSet&        theCopyElements,
94               SMDSAbs_ElementType      theSelectType = SMDSAbs_All,
95               SMDSAbs_ElementType      theAvoidType = SMDSAbs_All)
96     {
97       // loop on theIDsOfElements
98       TIDSortedElemSet::const_iterator eIt = theElements.begin();
99       for ( ; eIt != theElements.end(); ++eIt )
100       {
101         const SMDS_MeshElement* anElem = *eIt;
102         if ( !anElem ) continue;
103         SMDSAbs_ElementType type = anElem->GetType();
104         if ( type == theAvoidType ||
105              ( theSelectType != SMDSAbs_All && type != theSelectType ))
106           continue;
107
108         if ( const SMDS_MeshElement* anElemCopy = Copy( anElem ))
109           theCopyElements.insert( theCopyElements.end(), anElemCopy );
110       }
111     }
112     //!< Copy an element
113     SMDS_MeshElement* Copy( const SMDS_MeshElement* anElem )
114     {
115       // copy element nodes
116       int anElemNbNodes = anElem->NbNodes();
117       vector< int > anElemNodesID( anElemNbNodes ) ;
118       SMDS_ElemIteratorPtr itElemNodes = anElem->nodesIterator();
119       for ( int i = 0; itElemNodes->more(); i++)
120       {
121         const SMDS_MeshNode* anElemNode = cast2Node( itElemNodes->next() );
122         Copy( anElemNode );
123         anElemNodesID[i] = anElemNode->GetID();
124       }
125
126       // creates a corresponding element on copied nodes
127       SMDS_MeshElement* anElemCopy = 0;
128       if ( anElem->IsPoly() && anElem->GetType() == SMDSAbs_Volume )
129       {
130         const SMDS_PolyhedralVolumeOfNodes* ph =
131           dynamic_cast<const SMDS_PolyhedralVolumeOfNodes*> (anElem);
132         if ( ph )
133           anElemCopy = _myMeshDS->AddPolyhedralVolumeWithID
134             (anElemNodesID, ph->GetQuanities(),anElem->GetID());
135       }
136       else {
137         anElemCopy = ::SMESH_MeshEditor(this).AddElement( anElemNodesID,
138                                                           anElem->GetType(),
139                                                           anElem->IsPoly() );
140       }
141       return anElemCopy;
142     }
143     //!< Copy a node
144     SMDS_MeshNode* Copy( const SMDS_MeshNode* anElemNode )
145     {
146       return _myMeshDS->AddNodeWithID(anElemNode->X(), anElemNode->Y(), anElemNode->Z(), 
147                                       anElemNode->GetID());
148     }
149   };// struct TPreviewMesh
150
151   static SMESH_NodeSearcher *    theNodeSearcher    = 0;
152   static SMESH_ElementSearcher * theElementSearcher = 0;
153
154   //=============================================================================
155   /*!
156    * \brief Deleter of theNodeSearcher at any compute event occured
157    */
158   //=============================================================================
159
160   struct TSearchersDeleter : public SMESH_subMeshEventListener
161   {
162     SMESH_Mesh* myMesh;
163     //!< Constructor
164     TSearchersDeleter(): SMESH_subMeshEventListener( false ), // won't be deleted by submesh
165     myMesh(0) {}
166     //!< Delete theNodeSearcher
167     static void Delete()
168     {
169       if ( theNodeSearcher )    delete theNodeSearcher;    theNodeSearcher    = 0;
170       if ( theElementSearcher ) delete theElementSearcher; theElementSearcher = 0;
171     }
172     typedef map < int, SMESH_subMesh * > TDependsOnMap;
173     //!< The meshod called by submesh: do my main job
174     void ProcessEvent(const int, const int eventType, SMESH_subMesh* sm,
175                       SMESH_subMeshEventListenerData*,const SMESH_Hypothesis*)
176     {
177       if ( eventType == SMESH_subMesh::COMPUTE_EVENT ) {
178         Delete();
179         Unset( sm->GetFather() );
180       }
181     }
182     //!< set self on all submeshes and delete theNodeSearcher if other mesh is set
183     void Set(SMESH_Mesh* mesh)
184     {
185       if ( myMesh != mesh )
186       {
187         if ( myMesh ) {
188           Delete();
189           Unset( myMesh );
190         }
191         myMesh = mesh;
192         if ( SMESH_subMesh* myMainSubMesh = mesh->GetSubMeshContaining(1) ) {
193           const TDependsOnMap & subMeshes = myMainSubMesh->DependsOn();
194           TDependsOnMap::const_iterator sm;
195           for (sm = subMeshes.begin(); sm != subMeshes.end(); sm++)
196             sm->second->SetEventListener( this, 0, sm->second );
197         }
198       }
199     }
200     //!<  delete self from all submeshes
201     void Unset(SMESH_Mesh* mesh)
202     {
203       if ( SMESH_subMesh* myMainSubMesh = mesh->GetSubMeshContaining(1) ) {
204         const TDependsOnMap & subMeshes = myMainSubMesh->DependsOn();
205         TDependsOnMap::const_iterator sm;
206         for (sm = subMeshes.begin(); sm != subMeshes.end(); sm++)
207           sm->second->DeleteEventListener( this );
208       }
209       myMesh = 0;
210     }
211
212   } theSearchersDeleter;
213
214   TCollection_AsciiString mirrorTypeName( SMESH::SMESH_MeshEditor::MirrorType theMirrorType )
215   {
216     TCollection_AsciiString typeStr;
217     switch ( theMirrorType ) {
218     case  SMESH::SMESH_MeshEditor::POINT:
219       typeStr = "SMESH.SMESH_MeshEditor.POINT";
220       break;
221     case  SMESH::SMESH_MeshEditor::AXIS:
222       typeStr = "SMESH.SMESH_MeshEditor.AXIS";
223       break;
224     default:
225       typeStr = "SMESH.SMESH_MeshEditor.PLANE";
226     }
227     return typeStr;
228   }
229 }
230
231 //=============================================================================
232 /*!
233  *
234  */
235 //=============================================================================
236
237 SMESH_MeshEditor_i::SMESH_MeshEditor_i(SMESH_Mesh_i* theMesh, bool isPreview)
238 {
239   myMesh_i = theMesh;
240   myMesh = & theMesh->GetImpl();
241   myPreviewMode = isPreview;
242 }
243
244 //================================================================================
245 /*!
246  * \brief Destructor
247  */
248 //================================================================================
249
250 SMESH_MeshEditor_i::~SMESH_MeshEditor_i()
251 {
252 }
253
254 //================================================================================
255 /*!
256  * \brief Clear members
257  */
258 //================================================================================
259
260 void SMESH_MeshEditor_i::initData(bool deleteSearchers)
261 {
262   if ( myPreviewMode ) {
263     myPreviewData = new SMESH::MeshPreviewStruct();
264   }
265   else {
266     myLastCreatedElems = new SMESH::long_array();
267     myLastCreatedNodes = new SMESH::long_array();
268     if ( deleteSearchers )
269       TSearchersDeleter::Delete();
270   }
271 }
272
273 //=============================================================================
274 /*!
275  *
276  */
277 //=============================================================================
278
279 CORBA::Boolean
280   SMESH_MeshEditor_i::RemoveElements(const SMESH::long_array & IDsOfElements)
281 {
282   initData();
283
284   ::SMESH_MeshEditor anEditor( myMesh );
285   list< int > IdList;
286
287   for (int i = 0; i < IDsOfElements.length(); i++)
288     IdList.push_back( IDsOfElements[i] );
289
290   // Update Python script
291   TPythonDump() << "isDone = " << this << ".RemoveElements( " << IDsOfElements << " )";
292 #ifdef _DEBUG_
293   TPythonDump() << "print 'RemoveElements: ', isDone";
294 #endif
295   // Remove Elements
296   return anEditor.Remove( IdList, false );
297 }
298
299 //=============================================================================
300 /*!
301  *
302  */
303 //=============================================================================
304
305 CORBA::Boolean SMESH_MeshEditor_i::RemoveNodes(const SMESH::long_array & IDsOfNodes)
306 {
307   initData();
308
309   ::SMESH_MeshEditor anEditor( myMesh );
310   list< int > IdList;
311   for (int i = 0; i < IDsOfNodes.length(); i++)
312     IdList.push_back( IDsOfNodes[i] );
313
314   // Update Python script
315   TPythonDump() << "isDone = " << this << ".RemoveNodes( " << IDsOfNodes << " )";
316 #ifdef _DEBUG_
317   TPythonDump() << "print 'RemoveNodes: ', isDone";
318 #endif
319
320   return anEditor.Remove( IdList, true );
321 }
322
323 //=============================================================================
324 /*!
325  *
326  */
327 //=============================================================================
328
329 CORBA::Long SMESH_MeshEditor_i::AddEdge(const SMESH::long_array & IDsOfNodes)
330 {
331   initData();
332
333   int NbNodes = IDsOfNodes.length();
334   SMDS_MeshElement* elem = 0;
335   if (NbNodes == 2)
336   {
337     CORBA::Long index1 = IDsOfNodes[0];
338     CORBA::Long index2 = IDsOfNodes[1];
339     elem = GetMeshDS()->AddEdge(GetMeshDS()->FindNode(index1), GetMeshDS()->FindNode(index2));
340
341     // Update Python script
342     TPythonDump() << "edge = " << this << ".AddEdge([ "
343                   << index1 << ", " << index2 <<" ])";
344   }
345   if (NbNodes == 3) {
346     CORBA::Long n1 = IDsOfNodes[0];
347     CORBA::Long n2 = IDsOfNodes[1];
348     CORBA::Long n12 = IDsOfNodes[2];
349     elem = GetMeshDS()->AddEdge(GetMeshDS()->FindNode(n1),
350                                 GetMeshDS()->FindNode(n2),
351                                 GetMeshDS()->FindNode(n12));
352     // Update Python script
353     TPythonDump() << "edgeID = " << this << ".AddEdge([ "
354                   <<n1<<", "<<n2<<", "<<n12<<" ])";
355   }
356
357   if(elem)
358     return elem->GetID();
359
360   return 0;
361 }
362
363 //=============================================================================
364 /*!
365  *
366  */
367 //=============================================================================
368
369 CORBA::Long SMESH_MeshEditor_i::AddNode(CORBA::Double x,
370                                         CORBA::Double y, CORBA::Double z)
371 {
372   initData();
373
374   const SMDS_MeshNode* N = GetMeshDS()->AddNode(x, y, z);
375
376   // Update Python script
377   TPythonDump() << "nodeID = " << this << ".AddNode( "
378                 << x << ", " << y << ", " << z << " )";
379
380   return N->GetID();
381 }
382
383 //=============================================================================
384 /*!
385  *  AddFace
386  */
387 //=============================================================================
388
389 CORBA::Long SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes)
390 {
391   initData();
392
393   int NbNodes = IDsOfNodes.length();
394   if (NbNodes < 3)
395   {
396     return 0;
397   }
398
399   std::vector<const SMDS_MeshNode*> nodes (NbNodes);
400   for (int i = 0; i < NbNodes; i++)
401     nodes[i] = GetMeshDS()->FindNode(IDsOfNodes[i]);
402
403   SMDS_MeshElement* elem = 0;
404   if (NbNodes == 3) {
405     elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2]);
406   }
407   else if (NbNodes == 4) {
408     elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3]);
409   }
410   else if (NbNodes == 6) {
411     elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
412                                 nodes[4], nodes[5]);
413   }
414   else if (NbNodes == 8) {
415     elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
416                                 nodes[4], nodes[5], nodes[6], nodes[7]);
417   }
418   else if (NbNodes > 2) {
419     elem = GetMeshDS()->AddPolygonalFace(nodes);
420   }
421
422   // Update Python script
423   TPythonDump() << "faceID = " << this << ".AddFace( " << IDsOfNodes << " )";
424
425   if(elem)
426     return elem->GetID();
427
428   return 0;
429 }
430
431 //=============================================================================
432 /*!
433  *  AddPolygonalFace
434  */
435 //=============================================================================
436 CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace
437                                    (const SMESH::long_array & IDsOfNodes)
438 {
439   initData();
440
441   int NbNodes = IDsOfNodes.length();
442   std::vector<const SMDS_MeshNode*> nodes (NbNodes);
443   for (int i = 0; i < NbNodes; i++)
444     nodes[i] = GetMeshDS()->FindNode(IDsOfNodes[i]);
445
446   const SMDS_MeshElement* elem = GetMeshDS()->AddPolygonalFace(nodes);
447   
448   // Update Python script
449   TPythonDump() <<"faceID = "<<this<<".AddPolygonalFace( "<<IDsOfNodes<<" )";
450 #ifdef _DEBUG_
451   TPythonDump() << "print 'AddPolygonalFace: ', faceID";
452 #endif
453
454   if(elem)
455     return elem->GetID();
456
457   return 0;
458 }
459
460 //=============================================================================
461 /*!
462  *
463  */
464 //=============================================================================
465
466 CORBA::Long SMESH_MeshEditor_i::AddVolume(const SMESH::long_array & IDsOfNodes)
467 {
468   initData();
469
470   int NbNodes = IDsOfNodes.length();
471   vector< const SMDS_MeshNode*> n(NbNodes);
472   for(int i=0;i<NbNodes;i++)
473     n[i]=GetMeshDS()->FindNode(IDsOfNodes[i]);
474
475   SMDS_MeshElement* elem = 0;
476   switch(NbNodes)
477   {
478   case 4 :elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3]); break;
479   case 5 :elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4]); break;
480   case 6 :elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5]); break;
481   case 8 :elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7]); break;
482   case 10:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],
483                                         n[6],n[7],n[8],n[9]);
484     break;
485   case 13:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],
486                                         n[7],n[8],n[9],n[10],n[11],n[12]);
487     break;
488   case 15:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],n[8],
489                                         n[9],n[10],n[11],n[12],n[13],n[14]);
490     break;
491   case 20:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],
492                                         n[8],n[9],n[10],n[11],n[12],n[13],n[14],
493                                         n[15],n[16],n[17],n[18],n[19]);
494     break;
495   }
496
497   // Update Python script
498   TPythonDump() << "volID = " << this << ".AddVolume( " << IDsOfNodes << " )";
499 #ifdef _DEBUG_
500   TPythonDump() << "print 'AddVolume: ', volID";
501 #endif
502
503   if(elem)
504     return elem->GetID();
505
506   return 0;
507 }
508
509 //=============================================================================
510 /*!
511  *  AddPolyhedralVolume
512  */
513 //=============================================================================
514 CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolume
515                                    (const SMESH::long_array & IDsOfNodes,
516                                     const SMESH::long_array & Quantities)
517 {
518   initData();
519
520   int NbNodes = IDsOfNodes.length();
521   std::vector<const SMDS_MeshNode*> n (NbNodes);
522   for (int i = 0; i < NbNodes; i++)
523     n[i] = GetMeshDS()->FindNode(IDsOfNodes[i]);
524
525   int NbFaces = Quantities.length();
526   std::vector<int> q (NbFaces);
527   for (int j = 0; j < NbFaces; j++)
528     q[j] = Quantities[j];
529
530   const SMDS_MeshElement* elem = GetMeshDS()->AddPolyhedralVolume(n, q);
531
532   // Update Python script
533   TPythonDump() << "volID = " << this << ".AddPolyhedralVolume( "
534                 << IDsOfNodes << ", " << Quantities << " )";
535 #ifdef _DEBUG_
536   TPythonDump() << "print 'AddPolyhedralVolume: ', volID";
537 #endif
538
539   if(elem)
540     return elem->GetID();
541
542   return 0;
543 }
544
545 //=============================================================================
546 /*!
547  *  AddPolyhedralVolumeByFaces
548  */
549 //=============================================================================
550 CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolumeByFaces
551                                    (const SMESH::long_array & IdsOfFaces)
552 {
553   initData();
554
555   int NbFaces = IdsOfFaces.length();
556   std::vector<const SMDS_MeshNode*> poly_nodes;
557   std::vector<int> quantities (NbFaces);
558
559   for (int i = 0; i < NbFaces; i++) {
560     const SMDS_MeshElement* aFace = GetMeshDS()->FindElement(IdsOfFaces[i]);
561     quantities[i] = aFace->NbNodes();
562
563     SMDS_ElemIteratorPtr It = aFace->nodesIterator();
564     while (It->more()) {
565       poly_nodes.push_back(static_cast<const SMDS_MeshNode *>(It->next()));
566     }
567   }
568
569   const SMDS_MeshElement* elem = GetMeshDS()->AddPolyhedralVolume(poly_nodes, quantities);
570
571   // Update Python script
572   TPythonDump() << "volID = " << this << ".AddPolyhedralVolumeByFaces( "
573                 << IdsOfFaces << " )";
574 #ifdef _DEBUG_
575   TPythonDump() << "print 'AddPolyhedralVolume: ', volID";
576 #endif
577
578   if(elem)
579     return elem->GetID();
580
581   return 0;
582 }
583
584 //=============================================================================
585 /*!
586  * \brief Bind a node to a vertex
587  * \param NodeID - node ID
588  * \param VertexID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
589  * \retval boolean - false if NodeID or VertexID is invalid
590  */
591 //=============================================================================
592
593 void SMESH_MeshEditor_i::SetNodeOnVertex(CORBA::Long NodeID, CORBA::Long VertexID)
594   throw (SALOME::SALOME_Exception)
595 {
596   Unexpect aCatch(SALOME_SalomeException);
597
598   SMESHDS_Mesh * mesh = GetMeshDS();
599   SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
600   if ( !node )
601     THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);
602
603   if ( mesh->MaxShapeIndex() < VertexID )
604     THROW_SALOME_CORBA_EXCEPTION("Invalid VertexID", SALOME::BAD_PARAM);
605
606   TopoDS_Shape shape = mesh->IndexToShape( VertexID );
607   if ( shape.ShapeType() != TopAbs_VERTEX )
608     THROW_SALOME_CORBA_EXCEPTION("Invalid VertexID", SALOME::BAD_PARAM);
609
610   mesh->SetNodeOnVertex( node, VertexID );
611 }
612
613 //=============================================================================
614 /*!
615  * \brief Store node position on an edge
616  * \param NodeID - node ID
617  * \param EdgeID - edge ID available through GEOM_Object.GetSubShapeIndices()[0]
618  * \param paramOnEdge - parameter on edge where the node is located
619  * \retval boolean - false if any parameter is invalid
620  */
621 //=============================================================================
622
623 void SMESH_MeshEditor_i::SetNodeOnEdge(CORBA::Long NodeID, CORBA::Long EdgeID,
624                                        CORBA::Double paramOnEdge)
625   throw (SALOME::SALOME_Exception)
626 {
627   Unexpect aCatch(SALOME_SalomeException);
628
629   SMESHDS_Mesh * mesh = GetMeshDS();
630   SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
631   if ( !node )
632     THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);
633
634   if ( mesh->MaxShapeIndex() < EdgeID )
635     THROW_SALOME_CORBA_EXCEPTION("Invalid EdgeID", SALOME::BAD_PARAM);
636
637   TopoDS_Shape shape = mesh->IndexToShape( EdgeID );
638   if ( shape.ShapeType() != TopAbs_EDGE )
639     THROW_SALOME_CORBA_EXCEPTION("Invalid EdgeID", SALOME::BAD_PARAM);
640
641   Standard_Real f,l;
642   BRep_Tool::Range( TopoDS::Edge( shape ), f,l);
643   if ( paramOnEdge < f || paramOnEdge > l )
644     THROW_SALOME_CORBA_EXCEPTION("Invalid paramOnEdge", SALOME::BAD_PARAM);
645
646   mesh->SetNodeOnEdge( node, EdgeID, paramOnEdge );
647 }
648
649 //=============================================================================
650 /*!
651  * \brief Store node position on a face
652  * \param NodeID - node ID
653  * \param FaceID - face ID available through GEOM_Object.GetSubShapeIndices()[0]
654  * \param u - U parameter on face where the node is located
655  * \param v - V parameter on face where the node is located
656  * \retval boolean - false if any parameter is invalid
657  */
658 //=============================================================================
659
660 void SMESH_MeshEditor_i::SetNodeOnFace(CORBA::Long NodeID, CORBA::Long FaceID,
661                                        CORBA::Double u, CORBA::Double v)
662   throw (SALOME::SALOME_Exception)
663 {
664   Unexpect aCatch(SALOME_SalomeException);
665
666   SMESHDS_Mesh * mesh = GetMeshDS();
667   SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
668   if ( !node )
669     THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);
670
671   if ( mesh->MaxShapeIndex() < FaceID )
672     THROW_SALOME_CORBA_EXCEPTION("Invalid FaceID", SALOME::BAD_PARAM);
673
674   TopoDS_Shape shape = mesh->IndexToShape( FaceID );
675   if ( shape.ShapeType() != TopAbs_FACE )
676     THROW_SALOME_CORBA_EXCEPTION("Invalid FaceID", SALOME::BAD_PARAM);
677
678   BRepAdaptor_Surface surf( TopoDS::Face( shape ));
679   bool isOut = ( u < surf.FirstUParameter() ||
680                  u > surf.LastUParameter()  ||
681                  v < surf.FirstVParameter() ||
682                  v > surf.LastVParameter() );
683
684   if ( isOut ) {
685 #ifdef _DEBUG_
686     MESSAGE ( "FACE " << FaceID << " (" << u << "," << v << ") out of "
687            << " u( " <<  surf.FirstUParameter() 
688            << "," <<  surf.LastUParameter()  
689            << ") v( " <<  surf.FirstVParameter() 
690            << "," <<  surf.LastVParameter() << ")" );
691 #endif    
692     THROW_SALOME_CORBA_EXCEPTION("Invalid UV", SALOME::BAD_PARAM);
693   }
694
695   mesh->SetNodeOnFace( node, FaceID, u, v );
696 }
697
698 //=============================================================================
699 /*!
700  * \brief Bind a node to a solid
701  * \param NodeID - node ID
702  * \param SolidID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
703  * \retval boolean - false if NodeID or SolidID is invalid
704  */
705 //=============================================================================
706
707 void SMESH_MeshEditor_i::SetNodeInVolume(CORBA::Long NodeID, CORBA::Long SolidID)
708   throw (SALOME::SALOME_Exception)
709 {
710   Unexpect aCatch(SALOME_SalomeException);
711
712   SMESHDS_Mesh * mesh = GetMeshDS();
713   SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
714   if ( !node )
715     THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);
716
717   if ( mesh->MaxShapeIndex() < SolidID )
718     THROW_SALOME_CORBA_EXCEPTION("Invalid SolidID", SALOME::BAD_PARAM);
719
720   TopoDS_Shape shape = mesh->IndexToShape( SolidID );
721   if ( shape.ShapeType() != TopAbs_SOLID &&
722        shape.ShapeType() != TopAbs_SHELL)
723     THROW_SALOME_CORBA_EXCEPTION("Invalid SolidID", SALOME::BAD_PARAM);
724
725   mesh->SetNodeInVolume( node, SolidID );
726 }
727
728 //=============================================================================
729 /*!
730  * \brief Bind an element to a shape
731  * \param ElementID - element ID
732  * \param ShapeID - shape ID available through GEOM_Object.GetSubShapeIndices()[0]
733  * \retval boolean - false if ElementID or ShapeID is invalid
734  */
735 //=============================================================================
736
737 void SMESH_MeshEditor_i::SetMeshElementOnShape(CORBA::Long ElementID,
738                                                CORBA::Long ShapeID)
739   throw (SALOME::SALOME_Exception)
740 {
741   Unexpect aCatch(SALOME_SalomeException);
742
743   SMESHDS_Mesh * mesh = GetMeshDS();
744   SMDS_MeshElement* elem = const_cast<SMDS_MeshElement*>(mesh->FindElement(ElementID));
745   if ( !elem )
746     THROW_SALOME_CORBA_EXCEPTION("Invalid ElementID", SALOME::BAD_PARAM);
747
748   if ( mesh->MaxShapeIndex() < ShapeID )
749     THROW_SALOME_CORBA_EXCEPTION("Invalid ShapeID", SALOME::BAD_PARAM);
750
751   TopoDS_Shape shape = mesh->IndexToShape( ShapeID );
752   if ( shape.ShapeType() != TopAbs_EDGE &&
753        shape.ShapeType() != TopAbs_FACE &&
754        shape.ShapeType() != TopAbs_SOLID &&
755        shape.ShapeType() != TopAbs_SHELL )
756     THROW_SALOME_CORBA_EXCEPTION("Invalid shape type", SALOME::BAD_PARAM);
757
758   mesh->SetMeshElementOnShape( elem, ShapeID );
759 }
760
761 //=============================================================================
762 /*!
763  *
764  */
765 //=============================================================================
766
767 CORBA::Boolean SMESH_MeshEditor_i::InverseDiag(CORBA::Long NodeID1,
768                                                CORBA::Long NodeID2)
769 {
770   initData();
771
772   const SMDS_MeshNode * n1 = GetMeshDS()->FindNode( NodeID1 );
773   const SMDS_MeshNode * n2 = GetMeshDS()->FindNode( NodeID2 );
774   if ( !n1 || !n2 )
775     return false;
776
777   // Update Python script
778   TPythonDump() << "isDone = " << this << ".InverseDiag( "
779                 << NodeID1 << ", " << NodeID2 << " )";
780
781   ::SMESH_MeshEditor aMeshEditor( myMesh );
782   return aMeshEditor.InverseDiag ( n1, n2 );
783 }
784
785 //=============================================================================
786 /*!
787  *
788  */
789 //=============================================================================
790
791 CORBA::Boolean SMESH_MeshEditor_i::DeleteDiag(CORBA::Long NodeID1,
792                                               CORBA::Long NodeID2)
793 {
794   initData();
795
796   const SMDS_MeshNode * n1 = GetMeshDS()->FindNode( NodeID1 );
797   const SMDS_MeshNode * n2 = GetMeshDS()->FindNode( NodeID2 );
798   if ( !n1 || !n2 )
799     return false;
800
801   // Update Python script
802   TPythonDump() << "isDone = " << this << ".DeleteDiag( "
803                 << NodeID1 << ", " << NodeID2 <<  " )";
804
805   ::SMESH_MeshEditor aMeshEditor( myMesh );
806
807   bool stat = aMeshEditor.DeleteDiag ( n1, n2 );
808
809   storeResult(aMeshEditor);
810
811   return stat;
812 }
813
814 //=============================================================================
815 /*!
816  *
817  */
818 //=============================================================================
819
820 CORBA::Boolean SMESH_MeshEditor_i::Reorient(const SMESH::long_array & IDsOfElements)
821 {
822   initData();
823
824   ::SMESH_MeshEditor anEditor( myMesh );
825   for (int i = 0; i < IDsOfElements.length(); i++)
826   {
827     CORBA::Long index = IDsOfElements[i];
828     const SMDS_MeshElement * elem = GetMeshDS()->FindElement(index);
829     if ( elem )
830       anEditor.Reorient( elem );
831   }
832   // Update Python script
833   TPythonDump() << "isDone = " << this << ".Reorient( " << IDsOfElements << " )";
834
835   return true;
836 }
837
838
839 //=============================================================================
840 /*!
841  *
842  */
843 //=============================================================================
844
845 CORBA::Boolean SMESH_MeshEditor_i::ReorientObject(SMESH::SMESH_IDSource_ptr theObject)
846 {
847   initData();
848
849   SMESH::long_array_var anElementsId = theObject->GetIDs();
850   CORBA::Boolean isDone = Reorient(anElementsId);
851
852   // Clear python line, created by Reorient()
853   SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
854   aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
855
856   // Update Python script
857   TPythonDump() << "isDone = " << this << ".ReorientObject( " << theObject << " )";
858
859   return isDone;
860 }
861
862 namespace
863 {
864   //================================================================================
865   /*!
866    * \brief function for conversion long_array to TIDSortedElemSet
867     * \param IDs - array of IDs
868     * \param aMesh - mesh
869     * \param aMap - collection to fill
870     * \param aType - element type
871    */
872   //================================================================================
873
874   void arrayToSet(const SMESH::long_array & IDs,
875                   const SMESHDS_Mesh*       aMesh,
876                   TIDSortedElemSet&         aMap,
877                   const SMDSAbs_ElementType aType = SMDSAbs_All )
878   { 
879     for (int i=0; i<IDs.length(); i++) {
880       CORBA::Long ind = IDs[i];
881       const SMDS_MeshElement * elem =
882         (aType == SMDSAbs_Node ? aMesh->FindNode(ind)
883                               : aMesh->FindElement(ind));
884       if ( elem && ( aType == SMDSAbs_All || elem->GetType() == aType ))
885         aMap.insert( elem );
886     }
887   }
888 }
889
890 //=============================================================================
891 /*!
892  *
893  */
894 //=============================================================================
895 CORBA::Boolean SMESH_MeshEditor_i::TriToQuad (const SMESH::long_array &   IDsOfElements,
896                                               SMESH::NumericalFunctor_ptr Criterion,
897                                               CORBA::Double               MaxAngle)
898 {
899   initData();
900
901   SMESHDS_Mesh* aMesh = GetMeshDS();
902   TIDSortedElemSet faces;
903   arrayToSet(IDsOfElements, aMesh, faces, SMDSAbs_Face);
904
905   SMESH::NumericalFunctor_i* aNumericalFunctor =
906     dynamic_cast<SMESH::NumericalFunctor_i*>( SMESH_Gen_i::GetServant( Criterion ).in() );
907   SMESH::Controls::NumericalFunctorPtr aCrit;
908   if ( !aNumericalFunctor )
909     aCrit.reset( new SMESH::Controls::AspectRatio() );
910   else
911     aCrit = aNumericalFunctor->GetNumericalFunctor();
912
913   // Update Python script
914   TPythonDump() << "isDone = " << this << ".TriToQuad( "
915                 << IDsOfElements << ", " << aNumericalFunctor << ", " << MaxAngle << " )";
916 #ifdef _DEBUG_
917   TPythonDump() << "print 'TriToQuad: ', isDone";
918 #endif
919
920   ::SMESH_MeshEditor anEditor( myMesh );
921
922   bool stat = anEditor.TriToQuad( faces, aCrit, MaxAngle );
923
924   storeResult(anEditor);
925
926   return stat;
927 }
928
929
930 //=============================================================================
931 /*!
932  *
933  */
934 //=============================================================================
935 CORBA::Boolean SMESH_MeshEditor_i::TriToQuadObject (SMESH::SMESH_IDSource_ptr   theObject,
936                                                     SMESH::NumericalFunctor_ptr Criterion,
937                                                     CORBA::Double               MaxAngle)
938 {
939   initData();
940
941   SMESH::long_array_var anElementsId = theObject->GetIDs();
942   CORBA::Boolean isDone = TriToQuad(anElementsId, Criterion, MaxAngle);
943
944   // Clear python line(s), created by TriToQuad()
945   SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
946   aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
947 #ifdef _DEBUG_
948   aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
949 #endif
950
951   SMESH::NumericalFunctor_i* aNumericalFunctor =
952     SMESH::DownCast<SMESH::NumericalFunctor_i*>( Criterion );
953
954   // Update Python script
955   TPythonDump() << "isDone = " << this << ".TriToQuadObject("
956                 << theObject << ", " << aNumericalFunctor << ", " << MaxAngle << " )";
957 #ifdef _DEBUG_
958   TPythonDump() << "print 'TriToQuadObject: ', isDone";
959 #endif
960
961   return isDone;
962 }
963
964
965 //=============================================================================
966 /*!
967  *
968  */
969 //=============================================================================
970 CORBA::Boolean SMESH_MeshEditor_i::QuadToTri (const SMESH::long_array &   IDsOfElements,
971                                               SMESH::NumericalFunctor_ptr Criterion)
972 {
973   initData();
974
975   SMESHDS_Mesh* aMesh = GetMeshDS();
976   TIDSortedElemSet faces;
977   arrayToSet(IDsOfElements, aMesh, faces, SMDSAbs_Face);
978
979   SMESH::NumericalFunctor_i* aNumericalFunctor =
980     dynamic_cast<SMESH::NumericalFunctor_i*>( SMESH_Gen_i::GetServant( Criterion ).in() );
981   SMESH::Controls::NumericalFunctorPtr aCrit;
982   if ( !aNumericalFunctor )
983     aCrit.reset( new SMESH::Controls::AspectRatio() );
984   else
985     aCrit = aNumericalFunctor->GetNumericalFunctor();
986
987
988   // Update Python script
989   TPythonDump() << "isDone = " << this << ".QuadToTri( " << IDsOfElements << ", " << aNumericalFunctor << " )";
990 #ifdef _DEBUG_
991   TPythonDump() << "print 'QuadToTri: ', isDone";
992 #endif
993
994   ::SMESH_MeshEditor anEditor( myMesh );
995   CORBA::Boolean stat = anEditor.QuadToTri( faces, aCrit );
996
997   storeResult(anEditor);
998
999   return stat;
1000 }
1001
1002
1003 //=============================================================================
1004 /*!
1005  *
1006  */
1007 //=============================================================================
1008 CORBA::Boolean SMESH_MeshEditor_i::QuadToTriObject (SMESH::SMESH_IDSource_ptr   theObject,
1009                                                     SMESH::NumericalFunctor_ptr Criterion)
1010 {
1011   initData();
1012
1013   SMESH::long_array_var anElementsId = theObject->GetIDs();
1014   CORBA::Boolean isDone = QuadToTri(anElementsId, Criterion);
1015
1016   // Clear python line(s), created by QuadToTri()
1017   SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
1018   aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
1019 #ifdef _DEBUG_
1020   aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
1021 #endif
1022
1023   SMESH::NumericalFunctor_i* aNumericalFunctor =
1024     SMESH::DownCast<SMESH::NumericalFunctor_i*>( Criterion );
1025
1026   // Update Python script
1027   TPythonDump() << "isDone = " << this << ".QuadToTriObject( " << theObject << ", " << aNumericalFunctor << " )";
1028 #ifdef _DEBUG_
1029   TPythonDump() << "print 'QuadToTriObject: ', isDone";
1030 #endif
1031
1032   return isDone;
1033 }
1034
1035
1036 //=============================================================================
1037 /*!
1038  *
1039  */
1040 //=============================================================================
1041 CORBA::Boolean SMESH_MeshEditor_i::SplitQuad (const SMESH::long_array & IDsOfElements,
1042                                               CORBA::Boolean            Diag13)
1043 {
1044   initData();
1045
1046   SMESHDS_Mesh* aMesh = GetMeshDS();
1047   TIDSortedElemSet faces;
1048   arrayToSet(IDsOfElements, aMesh, faces, SMDSAbs_Face);
1049
1050   // Update Python script
1051   TPythonDump() << "isDone = " << this << ".SplitQuad( "
1052                 << IDsOfElements << ", " << Diag13 << " )";
1053 #ifdef _DEBUG_
1054   TPythonDump() << "print 'SplitQuad: ', isDone";
1055 #endif
1056
1057   ::SMESH_MeshEditor anEditor( myMesh );
1058   CORBA::Boolean stat = anEditor.QuadToTri( faces, Diag13 );
1059
1060   storeResult(anEditor);
1061
1062   return stat;
1063 }
1064
1065
1066 //=============================================================================
1067 /*!
1068  *
1069  */
1070 //=============================================================================
1071 CORBA::Boolean SMESH_MeshEditor_i::SplitQuadObject (SMESH::SMESH_IDSource_ptr theObject,
1072                                                     CORBA::Boolean            Diag13)
1073 {
1074   initData();
1075
1076   SMESH::long_array_var anElementsId = theObject->GetIDs();
1077   CORBA::Boolean isDone = SplitQuad(anElementsId, Diag13);
1078
1079   // Clear python line(s), created by SplitQuad()
1080   SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
1081   aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
1082 #ifdef _DEBUG_
1083   aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
1084 #endif
1085
1086   // Update Python script
1087   TPythonDump() << "isDone = " << this << ".SplitQuadObject( "
1088                 << theObject << ", " << Diag13 << " )";
1089 #ifdef _DEBUG_
1090   TPythonDump() << "print 'SplitQuadObject: ', isDone";
1091 #endif
1092
1093   return isDone;
1094 }
1095
1096
1097 //=============================================================================
1098 /*!
1099  *  BestSplit
1100  */
1101 //=============================================================================
1102 CORBA::Long SMESH_MeshEditor_i::BestSplit (CORBA::Long                 IDOfQuad,
1103                                            SMESH::NumericalFunctor_ptr Criterion)
1104 {
1105   const SMDS_MeshElement* quad = GetMeshDS()->FindElement(IDOfQuad);
1106   if (quad && quad->GetType() == SMDSAbs_Face && quad->NbNodes() == 4)
1107   {
1108     SMESH::NumericalFunctor_i* aNumericalFunctor =
1109       dynamic_cast<SMESH::NumericalFunctor_i*>(SMESH_Gen_i::GetServant(Criterion).in());
1110     SMESH::Controls::NumericalFunctorPtr aCrit;
1111     if (aNumericalFunctor)
1112       aCrit = aNumericalFunctor->GetNumericalFunctor();
1113     else
1114       aCrit.reset(new SMESH::Controls::AspectRatio());
1115
1116     ::SMESH_MeshEditor anEditor (myMesh);
1117     return anEditor.BestSplit(quad, aCrit);
1118   }
1119   return -1;
1120 }
1121
1122
1123 //=======================================================================
1124 //function : Smooth
1125 //purpose  :
1126 //=======================================================================
1127
1128 CORBA::Boolean
1129   SMESH_MeshEditor_i::Smooth(const SMESH::long_array &              IDsOfElements,
1130                              const SMESH::long_array &              IDsOfFixedNodes,
1131                              CORBA::Long                            MaxNbOfIterations,
1132                              CORBA::Double                          MaxAspectRatio,
1133                              SMESH::SMESH_MeshEditor::Smooth_Method Method)
1134 {
1135   return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
1136                 MaxAspectRatio, Method, false );
1137 }
1138
1139
1140 //=======================================================================
1141 //function : SmoothParametric
1142 //purpose  :
1143 //=======================================================================
1144
1145 CORBA::Boolean
1146   SMESH_MeshEditor_i::SmoothParametric(const SMESH::long_array &              IDsOfElements,
1147                                        const SMESH::long_array &              IDsOfFixedNodes,
1148                                        CORBA::Long                            MaxNbOfIterations,
1149                                        CORBA::Double                          MaxAspectRatio,
1150                                        SMESH::SMESH_MeshEditor::Smooth_Method Method)
1151 {
1152   return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
1153                 MaxAspectRatio, Method, true );
1154 }
1155
1156
1157 //=======================================================================
1158 //function : SmoothObject
1159 //purpose  :
1160 //=======================================================================
1161
1162 CORBA::Boolean
1163   SMESH_MeshEditor_i::SmoothObject(SMESH::SMESH_IDSource_ptr              theObject,
1164                                    const SMESH::long_array &              IDsOfFixedNodes,
1165                                    CORBA::Long                            MaxNbOfIterations,
1166                                    CORBA::Double                          MaxAspectRatio,
1167                                    SMESH::SMESH_MeshEditor::Smooth_Method Method)
1168 {
1169   return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
1170                        MaxAspectRatio, Method, false);
1171 }
1172
1173
1174 //=======================================================================
1175 //function : SmoothParametricObject
1176 //purpose  :
1177 //=======================================================================
1178
1179 CORBA::Boolean
1180   SMESH_MeshEditor_i::SmoothParametricObject(SMESH::SMESH_IDSource_ptr              theObject,
1181                                    const SMESH::long_array &              IDsOfFixedNodes,
1182                                    CORBA::Long                            MaxNbOfIterations,
1183                                    CORBA::Double                          MaxAspectRatio,
1184                                    SMESH::SMESH_MeshEditor::Smooth_Method Method)
1185 {
1186   return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
1187                        MaxAspectRatio, Method, true);
1188 }
1189
1190
1191 //=============================================================================
1192 /*!
1193  *
1194  */
1195 //=============================================================================
1196
1197 CORBA::Boolean
1198   SMESH_MeshEditor_i::smooth(const SMESH::long_array &              IDsOfElements,
1199                              const SMESH::long_array &              IDsOfFixedNodes,
1200                              CORBA::Long                            MaxNbOfIterations,
1201                              CORBA::Double                          MaxAspectRatio,
1202                              SMESH::SMESH_MeshEditor::Smooth_Method Method,
1203                              bool                                   IsParametric)
1204 {
1205   initData();
1206
1207   SMESHDS_Mesh* aMesh = GetMeshDS();
1208
1209   TIDSortedElemSet elements;
1210   arrayToSet(IDsOfElements, aMesh, elements, SMDSAbs_Face);
1211
1212   set<const SMDS_MeshNode*> fixedNodes;
1213   for (int i = 0; i < IDsOfFixedNodes.length(); i++) {
1214     CORBA::Long index = IDsOfFixedNodes[i];
1215     const SMDS_MeshNode * node = aMesh->FindNode(index);
1216     if ( node )
1217       fixedNodes.insert( node );
1218   }
1219   ::SMESH_MeshEditor::SmoothMethod method = ::SMESH_MeshEditor::LAPLACIAN;
1220   if ( Method != SMESH::SMESH_MeshEditor::LAPLACIAN_SMOOTH )
1221     method = ::SMESH_MeshEditor::CENTROIDAL;
1222
1223   ::SMESH_MeshEditor anEditor( myMesh );
1224   anEditor.Smooth(elements, fixedNodes, method,
1225                   MaxNbOfIterations, MaxAspectRatio, IsParametric );
1226
1227   storeResult(anEditor);
1228
1229   // Update Python script
1230   TPythonDump() << "isDone = " << this << "."
1231                 << (IsParametric ? "SmoothParametric( " : "Smooth( ")
1232                 << IDsOfElements << ", "     << IDsOfFixedNodes << ", "
1233                 << MaxNbOfIterations << ", " << MaxAspectRatio << ", "
1234                 << "SMESH.SMESH_MeshEditor."
1235                 << ( Method == SMESH::SMESH_MeshEditor::CENTROIDAL_SMOOTH ?
1236                      "CENTROIDAL_SMOOTH )" : "LAPLACIAN_SMOOTH )");
1237 #ifdef _DEBUG_
1238   TPythonDump() << "print 'Smooth: ', isDone";
1239 #endif
1240
1241   return true;
1242 }
1243
1244
1245 //=============================================================================
1246 /*!
1247  *
1248  */
1249 //=============================================================================
1250
1251 CORBA::Boolean
1252 SMESH_MeshEditor_i::smoothObject(SMESH::SMESH_IDSource_ptr              theObject,
1253                                  const SMESH::long_array &              IDsOfFixedNodes,
1254                                  CORBA::Long                            MaxNbOfIterations,
1255                                  CORBA::Double                          MaxAspectRatio,
1256                                  SMESH::SMESH_MeshEditor::Smooth_Method Method,
1257                                  bool                                   IsParametric)
1258 {
1259   initData();
1260
1261   SMESH::long_array_var anElementsId = theObject->GetIDs();
1262   CORBA::Boolean isDone = smooth (anElementsId, IDsOfFixedNodes, MaxNbOfIterations,
1263                                   MaxAspectRatio, Method, IsParametric);
1264
1265   // Clear python line(s), created by Smooth()
1266   SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
1267   aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
1268 #ifdef _DEBUG_
1269   aSMESHGen->RemoveLastFromPythonScript(aSMESHGen->GetCurrentStudyID());
1270 #endif
1271
1272   // Update Python script
1273   TPythonDump() << "isDone = " << this << "."
1274                 << (IsParametric ? "SmoothParametricObject( " : "SmoothObject( ")
1275                 << theObject << ", " << IDsOfFixedNodes << ", "
1276                 << MaxNbOfIterations << ", " << MaxAspectRatio << ", "
1277                 << "SMESH.SMESH_MeshEditor."
1278                 << ( Method == SMESH::SMESH_MeshEditor::CENTROIDAL_SMOOTH ?
1279                      "CENTROIDAL_SMOOTH )" : "LAPLACIAN_SMOOTH )");
1280 #ifdef _DEBUG_
1281   TPythonDump() << "print 'SmoothObject: ', isDone";
1282 #endif
1283
1284   return isDone;
1285 }
1286
1287
1288 //=============================================================================
1289 /*!
1290  *
1291  */
1292 //=============================================================================
1293
1294 void SMESH_MeshEditor_i::RenumberNodes()
1295 {
1296   // Update Python script
1297   TPythonDump() << this << ".RenumberNodes()";
1298
1299   GetMeshDS()->Renumber( true );
1300 }
1301
1302
1303 //=============================================================================
1304 /*!
1305  *
1306  */
1307 //=============================================================================
1308
1309 void SMESH_MeshEditor_i::RenumberElements()
1310 {
1311   // Update Python script
1312   TPythonDump() << this << ".RenumberElements()";
1313
1314   GetMeshDS()->Renumber( false );
1315 }
1316
1317 //=======================================================================
1318   /*!
1319    * \brief Return groups by their IDs
1320    */
1321 //=======================================================================
1322
1323 SMESH::ListOfGroups* SMESH_MeshEditor_i::getGroups(const std::list<int>* groupIDs)
1324 {
1325   if ( !groupIDs )
1326     return 0;
1327   myMesh_i->CreateGroupServants();
1328   return myMesh_i->GetGroups( *groupIDs );
1329 }
1330
1331 //=======================================================================
1332 //function : rotationSweep
1333 //purpose  : 
1334 //=======================================================================
1335
1336 SMESH::ListOfGroups*
1337 SMESH_MeshEditor_i::rotationSweep(const SMESH::long_array & theIDsOfElements,
1338                                   const SMESH::AxisStruct & theAxis,
1339                                   CORBA::Double             theAngleInRadians,
1340                                   CORBA::Long               theNbOfSteps,
1341                                   CORBA::Double             theTolerance,
1342                                   const bool                theMakeGroups,
1343                                   const SMDSAbs_ElementType theElementType)
1344 {
1345   initData();
1346
1347   TIDSortedElemSet inElements, copyElements;
1348   arrayToSet(theIDsOfElements, GetMeshDS(), inElements, theElementType);
1349
1350   TIDSortedElemSet* workElements = & inElements;
1351   TPreviewMesh      tmpMesh( SMDSAbs_Face );
1352   SMESH_Mesh*       mesh = 0;
1353   bool              makeWalls=true;
1354   if ( myPreviewMode )
1355   {
1356     SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
1357     tmpMesh.Copy( inElements, copyElements, select, avoid );
1358     mesh = &tmpMesh;
1359     workElements = & copyElements;
1360     //makeWalls = false;
1361   }
1362   else
1363   {
1364     mesh = myMesh;
1365   }
1366
1367   gp_Ax1 Ax1 (gp_Pnt( theAxis.x,  theAxis.y,  theAxis.z ),
1368               gp_Vec( theAxis.vx, theAxis.vy, theAxis.vz ));
1369
1370   ::SMESH_MeshEditor anEditor( mesh );
1371   ::SMESH_MeshEditor::PGroupIDs groupIds =
1372     anEditor.RotationSweep (*workElements, Ax1, theAngleInRadians,
1373                             theNbOfSteps, theTolerance, theMakeGroups, makeWalls);
1374   storeResult(anEditor);
1375
1376   return theMakeGroups ? getGroups(groupIds.get()) : 0;
1377 }
1378
1379 //=======================================================================
1380 //function : RotationSweep
1381 //purpose  :
1382 //=======================================================================
1383
1384 void SMESH_MeshEditor_i::RotationSweep(const SMESH::long_array & theIDsOfElements,
1385                                        const SMESH::AxisStruct & theAxis,
1386                                        CORBA::Double             theAngleInRadians,
1387                                        CORBA::Long               theNbOfSteps,
1388                                        CORBA::Double             theTolerance)
1389 {
1390   if ( !myPreviewMode ) {
1391     TPythonDump() << this << ".RotationSweep( "
1392                   << theIDsOfElements << ", "
1393                   << theAxis << ", "
1394                   << theAngleInRadians << ", "
1395                   << theNbOfSteps << ", "
1396                   << theTolerance << " )";
1397   }
1398   rotationSweep(theIDsOfElements,
1399                 theAxis,
1400                 theAngleInRadians,
1401                 theNbOfSteps,
1402                 theTolerance,
1403                 false);
1404 }
1405
1406 //=======================================================================
1407 //function : RotationSweepMakeGroups
1408 //purpose  : 
1409 //=======================================================================
1410
1411 SMESH::ListOfGroups*
1412 SMESH_MeshEditor_i::RotationSweepMakeGroups(const SMESH::long_array& theIDsOfElements,
1413                                             const SMESH::AxisStruct& theAxis,
1414                                             CORBA::Double            theAngleInRadians,
1415                                             CORBA::Long              theNbOfSteps,
1416                                             CORBA::Double            theTolerance)
1417 {
1418   SMESH::ListOfGroups *aGroups = rotationSweep(theIDsOfElements,
1419                                                theAxis,
1420                                                theAngleInRadians,
1421                                                theNbOfSteps,
1422                                                theTolerance,
1423                                                true);
1424   if ( !myPreviewMode ) {
1425     TPythonDump aPythonDump;
1426     DumpGroupsList(aPythonDump,aGroups);
1427     aPythonDump<< this << ".RotationSweepMakeGroups( "
1428                << theIDsOfElements << ", "
1429                << theAxis << ", "
1430                << theAngleInRadians << ", "
1431                << theNbOfSteps << ", "
1432                << theTolerance << " )";
1433   }
1434   return aGroups;
1435 }
1436
1437 //=======================================================================
1438 //function : RotationSweepObject
1439 //purpose  :
1440 //=======================================================================
1441
1442 void SMESH_MeshEditor_i::RotationSweepObject(SMESH::SMESH_IDSource_ptr theObject,
1443                                              const SMESH::AxisStruct & theAxis,
1444                                              CORBA::Double             theAngleInRadians,
1445                                              CORBA::Long               theNbOfSteps,
1446                                              CORBA::Double             theTolerance)
1447 {
1448   if ( !myPreviewMode ) {
1449     TPythonDump() << this << ".RotationSweepObject( "
1450                   << theObject << ", "
1451                   << theAxis << ", "
1452                   << theAngleInRadians << ", "
1453                   << theNbOfSteps << ", "
1454                   << theTolerance << " )";
1455   }
1456   SMESH::long_array_var anElementsId = theObject->GetIDs();
1457   rotationSweep(anElementsId,
1458                 theAxis,
1459                 theAngleInRadians,
1460                 theNbOfSteps,
1461                 theTolerance,
1462                 false);
1463 }
1464
1465 //=======================================================================
1466 //function : RotationSweepObjectMakeGroups
1467 //purpose  : 
1468 //=======================================================================
1469
1470 SMESH::ListOfGroups*
1471 SMESH_MeshEditor_i::RotationSweepObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
1472                                                   const SMESH::AxisStruct&  theAxis,
1473                                                   CORBA::Double             theAngleInRadians,
1474                                                   CORBA::Long               theNbOfSteps,
1475                                                   CORBA::Double             theTolerance)
1476 {
1477   SMESH::long_array_var anElementsId = theObject->GetIDs();
1478   SMESH::ListOfGroups *aGroups = rotationSweep(anElementsId,
1479                                                theAxis,
1480                                                theAngleInRadians,
1481                                                theNbOfSteps,
1482                                                theTolerance,
1483                                                true);
1484   if ( !myPreviewMode ) {
1485     TPythonDump aPythonDump;
1486     DumpGroupsList(aPythonDump,aGroups);
1487     aPythonDump<< this << ".RotationSweepObjectMakeGroups( "
1488                << theObject
1489                << ", axis, "
1490                << theAngleInRadians << ", "
1491                << theNbOfSteps << ", "
1492                << theTolerance << " )";
1493   }
1494   return aGroups;
1495 }
1496
1497
1498 //=======================================================================
1499 //function : extrusionSweep
1500 //purpose  : 
1501 //=======================================================================
1502
1503 SMESH::ListOfGroups*
1504 SMESH_MeshEditor_i::extrusionSweep(const SMESH::long_array & theIDsOfElements,
1505                                    const SMESH::DirStruct &  theStepVector,
1506                                    CORBA::Long               theNbOfSteps,
1507                                    const bool                theMakeGroups,
1508                                    const SMDSAbs_ElementType theElementType)
1509 {
1510   initData();
1511
1512   try {   
1513 #ifdef NO_CAS_CATCH
1514     OCC_CATCH_SIGNALS;
1515 #endif
1516     TIDSortedElemSet elements;
1517     arrayToSet(theIDsOfElements, GetMeshDS(), elements, theElementType);
1518
1519     const SMESH::PointStruct * P = &theStepVector.PS;
1520     gp_Vec stepVec( P->x, P->y, P->z );
1521
1522     TElemOfElemListMap aHystory;
1523     ::SMESH_MeshEditor anEditor( myMesh );
1524     ::SMESH_MeshEditor::PGroupIDs groupIds =
1525         anEditor.ExtrusionSweep (elements, stepVec, theNbOfSteps, aHystory, theMakeGroups);
1526
1527     storeResult(anEditor);
1528
1529     return theMakeGroups ? getGroups(groupIds.get()) : 0;
1530
1531   } catch(Standard_Failure) {
1532     Handle(Standard_Failure) aFail = Standard_Failure::Caught();          
1533     INFOS( "SMESH_MeshEditor_i::ExtrusionSweep fails - "<< aFail->GetMessageString() );
1534   }
1535   return 0;
1536 }
1537
1538 //=======================================================================
1539 //function : ExtrusionSweep
1540 //purpose  :
1541 //=======================================================================
1542
1543 void SMESH_MeshEditor_i::ExtrusionSweep(const SMESH::long_array & theIDsOfElements,
1544                                         const SMESH::DirStruct &  theStepVector,
1545                                         CORBA::Long               theNbOfSteps)
1546 {
1547   extrusionSweep (theIDsOfElements, theStepVector, theNbOfSteps, false );
1548   if ( !myPreviewMode ) {
1549     TPythonDump() << this << ".ExtrusionSweep( "
1550                   << theIDsOfElements << ", " << theStepVector <<", " << theNbOfSteps << " )";
1551   }
1552 }
1553
1554
1555 //=======================================================================
1556 //function : ExtrusionSweepObject
1557 //purpose  :
1558 //=======================================================================
1559
1560 void SMESH_MeshEditor_i::ExtrusionSweepObject(SMESH::SMESH_IDSource_ptr theObject,
1561                                               const SMESH::DirStruct &  theStepVector,
1562                                               CORBA::Long               theNbOfSteps)
1563 {
1564   SMESH::long_array_var anElementsId = theObject->GetIDs();
1565   extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false );
1566   if ( !myPreviewMode ) {
1567     TPythonDump() << this << ".ExtrusionSweepObject( "
1568                   << theObject << ", " << theStepVector << ", " << theNbOfSteps << " )";
1569   }
1570 }
1571
1572 //=======================================================================
1573 //function : ExtrusionSweepObject1D
1574 //purpose  :
1575 //=======================================================================
1576
1577 void SMESH_MeshEditor_i::ExtrusionSweepObject1D(SMESH::SMESH_IDSource_ptr theObject,
1578                                                 const SMESH::DirStruct &  theStepVector,
1579                                                 CORBA::Long               theNbOfSteps)
1580 {
1581   SMESH::long_array_var anElementsId = theObject->GetIDs();
1582   extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false, SMDSAbs_Edge );
1583   if ( !myPreviewMode ) {
1584     TPythonDump() << this << ".ExtrusionSweepObject1D( "
1585                   << theObject << ", " << theStepVector << ", " << theNbOfSteps << " )";
1586   }
1587 }
1588
1589 //=======================================================================
1590 //function : ExtrusionSweepObject2D
1591 //purpose  :
1592 //=======================================================================
1593
1594 void SMESH_MeshEditor_i::ExtrusionSweepObject2D(SMESH::SMESH_IDSource_ptr theObject,
1595                                                 const SMESH::DirStruct &  theStepVector,
1596                                                 CORBA::Long               theNbOfSteps)
1597 {
1598   SMESH::long_array_var anElementsId = theObject->GetIDs();
1599   extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false, SMDSAbs_Face );
1600   if ( !myPreviewMode ) {
1601     TPythonDump() << this << ".ExtrusionSweepObject2D( "
1602                   << theObject << ", " << theStepVector << ", " << theNbOfSteps << " )";
1603   }
1604 }
1605
1606 //=======================================================================
1607 //function : ExtrusionSweepMakeGroups
1608 //purpose  : 
1609 //=======================================================================
1610
1611 SMESH::ListOfGroups*
1612 SMESH_MeshEditor_i::ExtrusionSweepMakeGroups(const SMESH::long_array& theIDsOfElements,
1613                                              const SMESH::DirStruct&  theStepVector,
1614                                              CORBA::Long              theNbOfSteps)
1615 {
1616   SMESH::ListOfGroups* aGroups = extrusionSweep (theIDsOfElements, theStepVector, theNbOfSteps, true );
1617     
1618   if ( !myPreviewMode ) {
1619     TPythonDump aPythonDump;
1620     DumpGroupsList(aPythonDump,aGroups);
1621     aPythonDump  << this << ".ExtrusionSweepMakeGroups( "
1622                  << theIDsOfElements << ", " << theStepVector <<", " << theNbOfSteps << " )";
1623   }
1624   return aGroups;
1625 }
1626 //=======================================================================
1627 //function : ExtrusionSweepObjectMakeGroups
1628 //purpose  : 
1629 //=======================================================================
1630
1631 SMESH::ListOfGroups*
1632 SMESH_MeshEditor_i::ExtrusionSweepObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
1633                                                    const SMESH::DirStruct&   theStepVector,
1634                                                    CORBA::Long               theNbOfSteps)
1635 {
1636   SMESH::long_array_var anElementsId = theObject->GetIDs();
1637   SMESH::ListOfGroups * aGroups = extrusionSweep (anElementsId, theStepVector, theNbOfSteps, true );
1638   
1639   if ( !myPreviewMode ) {
1640     TPythonDump aPythonDump;
1641     DumpGroupsList(aPythonDump,aGroups);
1642     aPythonDump<< this << ".ExtrusionSweepObjectMakeGroups( "
1643                << theObject << ", " << theStepVector << ", " << theNbOfSteps << " )";
1644   }
1645   return aGroups;
1646 }
1647
1648 //=======================================================================
1649 //function : ExtrusionSweepObject1DMakeGroups
1650 //purpose  : 
1651 //=======================================================================
1652
1653 SMESH::ListOfGroups*
1654 SMESH_MeshEditor_i::ExtrusionSweepObject1DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
1655                                                      const SMESH::DirStruct&   theStepVector,
1656                                                      CORBA::Long               theNbOfSteps)
1657 {
1658   SMESH::long_array_var anElementsId = theObject->GetIDs();
1659   SMESH::ListOfGroups * aGroups = extrusionSweep (anElementsId, theStepVector, theNbOfSteps, true, SMDSAbs_Edge );
1660   if ( !myPreviewMode ) {
1661     TPythonDump aPythonDump;
1662     DumpGroupsList(aPythonDump,aGroups);
1663     aPythonDump << this << ".ExtrusionSweepObject1DMakeGroups( "
1664                 << theObject << ", " << theStepVector << ", " << theNbOfSteps << " )";
1665   }
1666   return aGroups;
1667 }
1668
1669 //=======================================================================
1670 //function : ExtrusionSweepObject2DMakeGroups
1671 //purpose  : 
1672 //=======================================================================
1673
1674 SMESH::ListOfGroups*
1675 SMESH_MeshEditor_i::ExtrusionSweepObject2DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
1676                                                      const SMESH::DirStruct&   theStepVector,
1677                                                      CORBA::Long               theNbOfSteps)
1678 {
1679   SMESH::long_array_var anElementsId = theObject->GetIDs();
1680   SMESH::ListOfGroups * aGroups = extrusionSweep (anElementsId, theStepVector, theNbOfSteps, true, SMDSAbs_Face );
1681   if ( !myPreviewMode ) {
1682     TPythonDump aPythonDump;
1683     DumpGroupsList(aPythonDump,aGroups);
1684     aPythonDump << this << ".ExtrusionSweepObject2DMakeGroups( "
1685                 << theObject << ", " << theStepVector << ", " << theNbOfSteps << " )";
1686   }
1687   return aGroups;
1688 }
1689
1690
1691 //=======================================================================
1692 //function : advancedExtrusion
1693 //purpose  : 
1694 //=======================================================================
1695
1696 SMESH::ListOfGroups*
1697 SMESH_MeshEditor_i::advancedExtrusion(const SMESH::long_array & theIDsOfElements,
1698                                       const SMESH::DirStruct &  theStepVector,
1699                                       CORBA::Long               theNbOfSteps,
1700                                       CORBA::Long               theExtrFlags,
1701                                       CORBA::Double             theSewTolerance,
1702                                       const bool                theMakeGroups)
1703 {
1704   initData();
1705
1706   TIDSortedElemSet elements;
1707   arrayToSet(theIDsOfElements, GetMeshDS(), elements);
1708
1709   const SMESH::PointStruct * P = &theStepVector.PS;
1710   gp_Vec stepVec( P->x, P->y, P->z );
1711
1712   ::SMESH_MeshEditor anEditor( myMesh );
1713   TElemOfElemListMap aHystory;
1714   ::SMESH_MeshEditor::PGroupIDs groupIds =
1715       anEditor.ExtrusionSweep (elements, stepVec, theNbOfSteps, aHystory,
1716                                theMakeGroups, theExtrFlags, theSewTolerance);
1717   storeResult(anEditor);
1718
1719   return theMakeGroups ? getGroups(groupIds.get()) : 0;
1720 }
1721
1722 //=======================================================================
1723 //function : AdvancedExtrusion
1724 //purpose  :
1725 //=======================================================================
1726
1727 void SMESH_MeshEditor_i::AdvancedExtrusion(const SMESH::long_array & theIDsOfElements,
1728                                            const SMESH::DirStruct &  theStepVector,
1729                                            CORBA::Long               theNbOfSteps,
1730                                            CORBA::Long               theExtrFlags,
1731                                            CORBA::Double             theSewTolerance)
1732 {
1733   if ( !myPreviewMode ) {
1734     TPythonDump() << "stepVector = " << theStepVector;
1735     TPythonDump() << this << ".AdvancedExtrusion("
1736                   << theIDsOfElements
1737                   << ", stepVector, "
1738                   << theNbOfSteps << ","
1739                   << theExtrFlags << ", "
1740                   << theSewTolerance <<  " )";
1741   }
1742   advancedExtrusion( theIDsOfElements,
1743                      theStepVector,
1744                      theNbOfSteps,
1745                      theExtrFlags,
1746                      theSewTolerance,
1747                      false);
1748 }
1749
1750 //=======================================================================
1751 //function : AdvancedExtrusionMakeGroups
1752 //purpose  : 
1753 //=======================================================================
1754
1755 SMESH::ListOfGroups*
1756 SMESH_MeshEditor_i::AdvancedExtrusionMakeGroups(const SMESH::long_array& theIDsOfElements,
1757                                                 const SMESH::DirStruct&  theStepVector,
1758                                                 CORBA::Long              theNbOfSteps,
1759                                                 CORBA::Long              theExtrFlags,
1760                                                 CORBA::Double            theSewTolerance)
1761 {
1762   SMESH::ListOfGroups * aGroups = advancedExtrusion( theIDsOfElements,
1763                                                     theStepVector,
1764                                                     theNbOfSteps,
1765                                                     theExtrFlags,
1766                                                     theSewTolerance,
1767                                                     true);
1768   
1769   if ( !myPreviewMode ) {
1770     TPythonDump() << "stepVector = " << theStepVector;
1771     TPythonDump aPythonDump;
1772     DumpGroupsList(aPythonDump,aGroups);
1773     aPythonDump << this << ".AdvancedExtrusionMakeGroups("
1774                 << theIDsOfElements
1775                 << ", stepVector, "
1776                 << theNbOfSteps << ","
1777                 << theExtrFlags << ", "
1778                 << theSewTolerance <<  " )";
1779   }
1780   return aGroups;
1781 }
1782
1783
1784 //================================================================================
1785 /*!
1786  * \brief Convert extrusion error to IDL enum
1787  */
1788 //================================================================================
1789
1790 #define RETCASE(enm) case ::SMESH_MeshEditor::enm: return SMESH::SMESH_MeshEditor::enm;
1791
1792 static SMESH::SMESH_MeshEditor::Extrusion_Error convExtrError( const::SMESH_MeshEditor::Extrusion_Error e )
1793 {
1794   switch ( e ) {
1795   RETCASE( EXTR_OK );
1796   RETCASE( EXTR_NO_ELEMENTS );
1797   RETCASE( EXTR_PATH_NOT_EDGE );
1798   RETCASE( EXTR_BAD_PATH_SHAPE );
1799   RETCASE( EXTR_BAD_STARTING_NODE );
1800   RETCASE( EXTR_BAD_ANGLES_NUMBER );
1801   RETCASE( EXTR_CANT_GET_TANGENT );
1802   }
1803   return SMESH::SMESH_MeshEditor::EXTR_OK;
1804 }
1805
1806
1807 //=======================================================================
1808 //function : extrusionAlongPath
1809 //purpose  : 
1810 //=======================================================================
1811
1812 SMESH::ListOfGroups*
1813 SMESH_MeshEditor_i::extrusionAlongPath(const SMESH::long_array &   theIDsOfElements,
1814                                        SMESH::SMESH_Mesh_ptr       thePathMesh,
1815                                        GEOM::GEOM_Object_ptr       thePathShape,
1816                                        CORBA::Long                 theNodeStart,
1817                                        CORBA::Boolean              theHasAngles,
1818                                        const SMESH::double_array & theAngles,
1819                                        CORBA::Boolean              theHasRefPoint,
1820                                        const SMESH::PointStruct &  theRefPoint,
1821                                        const bool                  theMakeGroups,
1822                                        SMESH::SMESH_MeshEditor::Extrusion_Error & theError,
1823                                        const SMDSAbs_ElementType   theElementType)
1824 {
1825   initData();
1826
1827   if ( thePathMesh->_is_nil() || thePathShape->_is_nil() ) {
1828     theError = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
1829     return 0;
1830   }
1831   SMESH_Mesh_i* aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( thePathMesh );
1832
1833   TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( thePathShape );
1834   SMESH_subMesh* aSubMesh = aMeshImp->GetImpl().GetSubMesh( aShape );
1835
1836   if ( !aSubMesh || !aSubMesh->GetSubMeshDS()) {
1837     theError = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
1838     return 0;
1839   }
1840
1841   SMDS_MeshNode* nodeStart = (SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(theNodeStart);
1842   if ( !nodeStart ) {
1843     theError = SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE;
1844     return 0;
1845   }
1846
1847   TIDSortedElemSet elements;
1848   arrayToSet(theIDsOfElements, GetMeshDS(), elements, theElementType);
1849
1850   list<double> angles;
1851   for (int i = 0; i < theAngles.length(); i++) {
1852     angles.push_back( theAngles[i] );
1853   }
1854
1855   gp_Pnt refPnt( theRefPoint.x, theRefPoint.y, theRefPoint.z );
1856
1857   int nbOldGroups = myMesh->NbGroup();
1858
1859   ::SMESH_MeshEditor anEditor( myMesh );
1860   ::SMESH_MeshEditor::Extrusion_Error error =
1861       anEditor.ExtrusionAlongTrack( elements, aSubMesh, nodeStart,
1862                                     theHasAngles, angles, false,
1863                                     theHasRefPoint, refPnt, theMakeGroups );
1864   storeResult(anEditor);
1865   theError = convExtrError( error );
1866
1867   if ( theMakeGroups ) {
1868     list<int> groupIDs = myMesh->GetGroupIds();
1869     list<int>::iterator newBegin = groupIDs.begin();
1870     std::advance( newBegin, nbOldGroups ); // skip old groups
1871     groupIDs.erase( groupIDs.begin(), newBegin );
1872     return getGroups( & groupIDs );
1873   }
1874   return 0;
1875 }
1876
1877 //=======================================================================
1878 //function : ExtrusionAlongPath
1879 //purpose  :
1880 //=======================================================================
1881
1882 SMESH::SMESH_MeshEditor::Extrusion_Error
1883   SMESH_MeshEditor_i::ExtrusionAlongPath(const SMESH::long_array &   theIDsOfElements,
1884                                          SMESH::SMESH_Mesh_ptr       thePathMesh,
1885                                          GEOM::GEOM_Object_ptr       thePathShape,
1886                                          CORBA::Long                 theNodeStart,
1887                                          CORBA::Boolean              theHasAngles,
1888                                          const SMESH::double_array & theAngles,
1889                                          CORBA::Boolean              theHasRefPoint,
1890                                          const SMESH::PointStruct &  theRefPoint)
1891 {
1892   if ( !myPreviewMode ) {
1893     TPythonDump() << "error = " << this << ".ExtrusionAlongPath( "
1894                   << theIDsOfElements << ", "
1895                   << thePathMesh      << ", "
1896                   << thePathShape     << ", "
1897                   << theNodeStart     << ", "
1898                   << theHasAngles     << ", "
1899                   << theAngles        << ", "
1900                   << theHasRefPoint   << ", "
1901                   << "SMESH.PointStruct( "
1902                   << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
1903                   << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
1904                   << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
1905   }
1906   SMESH::SMESH_MeshEditor::Extrusion_Error anError;
1907   extrusionAlongPath( theIDsOfElements,
1908                       thePathMesh,
1909                       thePathShape,
1910                       theNodeStart,
1911                       theHasAngles,
1912                       theAngles,
1913                       theHasRefPoint,
1914                       theRefPoint,
1915                       false,
1916                       anError);
1917   return anError;
1918 }
1919
1920 //=======================================================================
1921 //function : ExtrusionAlongPathObject
1922 //purpose  :
1923 //=======================================================================
1924
1925 SMESH::SMESH_MeshEditor::Extrusion_Error
1926 SMESH_MeshEditor_i::ExtrusionAlongPathObject(SMESH::SMESH_IDSource_ptr   theObject,
1927                                              SMESH::SMESH_Mesh_ptr       thePathMesh,
1928                                              GEOM::GEOM_Object_ptr       thePathShape,
1929                                              CORBA::Long                 theNodeStart,
1930                                              CORBA::Boolean              theHasAngles,
1931                                              const SMESH::double_array & theAngles,
1932                                              CORBA::Boolean              theHasRefPoint,
1933                                              const SMESH::PointStruct &  theRefPoint)
1934 {
1935   if ( !myPreviewMode ) {
1936     TPythonDump() << "error = " << this << ".ExtrusionAlongPathObject( "
1937                   << theObject        << ", "
1938                   << thePathMesh      << ", "
1939                   << thePathShape     << ", "
1940                   << theNodeStart     << ", "
1941                   << theHasAngles     << ", "
1942                   << theAngles        << ", "
1943                   << theHasRefPoint   << ", "
1944                   << "SMESH.PointStruct( "
1945                   << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
1946                   << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
1947                   << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
1948   }
1949   SMESH::SMESH_MeshEditor::Extrusion_Error anError;
1950   SMESH::long_array_var anElementsId = theObject->GetIDs();
1951   extrusionAlongPath( anElementsId,
1952                       thePathMesh,
1953                       thePathShape,
1954                       theNodeStart,
1955                       theHasAngles,
1956                       theAngles,
1957                       theHasRefPoint,
1958                       theRefPoint,
1959                       false,
1960                       anError);
1961   return anError;
1962 }
1963
1964 //=======================================================================
1965 //function : ExtrusionAlongPathMakeGroups
1966 //purpose  : 
1967 //=======================================================================
1968
1969 SMESH::ListOfGroups*
1970 SMESH_MeshEditor_i::ExtrusionAlongPathMakeGroups(const SMESH::long_array&   theIDsOfElements,
1971                                                  SMESH::SMESH_Mesh_ptr      thePathMesh,
1972                                                  GEOM::GEOM_Object_ptr      thePathShape,
1973                                                  CORBA::Long                theNodeStart,
1974                                                  CORBA::Boolean             theHasAngles,
1975                                                  const SMESH::double_array& theAngles,
1976                                                  CORBA::Boolean             theHasRefPoint,
1977                                                  const SMESH::PointStruct&  theRefPoint,
1978                                                  SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
1979 {
1980     SMESH::ListOfGroups * aGroups =  extrusionAlongPath( theIDsOfElements,
1981                                                          thePathMesh,
1982                                                          thePathShape,
1983                                                          theNodeStart,
1984                                                          theHasAngles,
1985                                                          theAngles,
1986                                                          theHasRefPoint,
1987                                                          theRefPoint,
1988                                                          true,
1989                                                          Error);
1990   if ( !myPreviewMode ) {
1991     TPythonDump() << "rotAngles = " << theAngles;
1992
1993     if ( theHasRefPoint )
1994       TPythonDump() << "refPoint = SMESH.PointStruct( "
1995                     << theRefPoint.x << ", "
1996                     << theRefPoint.y << ", "
1997                     << theRefPoint.z << " )";
1998     else
1999       TPythonDump() << "refPoint = SMESH.PointStruct( 0,0,0 )";
2000
2001     bool isDumpGroups = aGroups && aGroups->length() > 0;
2002     TPythonDump aPythonDump;
2003     if(isDumpGroups) {
2004       aPythonDump << "("<<aGroups;
2005     }
2006     if(isDumpGroups)
2007       aPythonDump << ", error)";
2008     else
2009       aPythonDump <<"error";
2010     
2011     aPythonDump<<" = "<< this << ".ExtrusionAlongPathMakeGroups( "
2012                << theIDsOfElements << ", "
2013                << thePathMesh      << ", "
2014                << thePathShape     << ", "
2015                << theNodeStart     << ", "
2016                << theHasAngles     << ", "
2017                << theAngles        << ", "
2018                << theHasRefPoint   << ", "
2019                << "SMESH.PointStruct( "
2020                << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
2021                << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
2022                << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
2023   }
2024   return aGroups;
2025 }
2026
2027 //=======================================================================
2028 //function : ExtrusionAlongPathObjectMakeGroups
2029 //purpose  : 
2030 //=======================================================================
2031
2032 SMESH::ListOfGroups* SMESH_MeshEditor_i::
2033 ExtrusionAlongPathObjectMakeGroups(SMESH::SMESH_IDSource_ptr  theObject,
2034                                    SMESH::SMESH_Mesh_ptr      thePathMesh,
2035                                    GEOM::GEOM_Object_ptr      thePathShape,
2036                                    CORBA::Long                theNodeStart,
2037                                    CORBA::Boolean             theHasAngles,
2038                                    const SMESH::double_array& theAngles,
2039                                    CORBA::Boolean             theHasRefPoint,
2040                                    const SMESH::PointStruct&  theRefPoint,
2041                                    SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
2042 {
2043   SMESH::long_array_var anElementsId = theObject->GetIDs();
2044   SMESH::ListOfGroups * aGroups = extrusionAlongPath( anElementsId,
2045                                                       thePathMesh,
2046                                                       thePathShape,
2047                                                       theNodeStart,
2048                                                       theHasAngles,
2049                                                       theAngles,
2050                                                       theHasRefPoint,
2051                                                       theRefPoint,
2052                                                       true,
2053                                                       Error);
2054   
2055   if ( !myPreviewMode ) {
2056     bool isDumpGroups = aGroups && aGroups->length() > 0;
2057     TPythonDump aPythonDump;
2058     if(isDumpGroups) {
2059       aPythonDump << "("<<aGroups;
2060     }
2061     if(isDumpGroups)
2062       aPythonDump << ", error)";
2063     else
2064       aPythonDump <<"error";
2065
2066     aPythonDump << " = " << this << ".ExtrusionAlongPathObjectMakeGroups( "
2067                 << theObject << ", "
2068                 << thePathMesh      << ", "
2069                 << thePathShape     << ", "
2070                 << theNodeStart     << ", "
2071                 << theHasAngles     << ", "
2072                 << theAngles        << ", "
2073                 << theHasRefPoint   << ", "
2074                 << "SMESH.PointStruct( "
2075                 << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
2076                 << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
2077                 << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
2078   }
2079   return aGroups;
2080 }
2081
2082 //================================================================================
2083 /*!
2084  * \brief Compute rotation angles for ExtrusionAlongPath as linear variation
2085  * of given angles along path steps
2086   * \param PathMesh mesh containing a 1D sub-mesh on the edge, along 
2087   *                which proceeds the extrusion
2088   * \param PathShape is shape(edge); as the mesh can be complex, the edge 
2089   *                 is used to define the sub-mesh for the path
2090  */
2091 //================================================================================
2092
2093 SMESH::double_array*
2094 SMESH_MeshEditor_i::LinearAnglesVariation(SMESH::SMESH_Mesh_ptr       thePathMesh,
2095                                           GEOM::GEOM_Object_ptr       thePathShape,
2096                                           const SMESH::double_array & theAngles)
2097 {
2098   SMESH::double_array_var aResult = new SMESH::double_array();
2099   int nbAngles = theAngles.length();
2100   if ( nbAngles > 0 && !thePathMesh->_is_nil() && !thePathShape->_is_nil() )
2101   {
2102     SMESH_Mesh_i* aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( thePathMesh );
2103     TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( thePathShape );
2104     SMESH_subMesh* aSubMesh = aMeshImp->GetImpl().GetSubMesh( aShape );
2105     if ( !aSubMesh || !aSubMesh->GetSubMeshDS())
2106       return aResult._retn();
2107     int nbSteps = aSubMesh->GetSubMeshDS()->NbElements();
2108     if ( nbSteps == nbAngles )
2109     {
2110       aResult.inout() = theAngles;
2111     }
2112     else
2113     {
2114       aResult->length( nbSteps );
2115       double rAn2St = double( nbAngles ) / double( nbSteps );
2116       double angPrev = 0, angle;
2117       for ( int iSt = 0; iSt < nbSteps; ++iSt )
2118       {
2119         double angCur = rAn2St * ( iSt+1 );
2120         double angCurFloor  = floor( angCur );
2121         double angPrevFloor = floor( angPrev );
2122         if ( angPrevFloor == angCurFloor )
2123           angle = rAn2St * theAngles[ int( angCurFloor ) ];
2124         else
2125         {
2126           int iP = int( angPrevFloor );
2127           double angPrevCeil = ceil(angPrev);
2128           angle = ( angPrevCeil - angPrev ) * theAngles[ iP ];
2129           
2130           int iC = int( angCurFloor );
2131           if ( iC < nbAngles )
2132             angle += ( angCur - angCurFloor ) * theAngles[ iC ];
2133
2134           iP = int( angPrevCeil );
2135           while ( iC-- > iP )
2136             angle += theAngles[ iC ];
2137         }
2138         aResult[ iSt ] = angle;
2139         angPrev = angCur;
2140       }
2141     }
2142   }
2143   // Update Python script
2144   TPythonDump() << "rotAngles = " << theAngles;
2145   TPythonDump() << "rotAngles = " << this << ".LinearAnglesVariation( "
2146                 << thePathMesh  << ", "
2147                 << thePathShape << ", "
2148                 << "rotAngles )";
2149
2150   return aResult._retn();
2151 }
2152
2153
2154 //=======================================================================
2155 //function : mirror
2156 //purpose  : 
2157 //=======================================================================
2158
2159 SMESH::ListOfGroups*
2160 SMESH_MeshEditor_i::mirror(const SMESH::long_array &           theIDsOfElements,
2161                            const SMESH::AxisStruct &           theAxis,
2162                            SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
2163                            CORBA::Boolean                      theCopy,
2164                            const bool                          theMakeGroups,
2165                            ::SMESH_Mesh*                       theTargetMesh)
2166 {
2167   initData();
2168
2169   TIDSortedElemSet elements;
2170   arrayToSet(theIDsOfElements, GetMeshDS(), elements);
2171
2172   gp_Pnt P ( theAxis.x, theAxis.y, theAxis.z );
2173   gp_Vec V ( theAxis.vx, theAxis.vy, theAxis.vz );
2174
2175   gp_Trsf aTrsf;
2176   switch ( theMirrorType ) {
2177   case  SMESH::SMESH_MeshEditor::POINT:
2178     aTrsf.SetMirror( P );
2179     break;
2180   case  SMESH::SMESH_MeshEditor::AXIS:
2181     aTrsf.SetMirror( gp_Ax1( P, V ));
2182     break;
2183   default:
2184     aTrsf.SetMirror( gp_Ax2( P, V ));
2185   }
2186
2187   ::SMESH_MeshEditor anEditor( myMesh );
2188   ::SMESH_MeshEditor::PGroupIDs groupIds =
2189       anEditor.Transform (elements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
2190
2191   if(theCopy) {
2192     storeResult(anEditor);
2193   }
2194   return theMakeGroups ? getGroups(groupIds.get()) : 0;
2195 }
2196
2197 //=======================================================================
2198 //function : Mirror
2199 //purpose  :
2200 //=======================================================================
2201
2202 void SMESH_MeshEditor_i::Mirror(const SMESH::long_array &           theIDsOfElements,
2203                                 const SMESH::AxisStruct &           theAxis,
2204                                 SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
2205                                 CORBA::Boolean                      theCopy)
2206 {
2207   if ( !myPreviewMode ) {
2208     TPythonDump() << this << ".Mirror( "
2209                   << theIDsOfElements << ", "
2210                   << theAxis          << ", "
2211                   << mirrorTypeName(theMirrorType) << ", "
2212                   << theCopy          << " )";
2213   }
2214   mirror(theIDsOfElements, theAxis, theMirrorType, theCopy, false);
2215 }
2216
2217
2218 //=======================================================================
2219 //function : MirrorObject
2220 //purpose  :
2221 //=======================================================================
2222
2223 void SMESH_MeshEditor_i::MirrorObject(SMESH::SMESH_IDSource_ptr           theObject,
2224                                       const SMESH::AxisStruct &           theAxis,
2225                                       SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
2226                                       CORBA::Boolean                      theCopy)
2227 {
2228   if ( !myPreviewMode ) {
2229     TPythonDump() << this << ".MirrorObject( "
2230                   << theObject << ", "
2231                   << theAxis   << ", "
2232                   << mirrorTypeName(theMirrorType) << ", "
2233                   << theCopy   << " )";
2234   }
2235   SMESH::long_array_var anElementsId = theObject->GetIDs();
2236   mirror(anElementsId, theAxis, theMirrorType, theCopy, false);
2237 }
2238
2239 //=======================================================================
2240 //function : MirrorMakeGroups
2241 //purpose  : 
2242 //=======================================================================
2243
2244 SMESH::ListOfGroups*
2245 SMESH_MeshEditor_i::MirrorMakeGroups(const SMESH::long_array&            theIDsOfElements,
2246                                      const SMESH::AxisStruct&            theMirror,
2247                                      SMESH::SMESH_MeshEditor::MirrorType theMirrorType)
2248 {
2249   SMESH::ListOfGroups * aGroups = mirror(theIDsOfElements, theMirror, theMirrorType, true, true);
2250   if ( !myPreviewMode ) {
2251     TPythonDump aPythonDump;
2252     DumpGroupsList(aPythonDump,aGroups);
2253     aPythonDump << this << ".MirrorMakeGroups( "
2254                 << theIDsOfElements << ", "
2255                 << theMirror << ", "
2256                 << mirrorTypeName(theMirrorType) << " )";
2257   }
2258   return aGroups;
2259 }
2260
2261 //=======================================================================
2262 //function : MirrorObjectMakeGroups
2263 //purpose  : 
2264 //=======================================================================
2265
2266 SMESH::ListOfGroups*
2267 SMESH_MeshEditor_i::MirrorObjectMakeGroups(SMESH::SMESH_IDSource_ptr           theObject,
2268                                            const SMESH::AxisStruct&            theMirror,
2269                                            SMESH::SMESH_MeshEditor::MirrorType theMirrorType)
2270 {
2271   SMESH::long_array_var anElementsId = theObject->GetIDs();
2272   SMESH::ListOfGroups * aGroups = mirror(anElementsId, theMirror, theMirrorType, true, true);
2273   if ( !myPreviewMode ) {
2274     TPythonDump aPythonDump;
2275     DumpGroupsList(aPythonDump,aGroups);
2276     aPythonDump << this << ".MirrorObjectMakeGroups( "
2277                 << theObject << ", "
2278                 << theMirror << ", "
2279                 << mirrorTypeName(theMirrorType) << " )";
2280   }
2281   return aGroups;
2282 }
2283
2284 //=======================================================================
2285 //function : MirrorMakeMesh
2286 //purpose  : 
2287 //=======================================================================
2288
2289 SMESH::SMESH_Mesh_ptr
2290 SMESH_MeshEditor_i::MirrorMakeMesh(const SMESH::long_array&            theIDsOfElements,
2291                                    const SMESH::AxisStruct&            theMirror,
2292                                    SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
2293                                    CORBA::Boolean                      theCopyGroups,
2294                                    const char*                         theMeshName)
2295 {
2296   SMESH_Mesh_i* mesh_i;
2297   SMESH::SMESH_Mesh_var mesh;
2298   { // open new scope to dump "MakeMesh" command
2299     // and then "GetGroups" using SMESH_Mesh::GetGroups()
2300     
2301     TPythonDump pydump; // to prevent dump at mesh creation
2302
2303     mesh = makeMesh( theMeshName );
2304     mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
2305     if (mesh_i) {
2306       mirror(theIDsOfElements, theMirror, theMirrorType,
2307              false, theCopyGroups, & mesh_i->GetImpl());
2308       mesh_i->CreateGroupServants();
2309     }
2310     
2311     if ( !myPreviewMode ) {
2312       pydump << mesh << " = " << this << ".MirrorMakeMesh( "
2313              << theIDsOfElements << ", "
2314              << theMirror   << ", "
2315              << mirrorTypeName(theMirrorType) << ", "
2316              << theCopyGroups << ", '"
2317              << theMeshName << "' )";
2318     }
2319   }
2320
2321   //dump "GetGroups"
2322   if(!myPreviewMode && mesh_i)
2323     mesh_i->GetGroups();
2324   
2325   return mesh._retn();
2326 }
2327
2328 //=======================================================================
2329 //function : MirrorObjectMakeMesh
2330 //purpose  : 
2331 //=======================================================================
2332
2333 SMESH::SMESH_Mesh_ptr
2334 SMESH_MeshEditor_i::MirrorObjectMakeMesh(SMESH::SMESH_IDSource_ptr           theObject,
2335                                          const SMESH::AxisStruct&            theMirror,
2336                                          SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
2337                                          CORBA::Boolean                      theCopyGroups,
2338                                          const char*                         theMeshName)
2339 {
2340   SMESH_Mesh_i* mesh_i;
2341   SMESH::SMESH_Mesh_var mesh;
2342   { // open new scope to dump "MakeMesh" command
2343     // and then "GetGroups" using SMESH_Mesh::GetGroups()
2344     
2345     TPythonDump pydump; // to prevent dump at mesh creation
2346
2347     mesh = makeMesh( theMeshName );
2348     mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
2349     if ( mesh_i ) {
2350       SMESH::long_array_var anElementsId = theObject->GetIDs();
2351       mirror(anElementsId, theMirror, theMirrorType,
2352              false, theCopyGroups, & mesh_i->GetImpl());
2353       mesh_i->CreateGroupServants();
2354     }
2355
2356     if ( !myPreviewMode ) {
2357       pydump << mesh << " = " << this << ".MirrorObjectMakeMesh( "
2358              << theObject << ", "
2359              << theMirror   << ", "
2360              << mirrorTypeName(theMirrorType) << ", "
2361              << theCopyGroups << ", '"
2362              << theMeshName << "' )";
2363     }
2364   } 
2365
2366   //dump "GetGroups"
2367   if(!myPreviewMode && mesh_i)
2368     mesh_i->GetGroups();
2369   
2370   return mesh._retn();
2371 }
2372
2373 //=======================================================================
2374 //function : translate
2375 //purpose  : 
2376 //=======================================================================
2377
2378 SMESH::ListOfGroups*
2379 SMESH_MeshEditor_i::translate(const SMESH::long_array & theIDsOfElements,
2380                               const SMESH::DirStruct &  theVector,
2381                               CORBA::Boolean            theCopy,
2382                               const bool                theMakeGroups,
2383                               ::SMESH_Mesh*             theTargetMesh)
2384 {
2385   initData();
2386
2387   TIDSortedElemSet elements;
2388   arrayToSet(theIDsOfElements, GetMeshDS(), elements);
2389
2390   gp_Trsf aTrsf;
2391   const SMESH::PointStruct * P = &theVector.PS;
2392   aTrsf.SetTranslation( gp_Vec( P->x, P->y, P->z ));
2393
2394   ::SMESH_MeshEditor anEditor( myMesh );
2395   ::SMESH_MeshEditor::PGroupIDs groupIds =
2396       anEditor.Transform (elements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
2397
2398   if(theCopy)
2399     storeResult(anEditor);
2400
2401   return theMakeGroups ? getGroups(groupIds.get()) : 0;
2402 }
2403
2404 //=======================================================================
2405 //function : Translate
2406 //purpose  :
2407 //=======================================================================
2408
2409 void SMESH_MeshEditor_i::Translate(const SMESH::long_array & theIDsOfElements,
2410                                    const SMESH::DirStruct &  theVector,
2411                                    CORBA::Boolean            theCopy)
2412 {
2413   if ( !myPreviewMode ) {
2414     TPythonDump() << this << ".Translate( "
2415                   << theIDsOfElements << ", "
2416                   << theVector << ", "
2417                   << theCopy << " )";
2418   }
2419   translate(theIDsOfElements,
2420             theVector,
2421             theCopy,
2422             false);
2423 }
2424
2425 //=======================================================================
2426 //function : TranslateObject
2427 //purpose  :
2428 //=======================================================================
2429
2430 void SMESH_MeshEditor_i::TranslateObject(SMESH::SMESH_IDSource_ptr theObject,
2431                                          const SMESH::DirStruct &  theVector,
2432                                          CORBA::Boolean            theCopy)
2433 {
2434   if ( !myPreviewMode ) {
2435     TPythonDump() << this << ".TranslateObject( "
2436                   << theObject << ", "
2437                   << theVector << ", "
2438                   << theCopy << " )";
2439   }
2440   SMESH::long_array_var anElementsId = theObject->GetIDs();
2441   translate(anElementsId,
2442             theVector,
2443             theCopy,
2444             false);
2445 }
2446
2447 //=======================================================================
2448 //function : TranslateMakeGroups
2449 //purpose  : 
2450 //=======================================================================
2451
2452 SMESH::ListOfGroups*
2453 SMESH_MeshEditor_i::TranslateMakeGroups(const SMESH::long_array& theIDsOfElements,
2454                                         const SMESH::DirStruct&  theVector)
2455 {
2456   SMESH::ListOfGroups * aGroups = translate(theIDsOfElements,theVector,true,true);
2457   if ( !myPreviewMode ) {
2458     TPythonDump aPythonDump;
2459     DumpGroupsList(aPythonDump,aGroups);
2460     aPythonDump << this << ".TranslateMakeGroups( "
2461                 << theIDsOfElements << ", "
2462                 << theVector << " )";
2463   }
2464   return aGroups;
2465 }
2466
2467 //=======================================================================
2468 //function : TranslateObjectMakeGroups
2469 //purpose  : 
2470 //=======================================================================
2471
2472 SMESH::ListOfGroups*
2473 SMESH_MeshEditor_i::TranslateObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
2474                                               const SMESH::DirStruct&   theVector)
2475 {
2476   SMESH::long_array_var anElementsId = theObject->GetIDs();
2477   SMESH::ListOfGroups * aGroups = translate(anElementsId, theVector, true, true);
2478   
2479   if ( !myPreviewMode ) {
2480
2481     TPythonDump aPythonDump;
2482     DumpGroupsList(aPythonDump,aGroups);
2483     aPythonDump << this << ".TranslateObjectMakeGroups( "
2484                 << theObject << ", "
2485                 << theVector << " )";
2486   }
2487   return aGroups;
2488 }
2489
2490 //=======================================================================
2491 //function : TranslateMakeMesh
2492 //purpose  : 
2493 //=======================================================================
2494
2495 SMESH::SMESH_Mesh_ptr
2496 SMESH_MeshEditor_i::TranslateMakeMesh(const SMESH::long_array& theIDsOfElements,
2497                                       const SMESH::DirStruct&  theVector,
2498                                       CORBA::Boolean           theCopyGroups,
2499                                       const char*              theMeshName)
2500 {
2501   SMESH_Mesh_i* mesh_i;
2502   SMESH::SMESH_Mesh_var mesh;
2503   
2504   { // open new scope to dump "MakeMesh" command
2505     // and then "GetGroups" using SMESH_Mesh::GetGroups()
2506
2507     TPythonDump pydump; // to prevent dump at mesh creation
2508     
2509     mesh = makeMesh( theMeshName );
2510     mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
2511     
2512     if ( mesh_i ) {
2513       translate(theIDsOfElements, theVector,
2514                 false, theCopyGroups, & mesh_i->GetImpl());
2515       mesh_i->CreateGroupServants();
2516     }
2517     
2518     if ( !myPreviewMode ) {
2519       pydump << mesh << " = " << this << ".TranslateMakeMesh( "
2520              << theIDsOfElements << ", "
2521              << theVector   << ", "
2522              << theCopyGroups << ", '"
2523              << theMeshName << "' )";
2524     }
2525   }
2526   
2527   //dump "GetGroups"
2528   if(!myPreviewMode && mesh_i)
2529     mesh_i->GetGroups();
2530   
2531   return mesh._retn();
2532 }
2533
2534 //=======================================================================
2535 //function : TranslateObjectMakeMesh
2536 //purpose  : 
2537 //=======================================================================
2538
2539 SMESH::SMESH_Mesh_ptr
2540 SMESH_MeshEditor_i::TranslateObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject,
2541                                             const SMESH::DirStruct&   theVector,
2542                                             CORBA::Boolean            theCopyGroups,
2543                                             const char*               theMeshName)
2544 {
2545   SMESH_Mesh_i* mesh_i;
2546   SMESH::SMESH_Mesh_var mesh;
2547   { // open new scope to dump "MakeMesh" command
2548     // and then "GetGroups" using SMESH_Mesh::GetGroups()
2549     
2550     TPythonDump pydump; // to prevent dump at mesh creation
2551     mesh = makeMesh( theMeshName );
2552     mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
2553     
2554     if ( mesh_i ) {
2555       SMESH::long_array_var anElementsId = theObject->GetIDs();
2556       translate(anElementsId, theVector,
2557                 false, theCopyGroups, & mesh_i->GetImpl());
2558       mesh_i->CreateGroupServants();
2559     }
2560     if ( !myPreviewMode ) {
2561       pydump << mesh << " = " << this << ".TranslateObjectMakeMesh( "
2562              << theObject << ", "
2563              << theVector   << ", "
2564              << theCopyGroups << ", '"
2565              << theMeshName << "' )";
2566     }
2567   }
2568   
2569   //dump "GetGroups"
2570   if(!myPreviewMode && mesh_i)
2571     mesh_i->GetGroups();
2572   
2573   return mesh._retn();
2574 }
2575
2576 //=======================================================================
2577 //function : rotate
2578 //purpose  : 
2579 //=======================================================================
2580
2581 SMESH::ListOfGroups*
2582 SMESH_MeshEditor_i::rotate(const SMESH::long_array & theIDsOfElements,
2583                            const SMESH::AxisStruct & theAxis,
2584                            CORBA::Double             theAngle,
2585                            CORBA::Boolean            theCopy,
2586                            const bool                theMakeGroups,
2587                            ::SMESH_Mesh*             theTargetMesh)
2588 {
2589   initData();
2590
2591   TIDSortedElemSet elements;
2592   arrayToSet(theIDsOfElements, GetMeshDS(), elements);
2593
2594   gp_Pnt P ( theAxis.x, theAxis.y, theAxis.z );
2595   gp_Vec V ( theAxis.vx, theAxis.vy, theAxis.vz );
2596
2597   gp_Trsf aTrsf;
2598   aTrsf.SetRotation( gp_Ax1( P, V ), theAngle);
2599
2600   ::SMESH_MeshEditor anEditor( myMesh );
2601   ::SMESH_MeshEditor::PGroupIDs groupIds =
2602       anEditor.Transform (elements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
2603
2604   if(theCopy) {
2605     storeResult(anEditor);
2606   }
2607   return theMakeGroups ? getGroups(groupIds.get()) : 0;
2608 }
2609
2610 //=======================================================================
2611 //function : Rotate
2612 //purpose  :
2613 //=======================================================================
2614
2615 void SMESH_MeshEditor_i::Rotate(const SMESH::long_array & theIDsOfElements,
2616                                 const SMESH::AxisStruct & theAxis,
2617                                 CORBA::Double             theAngle,
2618                                 CORBA::Boolean            theCopy)
2619 {
2620   if ( !myPreviewMode ) {
2621     TPythonDump() << this << ".Rotate( "
2622                   << theIDsOfElements << ", "
2623                   << theAxis << ", "
2624                   << theAngle << ", "
2625                   << theCopy << " )";
2626   }
2627   rotate(theIDsOfElements,
2628          theAxis,
2629          theAngle,
2630          theCopy,
2631          false);
2632 }
2633
2634 //=======================================================================
2635 //function : RotateObject
2636 //purpose  :
2637 //=======================================================================
2638
2639 void SMESH_MeshEditor_i::RotateObject(SMESH::SMESH_IDSource_ptr theObject,
2640                                       const SMESH::AxisStruct & theAxis,
2641                                       CORBA::Double             theAngle,
2642                                       CORBA::Boolean            theCopy)
2643 {
2644   if ( !myPreviewMode ) {
2645     TPythonDump() << this << ".RotateObject( "
2646                   << theObject << ", "
2647                   << theAxis << ", "
2648                   << theAngle << ", "
2649                   << theCopy << " )";
2650   }
2651   SMESH::long_array_var anElementsId = theObject->GetIDs();
2652   rotate(anElementsId,
2653          theAxis,
2654          theAngle,
2655          theCopy,
2656          false);
2657 }
2658
2659 //=======================================================================
2660 //function : RotateMakeGroups
2661 //purpose  : 
2662 //=======================================================================
2663
2664 SMESH::ListOfGroups*
2665 SMESH_MeshEditor_i::RotateMakeGroups(const SMESH::long_array& theIDsOfElements,
2666                                      const SMESH::AxisStruct& theAxis,
2667                                      CORBA::Double            theAngle)
2668 {
2669   SMESH::ListOfGroups * aGroups =  rotate(theIDsOfElements,theAxis,theAngle,true,true);
2670   if ( !myPreviewMode ) {
2671     TPythonDump aPythonDump;
2672     DumpGroupsList(aPythonDump,aGroups);
2673     aPythonDump << this << ".RotateMakeGroups( "
2674                 << theIDsOfElements << ", "
2675                 << theAxis << ", "
2676                 << theAngle << " )";
2677   }
2678   return aGroups;
2679 }
2680
2681 //=======================================================================
2682 //function : RotateObjectMakeGroups
2683 //purpose  : 
2684 //=======================================================================
2685
2686 SMESH::ListOfGroups*
2687 SMESH_MeshEditor_i::RotateObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
2688                                            const SMESH::AxisStruct&  theAxis,
2689                                            CORBA::Double             theAngle)
2690 {
2691   SMESH::long_array_var anElementsId = theObject->GetIDs();
2692   SMESH::ListOfGroups * aGroups =  rotate(anElementsId,theAxis,theAngle,true,true);
2693  
2694   if ( !myPreviewMode ) {
2695     TPythonDump aPythonDump;
2696     DumpGroupsList(aPythonDump,aGroups);
2697     aPythonDump << this << ".RotateObjectMakeGroups( "
2698                 << theObject << ", "
2699                 << theAxis << ", "
2700                 << theAngle << " )";
2701   }
2702   return aGroups;
2703 }
2704
2705 //=======================================================================
2706 //function : RotateMakeMesh
2707 //purpose  : 
2708 //=======================================================================
2709
2710 SMESH::SMESH_Mesh_ptr 
2711 SMESH_MeshEditor_i::RotateMakeMesh(const SMESH::long_array& theIDsOfElements,
2712                                    const SMESH::AxisStruct& theAxis,
2713                                    CORBA::Double            theAngleInRadians,
2714                                    CORBA::Boolean           theCopyGroups,
2715                                    const char*              theMeshName)
2716 {
2717   SMESH::SMESH_Mesh_var mesh;
2718   SMESH_Mesh_i* mesh_i;
2719
2720   { // open new scope to dump "MakeMesh" command
2721     // and then "GetGroups" using SMESH_Mesh::GetGroups()
2722     
2723     TPythonDump pydump; // to prevent dump at mesh creation
2724
2725     mesh = makeMesh( theMeshName );
2726     mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
2727     
2728     if ( mesh_i ) {
2729       rotate(theIDsOfElements, theAxis, theAngleInRadians,
2730              false, theCopyGroups, & mesh_i->GetImpl());
2731       mesh_i->CreateGroupServants();
2732     }
2733     if ( !myPreviewMode ) {
2734       pydump << mesh << " = " << this << ".RotateMakeMesh( "
2735              << theIDsOfElements << ", "
2736              << theAxis << ", "
2737              << theAngleInRadians   << ", "
2738              << theCopyGroups << ", '"
2739              << theMeshName << "' )";
2740     }
2741   }
2742   
2743   //dump "GetGroups"
2744   if(!myPreviewMode && mesh_i)
2745     mesh_i->GetGroups();
2746   
2747   return mesh._retn();
2748 }
2749
2750 //=======================================================================
2751 //function : RotateObjectMakeMesh
2752 //purpose  : 
2753 //=======================================================================
2754
2755 SMESH::SMESH_Mesh_ptr 
2756 SMESH_MeshEditor_i::RotateObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject,
2757                                          const SMESH::AxisStruct&  theAxis,
2758                                          CORBA::Double             theAngleInRadians,
2759                                          CORBA::Boolean            theCopyGroups,
2760                                          const char*               theMeshName)
2761 {
2762   SMESH::SMESH_Mesh_var mesh;
2763   SMESH_Mesh_i* mesh_i;
2764   
2765   {// open new scope to dump "MakeMesh" command
2766    // and then "GetGroups" using SMESH_Mesh::GetGroups()
2767     
2768     TPythonDump pydump; // to prevent dump at mesh creation
2769     mesh = makeMesh( theMeshName );
2770     mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
2771     
2772     if (mesh_i ) {
2773       SMESH::long_array_var anElementsId = theObject->GetIDs();
2774       rotate(anElementsId, theAxis, theAngleInRadians,
2775              false, theCopyGroups, & mesh_i->GetImpl());
2776       mesh_i->CreateGroupServants();
2777     }
2778     if ( !myPreviewMode ) {
2779       pydump << mesh << " = " << this << ".RotateObjectMakeMesh( "
2780              << theObject << ", "
2781              << theAxis << ", "
2782              << theAngleInRadians   << ", "
2783              << theCopyGroups << ", '"
2784              << theMeshName << "' )";
2785     }
2786   }
2787   
2788   //dump "GetGroups"
2789   if(!myPreviewMode && mesh_i)
2790     mesh_i->GetGroups();
2791   
2792   return mesh._retn();
2793 }
2794
2795 //=======================================================================
2796 //function : FindCoincidentNodes
2797 //purpose  :
2798 //=======================================================================
2799
2800 void SMESH_MeshEditor_i::FindCoincidentNodes (CORBA::Double                  Tolerance,
2801                                               SMESH::array_of_long_array_out GroupsOfNodes)
2802 {
2803   initData();
2804
2805   ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
2806   ::SMESH_MeshEditor anEditor( myMesh );
2807   set<const SMDS_MeshNode*> nodes; // no input nodes
2808   anEditor.FindCoincidentNodes( nodes, Tolerance, aListOfListOfNodes );
2809
2810   GroupsOfNodes = new SMESH::array_of_long_array;
2811   GroupsOfNodes->length( aListOfListOfNodes.size() );
2812   ::SMESH_MeshEditor::TListOfListOfNodes::iterator llIt = aListOfListOfNodes.begin();
2813   for ( CORBA::Long i = 0; llIt != aListOfListOfNodes.end(); llIt++, i++ ) {
2814     list< const SMDS_MeshNode* >& aListOfNodes = *llIt;
2815     list< const SMDS_MeshNode* >::iterator lIt = aListOfNodes.begin();;
2816     SMESH::long_array& aGroup = (*GroupsOfNodes)[ i ];
2817     aGroup.length( aListOfNodes.size() );
2818     for ( int j = 0; lIt != aListOfNodes.end(); lIt++, j++ )
2819       aGroup[ j ] = (*lIt)->GetID();
2820   }
2821   TPythonDump() << "coincident_nodes = " << this << ".FindCoincidentNodes( "
2822                 << Tolerance << " )";
2823 }
2824
2825 //=======================================================================
2826 //function : FindCoincidentNodesOnPart
2827 //purpose  :
2828 //=======================================================================
2829 void SMESH_MeshEditor_i::FindCoincidentNodesOnPart(SMESH::SMESH_IDSource_ptr      theObject,
2830                                                    CORBA::Double                  Tolerance,
2831                                                    SMESH::array_of_long_array_out GroupsOfNodes)
2832 {
2833   initData();
2834   SMESH::long_array_var aElementsId = theObject->GetIDs();
2835
2836   SMESHDS_Mesh* aMesh = GetMeshDS();
2837   set<const SMDS_MeshNode*> nodes;
2838
2839   if ( !CORBA::is_nil(SMESH::SMESH_GroupBase::_narrow(theObject)) &&
2840       SMESH::SMESH_GroupBase::_narrow(theObject)->GetType() == SMESH::NODE) {
2841     for(int i = 0; i < aElementsId->length(); i++) {
2842       CORBA::Long ind = aElementsId[i];
2843       const SMDS_MeshNode * elem = aMesh->FindNode(ind);
2844       if(elem)
2845         nodes.insert(elem);
2846     }
2847   }
2848   else {
2849     for(int i = 0; i < aElementsId->length(); i++) {
2850       CORBA::Long ind = aElementsId[i];
2851       const SMDS_MeshElement * elem = aMesh->FindElement(ind);
2852       if(elem) {
2853         SMDS_ElemIteratorPtr nIt = elem->nodesIterator();
2854         while ( nIt->more() )
2855           nodes.insert( nodes.end(),static_cast<const SMDS_MeshNode*>(nIt->next()));
2856       }
2857     }
2858   }
2859     
2860   
2861   ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
2862   ::SMESH_MeshEditor anEditor( myMesh );
2863   if(!nodes.empty())
2864     anEditor.FindCoincidentNodes( nodes, Tolerance, aListOfListOfNodes );
2865   
2866   GroupsOfNodes = new SMESH::array_of_long_array;
2867   GroupsOfNodes->length( aListOfListOfNodes.size() );
2868   ::SMESH_MeshEditor::TListOfListOfNodes::iterator llIt = aListOfListOfNodes.begin();
2869   for ( CORBA::Long i = 0; llIt != aListOfListOfNodes.end(); llIt++, i++ ) {
2870     list< const SMDS_MeshNode* >& aListOfNodes = *llIt;
2871     list< const SMDS_MeshNode* >::iterator lIt = aListOfNodes.begin();;
2872     SMESH::long_array& aGroup = (*GroupsOfNodes)[ i ];
2873     aGroup.length( aListOfNodes.size() );
2874     for ( int j = 0; lIt != aListOfNodes.end(); lIt++, j++ )
2875       aGroup[ j ] = (*lIt)->GetID();
2876   }
2877   TPythonDump() << "coincident_nodes_on_part = " << this << ".FindCoincidentNodesOnPart( "
2878                 <<theObject<<", "
2879                 << Tolerance << " )";
2880 }
2881
2882 //=======================================================================
2883 //function : MergeNodes
2884 //purpose  :
2885 //=======================================================================
2886
2887 void SMESH_MeshEditor_i::MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes)
2888 {
2889   initData();
2890
2891   SMESHDS_Mesh* aMesh = GetMeshDS();
2892
2893   TPythonDump aTPythonDump;
2894   aTPythonDump << this << ".MergeNodes([";
2895   ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
2896   for (int i = 0; i < GroupsOfNodes.length(); i++)
2897   {
2898     const SMESH::long_array& aNodeGroup = GroupsOfNodes[ i ];
2899     aListOfListOfNodes.push_back( list< const SMDS_MeshNode* >() );
2900     list< const SMDS_MeshNode* >& aListOfNodes = aListOfListOfNodes.back();
2901     for ( int j = 0; j < aNodeGroup.length(); j++ )
2902     {
2903       CORBA::Long index = aNodeGroup[ j ];
2904       const SMDS_MeshNode * node = aMesh->FindNode(index);
2905       if ( node )
2906         aListOfNodes.push_back( node );
2907     }
2908     if ( aListOfNodes.size() < 2 )
2909       aListOfListOfNodes.pop_back();
2910
2911     if ( i > 0 ) aTPythonDump << ", ";
2912     aTPythonDump << aNodeGroup;
2913   }
2914   ::SMESH_MeshEditor anEditor( myMesh );
2915   anEditor.MergeNodes( aListOfListOfNodes );
2916
2917   aTPythonDump <<  "])";
2918 }
2919
2920 //=======================================================================
2921 //function : FindEqualElements
2922 //purpose  :
2923 //=======================================================================
2924 void SMESH_MeshEditor_i::FindEqualElements(SMESH::SMESH_IDSource_ptr      theObject,
2925                                            SMESH::array_of_long_array_out GroupsOfElementsID)
2926 {
2927   initData();
2928   if ( !(!CORBA::is_nil(SMESH::SMESH_GroupBase::_narrow(theObject)) &&
2929          SMESH::SMESH_GroupBase::_narrow(theObject)->GetType() == SMESH::NODE) ) {
2930     typedef list<int> TListOfIDs;
2931     set<const SMDS_MeshElement*> elems;
2932     SMESH::long_array_var aElementsId = theObject->GetIDs();
2933     SMESHDS_Mesh* aMesh = GetMeshDS();
2934
2935     for(int i = 0; i < aElementsId->length(); i++) {
2936       CORBA::Long anID = aElementsId[i];
2937       const SMDS_MeshElement * elem = aMesh->FindElement(anID);
2938       if (elem) {
2939         elems.insert(elem);
2940       }
2941     }
2942
2943     ::SMESH_MeshEditor::TListOfListOfElementsID aListOfListOfElementsID;
2944     ::SMESH_MeshEditor anEditor( myMesh );
2945     anEditor.FindEqualElements( elems, aListOfListOfElementsID );
2946
2947     GroupsOfElementsID = new SMESH::array_of_long_array;
2948     GroupsOfElementsID->length( aListOfListOfElementsID.size() );
2949
2950     ::SMESH_MeshEditor::TListOfListOfElementsID::iterator arraysIt = aListOfListOfElementsID.begin();
2951     for (CORBA::Long j = 0; arraysIt != aListOfListOfElementsID.end(); ++arraysIt, ++j) {
2952       SMESH::long_array& aGroup = (*GroupsOfElementsID)[ j ];
2953       TListOfIDs& listOfIDs = *arraysIt;
2954       aGroup.length( listOfIDs.size() );
2955       TListOfIDs::iterator idIt = listOfIDs.begin();
2956       for (int k = 0; idIt != listOfIDs.end(); ++idIt, ++k ) {
2957         aGroup[ k ] = *idIt;
2958       }
2959     }
2960
2961   TPythonDump() << "equal_elements = " << this << ".FindEqualElements( "
2962                 <<theObject<<" )";
2963   }
2964 }
2965
2966 //=======================================================================
2967 //function : MergeElements
2968 //purpose  :
2969 //=======================================================================
2970
2971 void SMESH_MeshEditor_i::MergeElements(const SMESH::array_of_long_array& GroupsOfElementsID)
2972 {
2973   initData();
2974
2975   TPythonDump aTPythonDump;
2976   aTPythonDump << this << ".MergeElements( [";
2977
2978   ::SMESH_MeshEditor::TListOfListOfElementsID aListOfListOfElementsID;
2979
2980   for (int i = 0; i < GroupsOfElementsID.length(); i++) {
2981     const SMESH::long_array& anElemsIDGroup = GroupsOfElementsID[ i ];
2982     aListOfListOfElementsID.push_back( list< int >() );
2983     list< int >& aListOfElemsID = aListOfListOfElementsID.back();
2984     for ( int j = 0; j < anElemsIDGroup.length(); j++ ) {
2985       CORBA::Long id = anElemsIDGroup[ j ];
2986       aListOfElemsID.push_back( id );
2987     }
2988     if ( aListOfElemsID.size() < 2 )
2989       aListOfListOfElementsID.pop_back();
2990     if ( i > 0 ) aTPythonDump << ", ";
2991     aTPythonDump << anElemsIDGroup;
2992   }
2993
2994   ::SMESH_MeshEditor anEditor( myMesh );
2995   anEditor.MergeElements(aListOfListOfElementsID);
2996
2997   aTPythonDump << "] )";
2998 }
2999
3000 //=======================================================================
3001 //function : MergeEqualElements
3002 //purpose  :
3003 //=======================================================================
3004
3005 void SMESH_MeshEditor_i::MergeEqualElements()
3006 {
3007   initData();
3008
3009   ::SMESH_MeshEditor anEditor( myMesh );
3010   anEditor.MergeEqualElements();
3011
3012   TPythonDump() << this << ".MergeEqualElements()";
3013 }
3014
3015 //=============================================================================
3016 /*!
3017  * Move the node to a given point
3018  */
3019 //=============================================================================
3020
3021 CORBA::Boolean SMESH_MeshEditor_i::MoveNode(CORBA::Long   NodeID,
3022                                             CORBA::Double x,
3023                                             CORBA::Double y,
3024                                             CORBA::Double z)
3025 {
3026   initData(/*deleteSearchers=*/false);
3027
3028   const SMDS_MeshNode * node = GetMeshDS()->FindNode( NodeID );
3029   if ( !node )
3030     return false;
3031
3032   if ( theNodeSearcher )
3033     theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other
3034
3035   if ( theNodeSearcher ) // move node and update theNodeSearcher data accordingly
3036     theNodeSearcher->MoveNode(node, gp_Pnt( x,y,z ));
3037   else
3038     GetMeshDS()->MoveNode(node, x, y, z);
3039
3040   // Update Python script
3041   TPythonDump() << "isDone = " << this << ".MoveNode( "
3042                 << NodeID << ", " << x << ", " << y << ", " << z << " )";
3043
3044   return true;
3045 }
3046
3047 //================================================================================
3048 /*!
3049  * \brief Return ID of node closest to a given point
3050  */
3051 //================================================================================
3052
3053 CORBA::Long SMESH_MeshEditor_i::FindNodeClosestTo(CORBA::Double x,
3054                                                   CORBA::Double y,
3055                                                   CORBA::Double z)
3056 {
3057   theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other
3058
3059   if ( !theNodeSearcher ) {
3060     ::SMESH_MeshEditor anEditor( myMesh );
3061     theNodeSearcher = anEditor.GetNodeSearcher();
3062   }
3063   gp_Pnt p( x,y,z );
3064   if ( const SMDS_MeshNode* node = theNodeSearcher->FindClosestTo( p ))
3065     return node->GetID();
3066
3067   return 0;
3068 }
3069
3070 //================================================================================
3071 /*!
3072  * \brief If the given ID is a valid node ID (nodeID > 0), just move this node, else
3073  * move the node closest to the point to point's location and return ID of the node
3074  */
3075 //================================================================================
3076
3077 CORBA::Long SMESH_MeshEditor_i::MoveClosestNodeToPoint(CORBA::Double x,
3078                                                        CORBA::Double y,
3079                                                        CORBA::Double z,
3080                                                        CORBA::Long   theNodeID)
3081 {
3082   // We keep theNodeSearcher until any mesh modification:
3083   // 1) initData() deletes theNodeSearcher at any edition,
3084   // 2) TSearchersDeleter - at any mesh compute event and mesh change
3085
3086   initData(/*deleteSearchers=*/false);
3087
3088   theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other
3089
3090   int nodeID = theNodeID;
3091   const SMDS_MeshNode* node = GetMeshDS()->FindNode( nodeID );
3092   if ( !node ) // preview moving node
3093   {
3094     if ( !theNodeSearcher ) {
3095       ::SMESH_MeshEditor anEditor( myMesh );
3096       theNodeSearcher = anEditor.GetNodeSearcher();
3097     }
3098     gp_Pnt p( x,y,z );
3099     node = theNodeSearcher->FindClosestTo( p );
3100   }
3101   if ( node ) {
3102     nodeID = node->GetID();
3103     if ( myPreviewMode ) // make preview data
3104     {
3105       // in a preview mesh, make edges linked to a node
3106       TPreviewMesh tmpMesh;
3107       TIDSortedElemSet linkedNodes;
3108       ::SMESH_MeshEditor::GetLinkedNodes( node, linkedNodes );
3109       TIDSortedElemSet::iterator nIt = linkedNodes.begin();
3110       for ( ; nIt != linkedNodes.end(); ++nIt )
3111       {
3112         SMDS_MeshEdge edge( node, cast2Node( *nIt ));
3113         tmpMesh.Copy( &edge );
3114       }
3115       // move copied node
3116       node = tmpMesh.GetMeshDS()->FindNode( nodeID );
3117       if ( node )
3118         tmpMesh.GetMeshDS()->MoveNode(node, x, y, z);
3119       // fill preview data
3120       ::SMESH_MeshEditor anEditor( & tmpMesh );
3121       storeResult( anEditor );
3122     }
3123     else if ( theNodeSearcher ) // move node and update theNodeSearcher data accordingly
3124     {
3125       theNodeSearcher->MoveNode(node, gp_Pnt( x,y,z ));
3126     }
3127     else
3128     {
3129       GetMeshDS()->MoveNode(node, x, y, z);
3130     }
3131   }
3132
3133   if ( !myPreviewMode ) {
3134     TPythonDump() << "nodeID = " << this
3135                   << ".MoveClosestNodeToPoint( "<< x << ", " << y << ", " << z
3136                   << ", " << nodeID << " )";
3137   }
3138
3139   return nodeID;
3140 }
3141
3142 //=======================================================================
3143 /*!
3144  * Return elements of given type where the given point is IN or ON.
3145  *
3146  * 'ALL' type means elements of any type excluding nodes
3147  */
3148 //=======================================================================
3149
3150 SMESH::long_array* SMESH_MeshEditor_i::FindElementsByPoint(CORBA::Double      x,
3151                                                            CORBA::Double      y,
3152                                                            CORBA::Double      z,
3153                                                            SMESH::ElementType type)
3154 {
3155   SMESH::long_array_var res = new SMESH::long_array;
3156   vector< const SMDS_MeshElement* > foundElems;
3157
3158   theSearchersDeleter.Set( myMesh );
3159   if ( !theElementSearcher ) {
3160     ::SMESH_MeshEditor anEditor( myMesh );
3161     theElementSearcher = anEditor.GetElementSearcher();
3162   }
3163   theElementSearcher->FindElementsByPoint( gp_Pnt( x,y,z ),
3164                                            SMDSAbs_ElementType( type ),
3165                                            foundElems);
3166   res->length( foundElems.size() );
3167   for ( int i = 0; i < foundElems.size(); ++i )
3168     res[i] = foundElems[i]->GetID();
3169
3170   if ( !myPreviewMode ) // call from tui
3171     TPythonDump() << res << " = " << this << ".FindElementsByPoint( "
3172                   << x << ", "
3173                   << y << ", "
3174                   << z << ", "
3175                   << type << " )";
3176
3177   return res._retn();
3178 }
3179
3180 //=======================================================================
3181 //function : convError
3182 //purpose  :
3183 //=======================================================================
3184
3185 #define RETCASE(enm) case ::SMESH_MeshEditor::enm: return SMESH::SMESH_MeshEditor::enm;
3186
3187 static SMESH::SMESH_MeshEditor::Sew_Error convError( const::SMESH_MeshEditor::Sew_Error e )
3188 {
3189   switch ( e ) {
3190   RETCASE( SEW_OK );
3191   RETCASE( SEW_BORDER1_NOT_FOUND );
3192   RETCASE( SEW_BORDER2_NOT_FOUND );
3193   RETCASE( SEW_BOTH_BORDERS_NOT_FOUND );
3194   RETCASE( SEW_BAD_SIDE_NODES );
3195   RETCASE( SEW_VOLUMES_TO_SPLIT );
3196   RETCASE( SEW_DIFF_NB_OF_ELEMENTS );
3197   RETCASE( SEW_TOPO_DIFF_SETS_OF_ELEMENTS );
3198   RETCASE( SEW_BAD_SIDE1_NODES );
3199   RETCASE( SEW_BAD_SIDE2_NODES );
3200   }
3201   return SMESH::SMESH_MeshEditor::SEW_OK;
3202 }
3203
3204 //=======================================================================
3205 //function : SewFreeBorders
3206 //purpose  :
3207 //=======================================================================
3208
3209 SMESH::SMESH_MeshEditor::Sew_Error
3210   SMESH_MeshEditor_i::SewFreeBorders(CORBA::Long FirstNodeID1,
3211                                      CORBA::Long SecondNodeID1,
3212                                      CORBA::Long LastNodeID1,
3213                                      CORBA::Long FirstNodeID2,
3214                                      CORBA::Long SecondNodeID2,
3215                                      CORBA::Long LastNodeID2,
3216                                      CORBA::Boolean CreatePolygons,
3217                                      CORBA::Boolean CreatePolyedrs)
3218 {
3219   initData();
3220
3221   SMESHDS_Mesh* aMesh = GetMeshDS();
3222
3223   const SMDS_MeshNode* aBorderFirstNode  = aMesh->FindNode( FirstNodeID1  );
3224   const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeID1 );
3225   const SMDS_MeshNode* aBorderLastNode   = aMesh->FindNode( LastNodeID1   );
3226   const SMDS_MeshNode* aSide2FirstNode   = aMesh->FindNode( FirstNodeID2  );
3227   const SMDS_MeshNode* aSide2SecondNode  = aMesh->FindNode( SecondNodeID2 );
3228   const SMDS_MeshNode* aSide2ThirdNode   = aMesh->FindNode( LastNodeID2   );
3229
3230   if (!aBorderFirstNode ||
3231       !aBorderSecondNode||
3232       !aBorderLastNode)
3233     return SMESH::SMESH_MeshEditor::SEW_BORDER1_NOT_FOUND;
3234   if (!aSide2FirstNode  ||
3235       !aSide2SecondNode ||
3236       !aSide2ThirdNode)
3237     return SMESH::SMESH_MeshEditor::SEW_BORDER2_NOT_FOUND;
3238
3239   TPythonDump() << "error = " << this << ".SewFreeBorders( "
3240                 << FirstNodeID1  << ", "
3241                 << SecondNodeID1 << ", "
3242                 << LastNodeID1   << ", "
3243                 << FirstNodeID2  << ", "
3244                 << SecondNodeID2 << ", "
3245                 << LastNodeID2   << ", "
3246                 << CreatePolygons<< ", "
3247                 << CreatePolyedrs<< " )";
3248
3249   ::SMESH_MeshEditor anEditor( myMesh );
3250   SMESH::SMESH_MeshEditor::Sew_Error error =
3251     convError( anEditor.SewFreeBorder (aBorderFirstNode,
3252                                        aBorderSecondNode,
3253                                        aBorderLastNode,
3254                                        aSide2FirstNode,
3255                                        aSide2SecondNode,
3256                                        aSide2ThirdNode,
3257                                        true,
3258                                        CreatePolygons,
3259                                        CreatePolyedrs) );
3260
3261   storeResult(anEditor);
3262
3263   return error;
3264 }
3265
3266
3267 //=======================================================================
3268 //function : SewConformFreeBorders
3269 //purpose  :
3270 //=======================================================================
3271
3272 SMESH::SMESH_MeshEditor::Sew_Error
3273 SMESH_MeshEditor_i::SewConformFreeBorders(CORBA::Long FirstNodeID1,
3274                                           CORBA::Long SecondNodeID1,
3275                                           CORBA::Long LastNodeID1,
3276                                           CORBA::Long FirstNodeID2,
3277                                           CORBA::Long SecondNodeID2)
3278 {
3279   initData();
3280
3281   SMESHDS_Mesh* aMesh = GetMeshDS();
3282
3283   const SMDS_MeshNode* aBorderFirstNode  = aMesh->FindNode( FirstNodeID1  );
3284   const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeID1 );
3285   const SMDS_MeshNode* aBorderLastNode   = aMesh->FindNode( LastNodeID1   );
3286   const SMDS_MeshNode* aSide2FirstNode   = aMesh->FindNode( FirstNodeID2  );
3287   const SMDS_MeshNode* aSide2SecondNode  = aMesh->FindNode( SecondNodeID2 );
3288   const SMDS_MeshNode* aSide2ThirdNode   = 0;
3289
3290   if (!aBorderFirstNode ||
3291       !aBorderSecondNode||
3292       !aBorderLastNode )
3293     return SMESH::SMESH_MeshEditor::SEW_BORDER1_NOT_FOUND;
3294   if (!aSide2FirstNode  ||
3295       !aSide2SecondNode)
3296     return SMESH::SMESH_MeshEditor::SEW_BORDER2_NOT_FOUND;
3297
3298   TPythonDump() << "error = " << this << ".SewConformFreeBorders( "
3299                 << FirstNodeID1  << ", "
3300                 << SecondNodeID1 << ", "
3301                 << LastNodeID1   << ", "
3302                 << FirstNodeID2  << ", "
3303                 << SecondNodeID2 << " )";
3304
3305   ::SMESH_MeshEditor anEditor( myMesh );
3306   SMESH::SMESH_MeshEditor::Sew_Error error =
3307     convError( anEditor.SewFreeBorder (aBorderFirstNode,
3308                                        aBorderSecondNode,
3309                                        aBorderLastNode,
3310                                        aSide2FirstNode,
3311                                        aSide2SecondNode,
3312                                        aSide2ThirdNode,
3313                                        true,
3314                                        false, false) );
3315
3316   storeResult(anEditor);
3317
3318   return error;
3319 }
3320
3321
3322 //=======================================================================
3323 //function : SewBorderToSide
3324 //purpose  :
3325 //=======================================================================
3326
3327 SMESH::SMESH_MeshEditor::Sew_Error
3328 SMESH_MeshEditor_i::SewBorderToSide(CORBA::Long FirstNodeIDOnFreeBorder,
3329                                     CORBA::Long SecondNodeIDOnFreeBorder,
3330                                     CORBA::Long LastNodeIDOnFreeBorder,
3331                                     CORBA::Long FirstNodeIDOnSide,
3332                                     CORBA::Long LastNodeIDOnSide,
3333                                     CORBA::Boolean CreatePolygons,
3334                                     CORBA::Boolean CreatePolyedrs)
3335 {
3336   initData();
3337
3338   SMESHDS_Mesh* aMesh = GetMeshDS();
3339
3340   const SMDS_MeshNode* aBorderFirstNode  = aMesh->FindNode( FirstNodeIDOnFreeBorder  );
3341   const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeIDOnFreeBorder );
3342   const SMDS_MeshNode* aBorderLastNode   = aMesh->FindNode( LastNodeIDOnFreeBorder   );
3343   const SMDS_MeshNode* aSide2FirstNode   = aMesh->FindNode( FirstNodeIDOnSide  );
3344   const SMDS_MeshNode* aSide2SecondNode  = aMesh->FindNode( LastNodeIDOnSide );
3345   const SMDS_MeshNode* aSide2ThirdNode   = 0;
3346
3347   if (!aBorderFirstNode ||
3348       !aBorderSecondNode||
3349       !aBorderLastNode  )
3350     return SMESH::SMESH_MeshEditor::SEW_BORDER1_NOT_FOUND;
3351   if (!aSide2FirstNode  ||
3352       !aSide2SecondNode)
3353     return SMESH::SMESH_MeshEditor::SEW_BAD_SIDE_NODES;
3354
3355   TPythonDump() << "error = " << this << ".SewBorderToSide( "
3356                 << FirstNodeIDOnFreeBorder  << ", "
3357                 << SecondNodeIDOnFreeBorder << ", "
3358                 << LastNodeIDOnFreeBorder   << ", "
3359                 << FirstNodeIDOnSide        << ", "
3360                 << LastNodeIDOnSide         << ", "
3361                 << CreatePolygons           << ", "
3362                 << CreatePolyedrs           << ") ";
3363
3364   ::SMESH_MeshEditor anEditor( myMesh );
3365   SMESH::SMESH_MeshEditor::Sew_Error error =
3366     convError( anEditor.SewFreeBorder (aBorderFirstNode,
3367                                        aBorderSecondNode,
3368                                        aBorderLastNode,
3369                                        aSide2FirstNode,
3370                                        aSide2SecondNode,
3371                                        aSide2ThirdNode,
3372                                        false,
3373                                        CreatePolygons,
3374                                        CreatePolyedrs) );
3375
3376   storeResult(anEditor);
3377
3378   return error;
3379 }
3380
3381
3382 //=======================================================================
3383 //function : SewSideElements
3384 //purpose  :
3385 //=======================================================================
3386
3387 SMESH::SMESH_MeshEditor::Sew_Error
3388 SMESH_MeshEditor_i::SewSideElements(const SMESH::long_array& IDsOfSide1Elements,
3389                                     const SMESH::long_array& IDsOfSide2Elements,
3390                                     CORBA::Long NodeID1OfSide1ToMerge,
3391                                     CORBA::Long NodeID1OfSide2ToMerge,
3392                                     CORBA::Long NodeID2OfSide1ToMerge,
3393                                     CORBA::Long NodeID2OfSide2ToMerge)
3394 {
3395   initData();
3396
3397   SMESHDS_Mesh* aMesh = GetMeshDS();
3398
3399   const SMDS_MeshNode* aFirstNode1ToMerge  = aMesh->FindNode( NodeID1OfSide1ToMerge );
3400   const SMDS_MeshNode* aFirstNode2ToMerge  = aMesh->FindNode( NodeID1OfSide2ToMerge );
3401   const SMDS_MeshNode* aSecondNode1ToMerge = aMesh->FindNode( NodeID2OfSide1ToMerge );
3402   const SMDS_MeshNode* aSecondNode2ToMerge = aMesh->FindNode( NodeID2OfSide2ToMerge );
3403
3404   if (!aFirstNode1ToMerge ||
3405       !aFirstNode2ToMerge )
3406     return SMESH::SMESH_MeshEditor::SEW_BAD_SIDE1_NODES;
3407   if (!aSecondNode1ToMerge||
3408       !aSecondNode2ToMerge)
3409     return SMESH::SMESH_MeshEditor::SEW_BAD_SIDE2_NODES;
3410
3411   TIDSortedElemSet aSide1Elems, aSide2Elems;
3412   arrayToSet(IDsOfSide1Elements, aMesh, aSide1Elems);
3413   arrayToSet(IDsOfSide2Elements, aMesh, aSide2Elems);
3414
3415   TPythonDump() << "error = " << this << ".SewSideElements( "
3416                 << IDsOfSide1Elements << ", "
3417                 << IDsOfSide2Elements << ", "
3418                 << NodeID1OfSide1ToMerge << ", "
3419                 << NodeID1OfSide2ToMerge << ", "
3420                 << NodeID2OfSide1ToMerge << ", "
3421                 << NodeID2OfSide2ToMerge << ")";
3422
3423   ::SMESH_MeshEditor anEditor( myMesh );
3424   SMESH::SMESH_MeshEditor::Sew_Error error =
3425     convError( anEditor.SewSideElements (aSide1Elems, aSide2Elems,
3426                                          aFirstNode1ToMerge,
3427                                          aFirstNode2ToMerge,
3428                                          aSecondNode1ToMerge,
3429                                          aSecondNode2ToMerge));
3430
3431   storeResult(anEditor);
3432
3433   return error;
3434 }
3435
3436 //================================================================================
3437 /*!
3438  * \brief Set new nodes for given element
3439   * \param ide - element id
3440   * \param newIDs - new node ids
3441   * \retval CORBA::Boolean - true if result is OK
3442  */
3443 //================================================================================
3444
3445 CORBA::Boolean SMESH_MeshEditor_i::ChangeElemNodes(CORBA::Long ide,
3446                                                    const SMESH::long_array& newIDs)
3447 {
3448   initData();
3449
3450   const SMDS_MeshElement* elem = GetMeshDS()->FindElement(ide);
3451   if(!elem) return false;
3452
3453   int nbn = newIDs.length();
3454   int i=0;
3455   vector<const SMDS_MeshNode*> aNodes(nbn);
3456   int nbn1=-1;
3457   for(; i<nbn; i++) {
3458     const SMDS_MeshNode* aNode = GetMeshDS()->FindNode(newIDs[i]);
3459     if(aNode) {
3460       nbn1++;
3461       aNodes[nbn1] = aNode;
3462     }
3463   }
3464   TPythonDump() << "isDone = " << this << ".ChangeElemNodes( "
3465                 << ide << ", " << newIDs << " )";
3466 #ifdef _DEBUG_
3467   TPythonDump() << "print 'ChangeElemNodes: ', isDone";
3468 #endif
3469
3470   return GetMeshDS()->ChangeElementNodes( elem, & aNodes[0], nbn1+1 );
3471 }
3472   
3473 //================================================================================
3474 /*!
3475  * \brief Update myLastCreated* or myPreviewData
3476   * \param anEditor - it contains last modification results
3477  */
3478 //================================================================================
3479
3480 void SMESH_MeshEditor_i::storeResult(::SMESH_MeshEditor& anEditor)
3481 {
3482   if ( myPreviewMode ) { // --- MeshPreviewStruct filling --- 
3483
3484     list<int> aNodesConnectivity;
3485     typedef map<int, int> TNodesMap;
3486     TNodesMap nodesMap;
3487
3488     TPreviewMesh * aPreviewMesh = dynamic_cast< TPreviewMesh* >( anEditor.GetMesh() );
3489     SMDSAbs_ElementType previewType = aPreviewMesh->myPreviewType;
3490
3491     SMESHDS_Mesh* aMeshDS = anEditor.GetMeshDS();
3492     int nbEdges = aMeshDS->NbEdges();
3493     int nbFaces = aMeshDS->NbFaces();
3494     int nbVolum = aMeshDS->NbVolumes();
3495     switch ( previewType ) {
3496     case SMDSAbs_Edge  : nbFaces = nbVolum = 0; break;
3497     case SMDSAbs_Face  : nbEdges = nbVolum = 0; break;
3498     case SMDSAbs_Volume: nbEdges = nbFaces = 0; break;
3499     default:;
3500     }
3501     myPreviewData->nodesXYZ.length(aMeshDS->NbNodes());
3502     myPreviewData->elementTypes.length(nbEdges + nbFaces + nbVolum);
3503     int i = 0, j = 0;
3504     SMDS_ElemIteratorPtr itMeshElems = aMeshDS->elementsIterator();
3505
3506     while ( itMeshElems->more() ) {
3507       const SMDS_MeshElement* aMeshElem = itMeshElems->next();
3508       if ( previewType != SMDSAbs_All && aMeshElem->GetType() != previewType )
3509         continue;
3510
3511       SMDS_ElemIteratorPtr itElemNodes = aMeshElem->nodesIterator();
3512       while ( itElemNodes->more() ) {
3513         const SMDS_MeshNode* aMeshNode = 
3514           static_cast<const SMDS_MeshNode*>( itElemNodes->next() );
3515         int aNodeID = aMeshNode->GetID();
3516         TNodesMap::iterator anIter = nodesMap.find(aNodeID);
3517         if ( anIter == nodesMap.end() ) {
3518           // filling the nodes coordinates
3519           myPreviewData->nodesXYZ[j].x = aMeshNode->X();
3520           myPreviewData->nodesXYZ[j].y = aMeshNode->Y();
3521           myPreviewData->nodesXYZ[j].z = aMeshNode->Z();
3522           anIter = nodesMap.insert( make_pair(aNodeID, j) ).first;
3523           j++;
3524         }
3525         aNodesConnectivity.push_back(anIter->second);
3526       }
3527
3528       // filling the elements types
3529       SMDSAbs_ElementType aType;
3530       bool isPoly;
3531       /*if (aMeshElem->GetType() == SMDSAbs_Volume) {
3532         aType = SMDSAbs_Node;
3533         isPoly = false;
3534       }
3535       else*/ {
3536         aType = aMeshElem->GetType();
3537         isPoly = aMeshElem->IsPoly();
3538       }
3539
3540       myPreviewData->elementTypes[i].SMDS_ElementType = (SMESH::ElementType) aType;
3541       myPreviewData->elementTypes[i].isPoly = isPoly;
3542       myPreviewData->elementTypes[i].nbNodesInElement = aMeshElem->NbNodes();
3543       i++;
3544
3545     }
3546     myPreviewData->nodesXYZ.length( j );
3547
3548     // filling the elements connectivities
3549     list<int>::iterator aConnIter = aNodesConnectivity.begin();
3550     myPreviewData->elementConnectivities.length(aNodesConnectivity.size());
3551     for( int i = 0; aConnIter != aNodesConnectivity.end(); aConnIter++, i++ )
3552       myPreviewData->elementConnectivities[i] = *aConnIter;
3553     
3554     return;
3555   }
3556
3557   {
3558     // add new nodes into myLastCreatedNodes
3559     const SMESH_SequenceOfElemPtr& aSeq = anEditor.GetLastCreatedNodes();
3560     myLastCreatedNodes->length(aSeq.Length());
3561     for(int i=0; i<aSeq.Length(); i++)
3562       myLastCreatedNodes[i] = aSeq.Value(i+1)->GetID();
3563   }
3564   {
3565     // add new elements into myLastCreatedElems
3566     const SMESH_SequenceOfElemPtr& aSeq = anEditor.GetLastCreatedElems();
3567     myLastCreatedElems->length(aSeq.Length());
3568     for(int i=0; i<aSeq.Length(); i++)
3569       myLastCreatedElems[i] = aSeq.Value(i+1)->GetID();
3570   }
3571 }
3572
3573 //================================================================================
3574 /*!
3575  * Return data of mesh edition preview
3576  */
3577 //================================================================================
3578
3579 SMESH::MeshPreviewStruct* SMESH_MeshEditor_i::GetPreviewData()
3580 {
3581   return myPreviewData._retn();
3582 }
3583
3584 //================================================================================
3585 /*!
3586  * \brief Returns list of it's IDs of created nodes
3587   * \retval SMESH::long_array* - list of node ID
3588  */
3589 //================================================================================
3590
3591 SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedNodes()
3592 {
3593   return myLastCreatedNodes._retn();
3594 }
3595
3596 //================================================================================
3597 /*!
3598  * \brief Returns list of it's IDs of created elements
3599   * \retval SMESH::long_array* - list of elements' ID
3600  */
3601 //================================================================================
3602
3603 SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedElems()
3604 {
3605   return myLastCreatedElems._retn();
3606 }
3607
3608 //=======================================================================
3609 //function : ConvertToQuadratic
3610 //purpose  :
3611 //=======================================================================
3612
3613 void SMESH_MeshEditor_i::ConvertToQuadratic(CORBA::Boolean theForce3d)
3614 {
3615   ::SMESH_MeshEditor anEditor( myMesh );
3616   anEditor.ConvertToQuadratic(theForce3d);
3617   TPythonDump() << this << ".ConvertToQuadratic( " << theForce3d << " )";
3618 }
3619
3620 //=======================================================================
3621 //function : ConvertFromQuadratic
3622 //purpose  : 
3623 //=======================================================================
3624
3625 CORBA::Boolean SMESH_MeshEditor_i::ConvertFromQuadratic()
3626 {
3627   ::SMESH_MeshEditor anEditor( myMesh );
3628   CORBA::Boolean isDone = anEditor.ConvertFromQuadratic();
3629   TPythonDump() << this << ".ConvertFromQuadratic()";
3630   return isDone;
3631 }
3632
3633 //=======================================================================
3634 //function : makeMesh
3635 //purpose  : create a named imported mesh 
3636 //=======================================================================
3637
3638 SMESH::SMESH_Mesh_ptr SMESH_MeshEditor_i::makeMesh(const char* theMeshName)
3639 {
3640   SMESH_Gen_i* gen = SMESH_Gen_i::GetSMESHGen();
3641   SMESH::SMESH_Mesh_var mesh = gen->CreateEmptyMesh();
3642   SALOMEDS::Study_var study = gen->GetCurrentStudy();
3643   SALOMEDS::SObject_var meshSO = gen->ObjectToSObject( study, mesh );
3644   gen->SetName( meshSO, theMeshName, "Mesh" );
3645   gen->SetPixMap( meshSO, "ICON_SMESH_TREE_MESH_IMPORTED");
3646
3647   return mesh._retn();
3648 }
3649
3650 //=======================================================================
3651 //function : DumpGroupsList
3652 //purpose  :
3653 //=======================================================================
3654 void SMESH_MeshEditor_i::DumpGroupsList(TPythonDump &               theDumpPython, 
3655                                         const SMESH::ListOfGroups * theGroupList)
3656 {
3657   bool isDumpGroupList = theGroupList && theGroupList->length() > 0;
3658   if(isDumpGroupList) {
3659     theDumpPython << theGroupList << " = ";
3660   }
3661 }
3662
3663 //================================================================================
3664 /*!
3665   \brief Creates a hole in a mesh by doubling the nodes of some particular elements
3666   \param theElems - the list of elements (edges or faces) to be replicated
3667         The nodes for duplication could be found from these elements
3668   \param theNodesNot - list of nodes to NOT replicate
3669   \param theAffectedElems - the list of elements (cells and edges) to which the 
3670         replicated nodes should be associated to.
3671   \return TRUE if operation has been completed successfully, FALSE otherwise
3672   \sa DoubleNodeGroup(), DoubleNodeGroups()
3673 */
3674 //================================================================================
3675
3676 CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theElems, 
3677                                                 const SMESH::long_array& theNodesNot,
3678                                                 const SMESH::long_array& theAffectedElems )
3679  
3680 {
3681   initData();
3682
3683   ::SMESH_MeshEditor aMeshEditor( myMesh );
3684
3685   SMESHDS_Mesh* aMeshDS = GetMeshDS();
3686   TIDSortedElemSet anElems, aNodes, anAffected;
3687   arrayToSet(theElems, aMeshDS, anElems, SMDSAbs_All);
3688   arrayToSet(theNodesNot, aMeshDS, aNodes, SMDSAbs_Node);
3689   arrayToSet(theAffectedElems, aMeshDS, anAffected, SMDSAbs_All);
3690
3691   bool aResult = aMeshEditor.DoubleNodes( anElems, aNodes, anAffected );
3692
3693   storeResult( aMeshEditor) ;
3694
3695   return aResult;
3696 }
3697
3698 //================================================================================
3699 /*!
3700   \brief Creates a hole in a mesh by doubling the nodes of some particular elements
3701   \param theElems - the list of elements (edges or faces) to be replicated
3702         The nodes for duplication could be found from these elements
3703   \param theNodesNot - list of nodes to NOT replicate
3704   \param theShape - shape to detect affected elements (element which geometric center
3705          located on or inside shape).
3706          The replicated nodes should be associated to affected elements.
3707   \return TRUE if operation has been completed successfully, FALSE otherwise
3708   \sa DoubleNodeGroupInRegion(), DoubleNodeGroupsInRegion()
3709 */
3710 //================================================================================
3711
3712 CORBA::Boolean SMESH_MeshEditor_i::DoubleNodesInRegion
3713   ( const SMESH::long_array& theElems, 
3714     const SMESH::long_array& theNodesNot,
3715     GEOM::GEOM_Object_ptr    theShape )
3716  
3717 {
3718   initData();
3719
3720   ::SMESH_MeshEditor aMeshEditor( myMesh );
3721
3722   SMESHDS_Mesh* aMeshDS = GetMeshDS();
3723   TIDSortedElemSet anElems, aNodes;
3724   arrayToSet(theElems, aMeshDS, anElems, SMDSAbs_All);
3725   arrayToSet(theNodesNot, aMeshDS, aNodes, SMDSAbs_Node);
3726
3727   TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
3728   bool aResult = aMeshEditor.DoubleNodesInRegion( anElems, aNodes, aShape );
3729
3730   storeResult( aMeshEditor) ;
3731
3732   return aResult;
3733 }
3734
3735 //================================================================================
3736 /*!
3737   \brief Creates a hole in a mesh by doubling the nodes of some particular elements
3738   \param theElems - group of of elements (edges or faces) to be replicated
3739   \param theNodesNot - group of nodes not to replicated
3740   \param theAffectedElems - group of elements to which the replicated nodes
3741          should be associated to.
3742   \return TRUE if operation has been completed successfully, FALSE otherwise
3743   \sa DoubleNodes(), DoubleNodeGroups()
3744 */
3745 //================================================================================
3746
3747 static void groupToSet(SMESH::SMESH_GroupBase_ptr theGrp,
3748                        SMESHDS_Mesh*              theMeshDS,
3749                        TIDSortedElemSet&          theElemSet,
3750                        const SMDSAbs_ElementType  theType)
3751  
3752 {
3753   if ( CORBA::is_nil( theGrp ) )
3754     return;
3755   SMESH::long_array_var anIDs = theGrp->GetIDs();
3756   arrayToSet( anIDs, theMeshDS, theElemSet, theType);
3757 }
3758
3759 CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroup( 
3760   SMESH::SMESH_GroupBase_ptr theElems,
3761   SMESH::SMESH_GroupBase_ptr theNodesNot,
3762   SMESH::SMESH_GroupBase_ptr theAffectedElems )
3763
3764 {
3765   if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE )
3766     return false;
3767   
3768   initData();
3769
3770   ::SMESH_MeshEditor aMeshEditor( myMesh );
3771
3772   SMESHDS_Mesh* aMeshDS = GetMeshDS();
3773   TIDSortedElemSet anElems, aNodes, anAffected;
3774   groupToSet( theElems, aMeshDS, anElems, SMDSAbs_All ); 
3775   groupToSet( theNodesNot, aMeshDS, aNodes, SMDSAbs_Node ); 
3776   groupToSet( theAffectedElems, aMeshDS, anAffected, SMDSAbs_All );
3777
3778   bool aResult = aMeshEditor.DoubleNodes( anElems, aNodes, anAffected );
3779
3780   storeResult( aMeshEditor) ;
3781
3782   return aResult;
3783 }
3784
3785 //================================================================================
3786 /*!
3787   \brief Creates a hole in a mesh by doubling the nodes of some particular elements
3788   \param theElems - group of of elements (edges or faces) to be replicated
3789   \param theNodesNot - group of nodes not to replicated
3790   \param theShape - shape to detect affected elements (element which geometric center
3791          located on or inside shape).
3792          The replicated nodes should be associated to affected elements.
3793   \return TRUE if operation has been completed successfully, FALSE otherwise
3794   \sa DoubleNodesInRegion(), DoubleNodeGroupsInRegion()
3795 */
3796 //================================================================================
3797
3798 CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroupInRegion( 
3799   SMESH::SMESH_GroupBase_ptr theElems,
3800   SMESH::SMESH_GroupBase_ptr theNodesNot,
3801   GEOM::GEOM_Object_ptr      theShape )
3802
3803 {
3804   if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE )
3805     return false;
3806   
3807   initData();
3808
3809   ::SMESH_MeshEditor aMeshEditor( myMesh );
3810
3811   SMESHDS_Mesh* aMeshDS = GetMeshDS();
3812   TIDSortedElemSet anElems, aNodes, anAffected;
3813   groupToSet( theElems, aMeshDS, anElems, SMDSAbs_All ); 
3814   groupToSet( theNodesNot, aMeshDS, aNodes, SMDSAbs_Node ); 
3815
3816   TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
3817   bool aResult = aMeshEditor.DoubleNodesInRegion( anElems, aNodes, aShape );
3818
3819   storeResult( aMeshEditor) ;
3820
3821   return aResult;
3822 }
3823
3824 //================================================================================
3825 /*!
3826   \brief Creates a hole in a mesh by doubling the nodes of some particular elements
3827   This method provided for convenience works as DoubleNodes() described above.
3828   \param theElems - list of groups of elements (edges or faces) to be replicated
3829   \param theNodesNot - list of groups of nodes not to replicated
3830   \param theAffectedElems - group of elements to which the replicated nodes
3831          should be associated to.
3832   \return TRUE if operation has been completed successfully, FALSE otherwise
3833   \sa DoubleNodeGroup(), DoubleNodes()
3834 */
3835 //================================================================================
3836
3837 static void listOfGroupToSet(const SMESH::ListOfGroups& theGrpList,
3838                              SMESHDS_Mesh*              theMeshDS,
3839                              TIDSortedElemSet&          theElemSet,
3840                              const bool                 theIsNodeGrp)
3841 {
3842   for ( int i = 0, n = theGrpList.length(); i < n; i++ )
3843   {
3844     SMESH::SMESH_GroupBase_var aGrp = theGrpList[ i ];
3845     if ( !CORBA::is_nil( aGrp ) && (theIsNodeGrp ? aGrp->GetType() == SMESH::NODE 
3846                                                  : aGrp->GetType() != SMESH::NODE ) )
3847     {
3848       SMESH::long_array_var anIDs = aGrp->GetIDs();
3849       arrayToSet( anIDs, theMeshDS, theElemSet, theIsNodeGrp ? SMDSAbs_Node : SMDSAbs_All );
3850     }
3851   }
3852 }
3853
3854 CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups( 
3855   const SMESH::ListOfGroups& theElems,
3856   const SMESH::ListOfGroups& theNodesNot,
3857   const SMESH::ListOfGroups& theAffectedElems )
3858 {
3859   initData();
3860
3861   ::SMESH_MeshEditor aMeshEditor( myMesh );
3862
3863   SMESHDS_Mesh* aMeshDS = GetMeshDS();
3864   TIDSortedElemSet anElems, aNodes, anAffected;
3865   listOfGroupToSet(theElems, aMeshDS, anElems, false );
3866   listOfGroupToSet(theNodesNot, aMeshDS, aNodes, true );
3867   listOfGroupToSet(theAffectedElems, aMeshDS, anAffected, false );
3868
3869   bool aResult = aMeshEditor.DoubleNodes( anElems, aNodes, anAffected );
3870
3871   storeResult( aMeshEditor) ;
3872
3873   return aResult;
3874 }
3875
3876 //================================================================================
3877 /*!
3878   \brief Creates a hole in a mesh by doubling the nodes of some particular elements
3879   This method provided for convenience works as DoubleNodes() described above.
3880   \param theElems - list of groups of elements (edges or faces) to be replicated
3881   \param theNodesNot - list of groups of nodes not to replicated
3882   \param theShape - shape to detect affected elements (element which geometric center
3883          located on or inside shape).
3884          The replicated nodes should be associated to affected elements.
3885   \return TRUE if operation has been completed successfully, FALSE otherwise
3886   \sa DoubleNodeGroupInRegion(), DoubleNodesInRegion()
3887 */
3888 //================================================================================
3889
3890 CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroupsInRegion( 
3891   const SMESH::ListOfGroups& theElems,
3892   const SMESH::ListOfGroups& theNodesNot,
3893   GEOM::GEOM_Object_ptr      theShape )
3894 {
3895   initData();
3896
3897   ::SMESH_MeshEditor aMeshEditor( myMesh );
3898
3899   SMESHDS_Mesh* aMeshDS = GetMeshDS();
3900   TIDSortedElemSet anElems, aNodes;
3901   listOfGroupToSet(theElems, aMeshDS, anElems,false );
3902   listOfGroupToSet(theNodesNot, aMeshDS, aNodes, true );
3903
3904   TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
3905   bool aResult = aMeshEditor.DoubleNodesInRegion( anElems, aNodes, aShape );
3906
3907   storeResult( aMeshEditor) ;
3908
3909   return aResult;
3910 }