idl/SMESH_Mesh.idl

   1 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   2 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   3 //
   4 //  This library is free software; you can redistribute it and/or
   5 //  modify it under the terms of the GNU Lesser General Public
   6 //  License as published by the Free Software Foundation; either
   7 //  version 2.1 of the License.
   8 //
   9 //  This library is distributed in the hope that it will be useful,
  10 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 //  Lesser General Public License for more details.
  13 //
  14 //  You should have received a copy of the GNU Lesser General Public
  15 //  License along with this library; if not, write to the Free Software
  16 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 //
  18 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 //
  20 //
  21 //
  22 //  File   : SMESH_Mesh.idl
  23 //  Author : Paul RASCLE, EDF
  24 //  $Header$
  25
  26 #ifndef _SMESH_MESH_IDL_
  27 #define _SMESH_MESH_IDL_
  28
  29 #include "SALOME_Exception.idl"
  30 #include "SALOME_GenericObj.idl"
  31 #include "GEOM_Gen.idl"
  32 #include "MED.idl"
  33
  34 module SMESH
  35 {
  36   interface SMESH_Hypothesis;
  37   typedef sequence<SMESH_Hypothesis> ListOfHypothesis;
  38   interface SMESH_GroupBase;
  39   typedef sequence<SMESH_GroupBase> ListOfGroups;
  40
  41   typedef sequence<double> double_array ;
  42   typedef sequence<long> long_array ;
  43   typedef sequence<string> string_array ;
  44   typedef sequence<long_array> array_of_long_array ;
  45
  46   enum log_command
  47     {
  48       ADD_NODE,
  49       ADD_EDGE,
  50       ADD_TRIANGLE,
  51       ADD_QUADRANGLE,
  52       ADD_POLYGON,
  53       ADD_TETRAHEDRON,
  54       ADD_PYRAMID,
  55       ADD_PRISM,
  56       ADD_HEXAHEDRON,
  57       ADD_POLYHEDRON,
  58       REMOVE_NODE,
  59       REMOVE_ELEMENT,
  60       MOVE_NODE,
  61       CHANGE_ELEMENT_NODES,
  62       CHANGE_POLYHEDRON_NODES,
  63       RENUMBER,
  64       ADD_QUADEDGE,
  65       ADD_QUADTRIANGLE,
  66       ADD_QUADQUADRANGLE,
  67       ADD_QUADTETRAHEDRON,
  68       ADD_QUADPYRAMID,
  69       ADD_QUADPENTAHEDRON,
  70       ADD_QUADHEXAHEDRON
  71     };
  72
  73   struct log_block
  74   {
  75     long commandType;
  76     long number;
  77     double_array coords;
  78     long_array indexes;
  79   };
  80
  81   struct PointStruct { double x;
  82                        double y;
  83                        double z; } ;
  84   struct DirStruct   { PointStruct PS ; } ;          // analog to Occ Direction
  85
  86   struct AxisStruct  { double x;
  87                        double y;
  88                        double z;
  89                        double vx;
  90                        double vy;
  91                        double vz; } ;
  92
  93
  94   /*!
  95    * Enumeration for element type, like in SMDS
  96    */
  97   enum ElementType
  98   {
  99     ALL,
 100     NODE,
 101     EDGE,
 102     FACE,
 103     VOLUME
 104   };
 105
 106   /*!
 107    * ElementOrder points out entities of what order are requested
 108    */
 109   enum ElementOrder {
 110     ORDER_ANY,          /*! entities of any order */
 111     ORDER_LINEAR,       /*! entities of 1st order */
 112     ORDER_QUADRATIC     /*! entities of 2nd order */
 113   };
 114
 115   /*!
 116    * Enumeration for hypothesis status (used by AddHypothesis() and RemoveHypothesis() methods)
 117    */
 118   enum Hypothesis_Status // in the order of severity
 119   {
 120     HYP_OK,
 121     HYP_MISSING,      // algo misses a hypothesis
 122     HYP_CONCURENT,    // several applicable hypotheses
 123     HYP_BAD_PARAMETER,// hypothesis has a bad parameter value
 124     HYP_UNKNOWN_FATAL,//  --- all statuses below should be considered as fatal
 125                       //      for Add/RemoveHypothesis operations
 126     HYP_INCOMPATIBLE, // hypothesis does not fit algo
 127     HYP_NOTCONFORM,   // not conform mesh is produced appling a hypothesis
 128     HYP_ALREADY_EXIST,// such hypothesis already exist
 129     HYP_BAD_DIM,      // bad dimension
 130     HYP_BAD_SUBSHAPE  // shape is neither the main one, nor its subshape, nor a group
 131   };
 132
 133   /*!
 134    * Enumeration for DriverMED read status (used by ImportMEDFile() method)
 135    */
 136   enum DriverMED_ReadStatus // in the order of severity
 137   {
 138     DRS_OK,
 139     DRS_EMPTY,          // a MED file contains no mesh with the given name
 140     DRS_WARN_RENUMBER,  // a MED file has overlapped ranges of element numbers,
 141                         // so the numbers from the file are ignored
 142     DRS_WARN_SKIP_ELEM, // some elements were skipped due to incorrect file data
 143     DRS_FAIL            // general failure (exception etc.)
 144   };
 145
 146   /*!
 147    * Enumeration for DriverMED (used by Perform() method)
 148    */
 149   enum MED_VERSION // in the order of severity
 150   {
 151     MED_V2_1,
 152     MED_V2_2
 153   };
 154
 155   typedef sequence<log_block> log_array;
 156
 157
 158   /*!
 159    * Auxilary flags for advanced extrusion.
 160    * BOUNDARY: create or not boundary for result of extrusion
 161    * SEW:      try to use existing nodes or create new nodes in any case
 162    */
 163   const long EXTRUSION_FLAG_BOUNDARY = 1;
 164   const long EXTRUSION_FLAG_SEW = 2;
 165
 166   interface SMESH_IDSource
 167   {
 168     /*!
 169      * Returns a sequence of all element IDs
 170      */
 171     long_array GetIDs();
 172   };
 173
 174   interface SMESH_Group;
 175   interface SMESH_GroupOnGeom;
 176   interface SMESH_subMesh;
 177   interface SMESH_MeshEditor;
 178   interface SMESH_Mesh : SALOME::GenericObj, SMESH_IDSource
 179   {
 180     ///*!
 181     // * Associate a Shape to a Mesh created with NewEmpty
 182     // */
 183     //boolean SetMesh(in GEOM::GEOM_Object anObject)
 184     //  raises (SALOME::SALOME_Exception);
 185
 186     /*!
 187      * Get the subMesh object associated to a subShape. The subMesh object
 188      * gives access to nodes and elements IDs.
 189      * SubMesh will be used instead of SubShape in a next idl version to
 190      * adress a specific subMesh...
 191      */
 192     SMESH_subMesh GetSubMesh(in GEOM::GEOM_Object aSubObject, in string name)
 193       raises (SALOME::SALOME_Exception);
 194
 195     ///*!
 196     // * Create a subMesh without reference to a subShape
 197     // */
 198     //SMESH_subMesh NewEmpty()
 199     //  raises (SALOME::SALOME_Exception);
 200
 201     /*!
 202      * Get geom shape to mesh. A result may be nil
 203      */
 204     GEOM::GEOM_Object GetShapeToMesh()
 205       raises (SALOME::SALOME_Exception);
 206
 207     /*!
 208      * Remove a submesh
 209      */
 210     void RemoveSubMesh(in SMESH_subMesh aSubMesh)
 211       raises (SALOME::SALOME_Exception);
 212
 213     /*!
 214      * Create a group
 215      */
 216     SMESH_Group CreateGroup( in ElementType elem_type,
 217                              in string name )
 218       raises (SALOME::SALOME_Exception);
 219
 220     /*!
 221      * Create a group from geometry group
 222      */
 223     SMESH_GroupOnGeom CreateGroupFromGEOM( in ElementType elem_type,
 224                                           in string name,
 225                                           in GEOM::GEOM_Object theGeomObject )
 226       raises (SALOME::SALOME_Exception);
 227
 228     /*!
 229      * Remove a group
 230      */
 231     void RemoveGroup(in SMESH_GroupBase aGroup)
 232       raises (SALOME::SALOME_Exception);
 233
 234     /*!
 235      *  Remove group with its contents
 236      */
 237     void RemoveGroupWithContents( in SMESH_GroupBase aGroup )
 238       raises (SALOME::SALOME_Exception);
 239
 240     /*!
 241      *  Get the list of groups existing in the mesh
 242      */
 243     ListOfGroups GetGroups()
 244       raises (SALOME::SALOME_Exception);
 245
 246     /*!
 247      * Union of two groups
 248      *    New group is created. All mesh elements that are
 249      *    present in initial groups are added to the new one
 250      */
 251     SMESH_Group UnionGroups (in SMESH_GroupBase aGroup1,
 252                              in SMESH_GroupBase aGroup2,
 253                              in string          name )
 254       raises (SALOME::SALOME_Exception);
 255
 256     /*!
 257      *  Intersection of two groups
 258      *  New group is created. All mesh elements that are
 259      *  present in both initial groups are added to the new one.
 260      */
 261     SMESH_Group IntersectGroups (in SMESH_GroupBase aGroup1,
 262                                  in SMESH_GroupBase aGroup2,
 263                                  in string          name )
 264       raises (SALOME::SALOME_Exception);
 265
 266     /*!
 267      *  Cut of two groups
 268      *  New group is created. All mesh elements that are present in
 269      *  main group but do not present in tool group are added to the new one
 270      */
 271     SMESH_Group CutGroups (in SMESH_GroupBase aMainGroup,
 272                            in SMESH_GroupBase aToolGroup,
 273                            in string          name )
 274       raises (SALOME::SALOME_Exception);
 275
 276     /*!
 277      * Add hypothesis to the mesh, under a particular subShape
 278      * (or the main shape itself)
 279      * The Add method is only used to prepare the build of the mesh and store
 280      * the algorithms and associated parameters.
 281      * Actual job of mesh the shape is done by MESH_Gen.
 282      * @params
 283      * - aSubShape : subShape obtained by a shape explode in GEOM
 284      *   (or main shape)
 285      * - anHyp : hypothesis object
 286      * @return
 287      * - OK if the hypothesis is compatible with the subShape
 288      *   (and all previous hypothesis on the subShape)
 289      * - NOK if the hypothesis is not compatible with the subShape
 290      *   (or one previous hypothesis on the subShape)
 291      * raises exception if hypothesis has not been created
 292      */
 293     Hypothesis_Status AddHypothesis(in GEOM::GEOM_Object aSubObject,
 294                                     in SMESH_Hypothesis anHyp)
 295       raises (SALOME::SALOME_Exception);
 296 //     boolean AddHypothesis(in SMESH_subMesh aSubMesh, in SMESH_Hypothesis anHyp)
 297 //       raises (SALOME::SALOME_Exception);
 298
 299     /*!
 300      * Remove an hypothesis previouly added with AddHypothesis.
 301      */
 302     Hypothesis_Status RemoveHypothesis(in GEOM::GEOM_Object aSubObject,
 303                                        in SMESH_Hypothesis anHyp)
 304       raises (SALOME::SALOME_Exception);
 305 //     boolean RemoveHypothesis(in SMESH_subMesh aSubMesh,
 306 //                           in SMESH_Hypothesis anHyp)
 307 //       raises (SALOME::SALOME_Exception);
 308
 309     /*!
 310      * Get the list of hypothesis added on a subShape
 311      */
 312     ListOfHypothesis GetHypothesisList(in GEOM::GEOM_Object aSubObject)
 313       raises (SALOME::SALOME_Exception);
 314 //     ListOfHypothesis GetHypothesisList(in SMESH_subMesh aSubMesh)
 315 //       raises (SALOME::SALOME_Exception);
 316
 317     /*!
 318      * Get the log of nodes and elements added or removed since previous
 319      * clear of the log.
 320      * @params
 321      * - clearAfterGet : log is emptied after Get (safe if concurrents access)
 322      */
 323     //    string_array GetLog(in boolean clearAfterGet)
 324     //      raises (SALOME::SALOME_Exception);
 325     log_array GetLog(in boolean clearAfterGet)
 326       raises (SALOME::SALOME_Exception);
 327
 328     /*!
 329      * Clear the log of nodes and elements added or removed since previous
 330      * clear. Must be used immediately after GetLog if clearAfterGet is false.
 331      */
 332     void ClearLog()
 333       raises (SALOME::SALOME_Exception);
 334
 335     /*!
 336      * Get the internal Id
 337      */
 338     long GetId();
 339
 340     /*!
 341      * Get the study Id
 342      */
 343     long GetStudyId();
 344
 345     /*!
 346      * Obtain instance of SMESH_MeshEditor
 347      */
 348     SMESH_MeshEditor GetMeshEditor()
 349       raises (SALOME::SALOME_Exception);
 350
 351     /*! Check group names for duplications.
 352      *  Consider maximum group name length stored in MED file.
 353      */
 354     boolean HasDuplicatedGroupNamesMED();
 355
 356     /*!
 357      * Export Mesh to different MED Formats
 358      * @params
 359      * - auto_groups : boolean parameter for creating/not creating
 360      *   the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
 361      *   the typical use is auto_groups=false.
 362      * - theVersion : define the version of format of MED file, that will be created
 363      */
 364     void ExportToMED( in string file, in boolean auto_groups, in MED_VERSION theVersion )
 365       raises (SALOME::SALOME_Exception);
 366
 367     /*!
 368      * Export Mesh to MED_V2_1 MED format
 369      * Works, just the same as ExportToMED, with MED_VERSION parameter equal to MED_V2_1.
 370      * The method is kept in order to support old functionality
 371      */
 372     void ExportMED( in string file, in boolean auto_groups )
 373       raises (SALOME::SALOME_Exception);
 374
 375     /*!
 376      * Export Mesh to DAT, UNV and STL Formats
 377      * (UNV supported version is I-DEAS 10)
 378      */
 379     void ExportDAT( in string file )
 380       raises (SALOME::SALOME_Exception);
 381     void ExportUNV( in string file )
 382       raises (SALOME::SALOME_Exception);
 383     void ExportSTL( in string file, in boolean isascii )
 384       raises (SALOME::SALOME_Exception);
 385
 386     /*!
 387      * Get MED Mesh
 388      */
 389     SALOME_MED::MESH GetMEDMesh()
 390       raises (SALOME::SALOME_Exception);
 391
 392     /*!
 393      * Get informations about mesh contents
 394      */
 395     long NbNodes()
 396       raises (SALOME::SALOME_Exception);
 397
 398     long NbElements()
 399       raises (SALOME::SALOME_Exception);
 400
 401     long NbEdges()
 402       raises (SALOME::SALOME_Exception);
 403
 404     long NbEdgesOfOrder(in ElementOrder order)
 405       raises (SALOME::SALOME_Exception);
 406
 407     long NbFaces()
 408       raises (SALOME::SALOME_Exception);
 409
 410     long NbFacesOfOrder(in ElementOrder order)
 411       raises (SALOME::SALOME_Exception);
 412
 413     long NbTriangles()
 414       raises (SALOME::SALOME_Exception);
 415
 416     long NbTrianglesOfOrder(in ElementOrder order)
 417       raises (SALOME::SALOME_Exception);
 418
 419     long NbQuadrangles()
 420       raises (SALOME::SALOME_Exception);
 421
 422     long NbQuadranglesOfOrder(in ElementOrder order)
 423       raises (SALOME::SALOME_Exception);
 424
 425     long NbPolygons()
 426       raises (SALOME::SALOME_Exception);
 427
 428     long NbVolumes()
 429       raises (SALOME::SALOME_Exception);
 430
 431     long NbVolumesOfOrder(in ElementOrder order)
 432       raises (SALOME::SALOME_Exception);
 433
 434     long NbTetras()
 435       raises (SALOME::SALOME_Exception);
 436
 437     long NbTetrasOfOrder(in ElementOrder order)
 438       raises (SALOME::SALOME_Exception);
 439
 440     long NbHexas()
 441       raises (SALOME::SALOME_Exception);
 442
 443     long NbHexasOfOrder(in ElementOrder order)
 444       raises (SALOME::SALOME_Exception);
 445
 446     long NbPyramids()
 447       raises (SALOME::SALOME_Exception);
 448
 449     long NbPyramidsOfOrder(in ElementOrder order)
 450       raises (SALOME::SALOME_Exception);
 451
 452     long NbPrisms()
 453       raises (SALOME::SALOME_Exception);
 454
 455     long NbPrismsOfOrder(in ElementOrder order)
 456       raises (SALOME::SALOME_Exception);
 457
 458     long NbPolyhedrons()
 459       raises (SALOME::SALOME_Exception);
 460
 461     long NbSubMesh()
 462       raises (SALOME::SALOME_Exception);
 463
 464     long_array GetElementsId()
 465       raises (SALOME::SALOME_Exception);
 466
 467     long_array GetElementsByType( in ElementType theType )
 468       raises (SALOME::SALOME_Exception);
 469
 470     long_array GetNodesId()
 471       raises (SALOME::SALOME_Exception);
 472
 473     /*!
 474      * Returns type of mesh element
 475      */
 476     ElementType GetElementType( in long id, in boolean iselem )
 477       raises (SALOME::SALOME_Exception);
 478
 479     long_array GetSubMeshElementsId(in long ShapeID)
 480       raises (SALOME::SALOME_Exception);
 481
 482     long_array GetSubMeshNodesId(in long ShapeID, in boolean all )
 483       raises (SALOME::SALOME_Exception);
 484
 485     ElementType GetSubMeshElementType(in long ShapeID)
 486       raises (SALOME::SALOME_Exception);
 487
 488     /*!
 489      * Get mesh description
 490      */
 491     string Dump();
 492
 493     /*!
 494      * Get mesh pointer
 495      */
 496     long GetMeshPtr();
 497
 498     /*!
 499      * Get XYZ coordinates of node as list of double
 500      * If there is not node for given ID - returns empty list
 501      */
 502     double_array GetNodeXYZ(in long id);
 503
 504     /*!
 505      * For given node returns list of IDs of inverse elements
 506      * If there is not node for given ID - returns empty list
 507      */
 508     long_array GetNodeInverseElements(in long id);
 509
 510     /*!
 511      * If given element is node returns IDs of shape from position
 512      * If there is not node for given ID - returns -1
 513      */
 514     long GetShapeID(in long id);
 515
 516     /*!
 517      * For given element returns ID of result shape after
 518      * ::FindShape() from SMESH_MeshEditor
 519      * If there is not element for given ID - returns -1
 520      */
 521     long GetShapeIDForElem(in long id);
 522
 523     /*!
 524      * Returns number of nodes for given element
 525      * If there is not element for given ID - returns -1
 526      */
 527     long GetElemNbNodes(in long id);
 528
 529     /*!
 530      * Returns ID of node by given index for given element
 531      * If there is not element for given ID - returns -1
 532      * If there is not node for given index - returns -2
 533      */
 534     long GetElemNode(in long id, in long index);
 535
 536     /*!
 537      * Returns true if given node is medium node
 538      * in given quadratic element
 539      */
 540     boolean IsMediumNode(in long ide, in long idn);
 541
 542     /*!
 543      * Returns true if given node is medium node
 544      * in one of quadratic elements
 545      */
 546     boolean IsMediumNodeOfAnyElem(in long idn, in ElementType elem_type);
 547
 548     /*!
 549      * Returns number of edges for given element
 550      */
 551     long ElemNbEdges(in long id);
 552
 553     /*!
 554      * Returns number of faces for given element
 555      */
 556     long ElemNbFaces(in long id);
 557
 558     /*!
 559      * Returns true if given element is polygon
 560      */
 561     boolean IsPoly(in long id);
 562
 563     /*!
 564      * Returns true if given element is quadratic
 565      */
 566     boolean IsQuadratic(in long id);
 567
 568     /*!
 569      * Returns XYZ coordinates of bary center for given element
 570      * as list of double
 571      * If there is not element for given ID - returns empty list
 572      */
 573     double_array BaryCenter(in long id);
 574
 575   };
 576
 577   interface SMESH_subMesh : SALOME::GenericObj, SMESH_IDSource
 578   {
 579     /*!
 580      *
 581      */
 582     long GetNumberOfElements()
 583       raises (SALOME::SALOME_Exception);
 584
 585     /*!
 586      *
 587      */
 588     long GetNumberOfNodes( in boolean all )
 589       raises (SALOME::SALOME_Exception);
 590
 591     /*!
 592      *
 593      */
 594     long_array GetElementsId()
 595       raises (SALOME::SALOME_Exception);
 596
 597     /*!
 598      *
 599      */
 600     long_array GetElementsByType( in ElementType theType )
 601       raises (SALOME::SALOME_Exception);
 602
 603     /*!
 604      * Return type of submesh element
 605      */
 606     ElementType GetElementType( in long id, in boolean iselem )
 607       raises (SALOME::SALOME_Exception);
 608
 609     /*!
 610      *
 611      */
 612     long_array GetNodesId()
 613       raises (SALOME::SALOME_Exception);
 614
 615     /*!
 616      * Get geom shape the submesh is dedicated to
 617      */
 618     GEOM::GEOM_Object GetSubShape()
 619       raises (SALOME::SALOME_Exception);
 620
 621     /*!
 622      * Get SMESH_Mesh which stores nodes coordinates & elements definition
 623      */
 624     SMESH_Mesh GetFather()
 625       raises (SALOME::SALOME_Exception);
 626
 627     /*!
 628      * Get the internal Id
 629      */
 630     long GetId();
 631
 632     /*!
 633      * Get MED subMesh
 634      */
 635     SALOME_MED::FAMILY GetFamily()
 636       raises (SALOME::SALOME_Exception);
 637   };
 638
 639   /*!
 640    * This interface makes modifications on the Mesh - removing elements and nodes etc.
 641    */
 642   interface NumericalFunctor;
 643   interface SMESH_MeshEditor
 644   {
 645     boolean RemoveElements(in long_array IDsOfElements);
 646
 647     boolean RemoveNodes(in long_array IDsOfNodes);
 648
 649     long AddNode(in double x, in double y, in double z);
 650
 651     /*!
 652      *  Create edge both similar and quadratic (this is determed
 653      *  by number of given nodes).
 654      *  \param IdsOfNodes List of node IDs for creation of element.
 655      *  Needed order of nodes in this list corresponds to description
 656      *  of MED. This description is located by the following link:
 657      *   http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
 658      */
 659     long AddEdge(in long_array IDsOfNodes);
 660
 661     /*!
 662      *  Create face both similar and quadratic (this is determed
 663      *  by number of given nodes).
 664      *  \param IdsOfNodes List of node IDs for creation of element.
 665      *  Needed order of nodes in this list corresponds to description
 666      *  of MED. This description is located by the following link:
 667      *   http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
 668      */
 669     long AddFace(in long_array IDsOfNodes);
 670
 671     long AddPolygonalFace(in long_array IdsOfNodes);
 672
 673     /*!
 674      *  Create volume both similar and quadratic (this is determed
 675      *  by number of given nodes).
 676      *  \param IdsOfNodes List of node IDs for creation of element.
 677      *  Needed order of nodes in this list corresponds to description
 678      *  of MED. This description is located by the following link:
 679      *   http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
 680      */
 681     long AddVolume(in long_array IDsOfNodes);
 682
 683     /*!
 684      *  Create volume of many faces, giving nodes for each face.
 685      *  \param IdsOfNodes List of node IDs for volume creation face by face.
 686      *  \param Quantities List of integer values, Quantities[i]
 687      *         gives quantity of nodes in face number i.
 688      */
 689     long AddPolyhedralVolume (in long_array IdsOfNodes,
 690                                  in long_array Quantities);
 691
 692     /*!
 693      *  Create volume of many faces, giving IDs of existing faces.
 694      *  \param IdsOfFaces List of face IDs for volume creation.
 695      *  \note The created volume will refer only to nodes
 696      *        of the given faces, not to the faces itself.
 697      */
 698     long AddPolyhedralVolumeByFaces (in long_array IdsOfFaces);
 699
 700     boolean MoveNode(in long NodeID, in double x, in double y, in double z);
 701
 702     boolean InverseDiag(in long NodeID1, in long NodeID2);
 703
 704     boolean DeleteDiag(in long NodeID1, in long NodeID2);
 705
 706     boolean Reorient(in long_array IDsOfElements);
 707
 708     boolean ReorientObject(in SMESH_IDSource theObject);
 709
 710     /*!
 711      * \brief Fuse neighbour triangles into quadrangles.
 712      * \param theElems     The triangles to be fused.
 713      * \param theCriterion Is used to choose a neighbour to fuse with.
 714      * \param theMaxAngle  Is a max angle between element normals at which fusion
 715      *                     is still performed; theMaxAngle is mesured in radians.
 716      * \return TRUE in case of success, FALSE otherwise.
 717      */
 718     boolean TriToQuad (in long_array       IDsOfElements,
 719                        in NumericalFunctor Criterion,
 720                        in double           MaxAngle);
 721
 722     /*!
 723      * \brief Fuse neighbour triangles into quadrangles.
 724      *
 725      * Behaves like the above method, taking list of elements from \a theObject
 726      */
 727     boolean TriToQuadObject (in SMESH_IDSource   theObject,
 728                              in NumericalFunctor Criterion,
 729                              in double           MaxAngle);
 730
 731     /*!
 732      * \brief Split quadrangles into triangles.
 733      * \param theElems     The faces to be splitted.
 734      * \param theCriterion Is used to choose a diagonal for splitting.
 735      * \return TRUE in case of success, FALSE otherwise.
 736      */
 737     boolean QuadToTri (in long_array       IDsOfElements,
 738                        in NumericalFunctor Criterion);
 739
 740     /*!
 741      * \brief Split quadrangles into triangles.
 742      *
 743      * Behaves like the above method, taking list of elements from \a theObject
 744      */
 745     boolean QuadToTriObject (in SMESH_IDSource   theObject,
 746                              in NumericalFunctor Criterion);
 747
 748     /*!
 749      * \brief Split quadrangles into triangles.
 750      * \param theElems  The faces to be splitted.
 751      * \param the13Diag Is used to choose a diagonal for splitting.
 752      * \return TRUE in case of success, FALSE otherwise.
 753      */
 754     boolean SplitQuad (in long_array IDsOfElements,
 755                        in boolean    Diag13);
 756
 757     /*!
 758      * \brief Split quadrangles into triangles.
 759      *
 760      * Behaves like the above method, taking list of elements from \a theObject
 761      */
 762     boolean SplitQuadObject (in SMESH_IDSource theObject,
 763                              in boolean        Diag13);
 764
 765     /*!
 766      *  Find better splitting of the given quadrangle.
 767      *  \param IDOfQuad  ID of the quadrangle to be splitted.
 768      *  \param Criterion A criterion to choose a diagonal for splitting.
 769      *  \return 1 if 1-3 diagonal is better, 2 if 2-4
 770      *          diagonal is better, 0 if error occurs.
 771      */
 772     long BestSplit (in long             IDOfQuad,
 773                     in NumericalFunctor Criterion);
 774
 775     enum Smooth_Method { LAPLACIAN_SMOOTH, CENTROIDAL_SMOOTH };
 776
 777     boolean Smooth(in long_array    IDsOfElements,
 778                    in long_array    IDsOfFixedNodes,
 779                    in long          MaxNbOfIterations,
 780                    in double        MaxAspectRatio,
 781                    in Smooth_Method Method);
 782
 783     boolean SmoothObject(in SMESH_IDSource  theObject,
 784                          in long_array      IDsOfFixedNodes,
 785                          in long            MaxNbOfIterations,
 786                          in double          MaxAspectRatio,
 787                          in Smooth_Method   Method);
 788
 789     boolean SmoothParametric(in long_array    IDsOfElements,
 790                              in long_array    IDsOfFixedNodes,
 791                              in long          MaxNbOfIterations,
 792                              in double        MaxAspectRatio,
 793                              in Smooth_Method Method);
 794
 795     boolean SmoothParametricObject(in SMESH_IDSource  theObject,
 796                                    in long_array      IDsOfFixedNodes,
 797                                    in long            MaxNbOfIterations,
 798                                    in double          MaxAspectRatio,
 799                                    in Smooth_Method   Method);
 800
 801     void ConvertToQuadratic(in boolean theForce3d);
 802
 803     boolean ConvertFromQuadratic();
 804
 805     void RenumberNodes();
 806
 807     void RenumberElements();
 808
 809     void RotationSweep(in long_array       IDsOfElements,
 810                        in AxisStruct       Axix,
 811                        in double           AngleInRadians,
 812                        in long             NbOfSteps,
 813                        in double           Tolerance);
 814
 815     void RotationSweepObject(in SMESH_IDSource  theObject,
 816                              in AxisStruct      Axix,
 817                              in double          AngleInRadians,
 818                              in long            NbOfSteps,
 819                              in double          Tolerance);
 820
 821     void ExtrusionSweep(in long_array      IDsOfElements,
 822                         in DirStruct       StepVector,
 823                         in long            NbOfSteps);
 824
 825    /*!
 826     * Generate new elements by extrusion of theElements
 827     * by StepVector by NbOfSteps
 828     * param ExtrFlags set flags for performing extrusion
 829     * param SewTolerance - uses for comparing locations of nodes if flag
 830     *   EXTRUSION_FLAG_SEW is set
 831     */
 832     void AdvancedExtrusion(in long_array      IDsOfElements,
 833                            in DirStruct       StepVector,
 834                            in long            NbOfSteps,
 835                            in long            ExtrFlags,
 836                            in double          SewTolerance);
 837
 838     void ExtrusionSweepObject(in SMESH_IDSource  theObject,
 839                               in DirStruct       StepVector,
 840                               in long            NbOfSteps);
 841
 842     void ExtrusionSweepObject1D(in SMESH_IDSource theObject,
 843                                 in DirStruct      StepVector,
 844                                 in long           NbOfSteps);
 845
 846     void ExtrusionSweepObject2D(in SMESH_IDSource theObject,
 847                                 in DirStruct      StepVector,
 848                                 in long           NbOfSteps);
 849
 850     enum Extrusion_Error {
 851       EXTR_OK,
 852       EXTR_NO_ELEMENTS,
 853       EXTR_PATH_NOT_EDGE,
 854       EXTR_BAD_PATH_SHAPE,
 855       EXTR_BAD_STARTING_NODE,
 856       EXTR_BAD_ANGLES_NUMBER,
 857       EXTR_CANT_GET_TANGENT
 858       };
 859
 860     Extrusion_Error ExtrusionAlongPath(in long_array        IDsOfElements,
 861                                        in SMESH_Mesh        PathMesh,
 862                                        in GEOM::GEOM_Object PathShape,
 863                                        in long              NodeStart,
 864                                        in boolean           HasAngles,
 865                                        in double_array      Angles,
 866                                        in boolean           HasRefPoint,
 867                                        in PointStruct       RefPoint);
 868
 869     Extrusion_Error ExtrusionAlongPathObject(in SMESH_IDSource    theObject,
 870                                              in SMESH_Mesh        PathMesh,
 871                                              in GEOM::GEOM_Object PathShape,
 872                                              in long              NodeStart,
 873                                              in boolean           HasAngles,
 874                                              in double_array      Angles,
 875                                              in boolean           HasRefPoint,
 876                                              in PointStruct       RefPoint);
 877
 878     enum MirrorType { POINT, AXIS, PLANE };
 879
 880     void Mirror (in long_array       IDsOfElements,
 881                  in AxisStruct       Mirror,
 882                  in MirrorType       theMirrorType,
 883                  in boolean          Copy);
 884
 885     void MirrorObject (in SMESH_IDSource  theObject,
 886                        in AxisStruct      Mirror,
 887                        in MirrorType      theMirrorType,
 888                        in boolean         Copy);
 889
 890     void Translate (in long_array      IDsOfElements,
 891                     in DirStruct       Vector,
 892                     in boolean         Copy);
 893
 894     void TranslateObject (in SMESH_IDSource  theObject,
 895                           in DirStruct       Vector,
 896                           in boolean         Copy);
 897
 898     void Rotate (in long_array       IDsOfElements,
 899                  in AxisStruct       Axis,
 900                  in double           AngleInRadians,
 901                  in boolean          Copy);
 902
 903     void RotateObject (in SMESH_IDSource  theObject,
 904                        in AxisStruct      Axis,
 905                        in double          AngleInRadians,
 906                        in boolean         Copy);
 907
 908     void FindCoincidentNodes (in  double              Tolerance,
 909                               out array_of_long_array GroupsOfNodes);
 910
 911     void MergeNodes (in array_of_long_array GroupsOfNodes);
 912
 913     void MergeEqualElements();
 914
 915     enum Sew_Error {
 916       SEW_OK,
 917       SEW_BORDER1_NOT_FOUND,
 918       SEW_BORDER2_NOT_FOUND,
 919       SEW_BOTH_BORDERS_NOT_FOUND,
 920       SEW_BAD_SIDE_NODES,
 921       SEW_VOLUMES_TO_SPLIT,
 922       // for SewSideElements() only:
 923       SEW_DIFF_NB_OF_ELEMENTS,
 924       SEW_TOPO_DIFF_SETS_OF_ELEMENTS,
 925       SEW_BAD_SIDE1_NODES,
 926       SEW_BAD_SIDE2_NODES
 927       };
 928
 929     Sew_Error SewFreeBorders (in long FirstNodeID1,
 930                               in long SecondNodeID1,
 931                               in long LastNodeID1,
 932                               in long FirstNodeID2,
 933                               in long SecondNodeID2,
 934                               in long LastNodeID2,
 935                               in boolean CreatePolygons,
 936                               in boolean CreatePolyedrs);
 937
 938     Sew_Error SewConformFreeBorders (in long FirstNodeID1,
 939                                      in long SecondNodeID1,
 940                                      in long LastNodeID1,
 941                                      in long FirstNodeID2,
 942                                      in long SecondNodeID2);
 943
 944     Sew_Error SewBorderToSide (in long FirstNodeIDOnFreeBorder,
 945                                in long SecondNodeIDOnFreeBorder,
 946                                in long LastNodeIDOnFreeBorder,
 947                                in long FirstNodeIDOnSide,
 948                                in long LastNodeIDOnSide,
 949                                in boolean CreatePolygons,
 950                                in boolean CreatePolyedrs);
 951
 952     Sew_Error SewSideElements (in long_array IDsOfSide1Elements,
 953                                in long_array IDsOfSide2Elements,
 954                                in long       NodeID1OfSide1ToMerge,
 955                                in long       NodeID1OfSide2ToMerge,
 956                                in long       NodeID2OfSide1ToMerge,
 957                                in long       NodeID2OfSide2ToMerge);
 958
 959    /*!
 960     * Set new nodes for given element.
 961     * If number of nodes is not corresponded to type of
 962     * element - returns false
 963     */
 964     boolean ChangeElemNodes(in long ide, in long_array newIDs);
 965
 966    /*!
 967     * If during last operation of MeshEditor some nodes were
 968     * created this method returns list of it's IDs, if new nodes
 969     * not creared - returns empty list
 970     */
 971     long_array GetLastCreatedNodes();
 972
 973    /*!
 974     * If during last operation of MeshEditor some elements were
 975     * created this method returns list of it's IDs, if new elements
 976     * not creared - returns empty list
 977     */
 978     long_array GetLastCreatedElems();
 979
 980   };
 981 };
 982
 983 #endif