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      * else - return ID of result shape after ::FindShape()
 513      * from SMESH_MeshEditor
 514      * If there is not element for given ID - returns -1
 515      */
 516     long GetShapeID(in long id);
 517
 518     /*!
 519      * Returns number of nodes for given element
 520      * If there is not element for given ID - returns -1
 521      */
 522     long GetElemNbNodes(in long id);
 523
 524     /*!
 525      * Returns ID of node by given index for given element
 526      * If there is not element for given ID - returns -1
 527      * If there is not node for given index - returns -2
 528      */
 529     long GetElemNode(in long id, in long index);
 530
 531     /*!
 532      * Returns true if given node is medium node
 533      * in given quadratic element
 534      */
 535     boolean IsMediumNode(in long ide, in long idn);
 536
 537     /*!
 538      * Returns true if given node is medium node
 539      * in one of quadratic elements
 540      */
 541     boolean IsMediumNodeOfAnyElem(in long idn, in ElementType elem_type);
 542
 543     /*!
 544      * Returns number of edges for given element
 545      */
 546     long ElemNbEdges(in long id);
 547
 548     /*!
 549      * Returns number of faces for given element
 550      */
 551     long ElemNbFaces(in long id);
 552
 553     /*!
 554      * Returns true if given element is polygon
 555      */
 556     boolean IsPoly(in long id);
 557
 558     /*!
 559      * Returns true if given element is quadratic
 560      */
 561     boolean IsQuadratic(in long id);
 562
 563     /*!
 564      * Returns XYZ coordinates of bary center for given element
 565      * as list of double
 566      * If there is not element for given ID - returns empty list
 567      */
 568     double_array BaryCenter(in long id);
 569
 570   };
 571
 572   interface SMESH_subMesh : SALOME::GenericObj, SMESH_IDSource
 573   {
 574     /*!
 575      *
 576      */
 577     long GetNumberOfElements()
 578       raises (SALOME::SALOME_Exception);
 579
 580     /*!
 581      *
 582      */
 583     long GetNumberOfNodes( in boolean all )
 584       raises (SALOME::SALOME_Exception);
 585
 586     /*!
 587      *
 588      */
 589     long_array GetElementsId()
 590       raises (SALOME::SALOME_Exception);
 591
 592     /*!
 593      *
 594      */
 595     long_array GetElementsByType( in ElementType theType )
 596       raises (SALOME::SALOME_Exception);
 597
 598     /*!
 599      * Return type of submesh element
 600      */
 601     ElementType GetElementType( in long id, in boolean iselem )
 602       raises (SALOME::SALOME_Exception);
 603
 604     /*!
 605      *
 606      */
 607     long_array GetNodesId()
 608       raises (SALOME::SALOME_Exception);
 609
 610     /*!
 611      * Get geom shape the submesh is dedicated to
 612      */
 613     GEOM::GEOM_Object GetSubShape()
 614       raises (SALOME::SALOME_Exception);
 615
 616     /*!
 617      * Get SMESH_Mesh which stores nodes coordinates & elements definition
 618      */
 619     SMESH_Mesh GetFather()
 620       raises (SALOME::SALOME_Exception);
 621
 622     /*!
 623      * Get the internal Id
 624      */
 625     long GetId();
 626
 627     /*!
 628      * Get MED subMesh
 629      */
 630     SALOME_MED::FAMILY GetFamily()
 631       raises (SALOME::SALOME_Exception);
 632   };
 633
 634   /*!
 635    * This interface makes modifications on the Mesh - removing elements and nodes etc.
 636    */
 637   interface NumericalFunctor;
 638   interface SMESH_MeshEditor
 639   {
 640     boolean RemoveElements(in long_array IDsOfElements);
 641
 642     boolean RemoveNodes(in long_array IDsOfNodes);
 643
 644     long AddNode(in double x, in double y, in double z);
 645
 646     /*!
 647      *  Following methods are intented for creation edges, faces
 648      *  and volumes both similar and quadratic (this is determed
 649      *  by number of given nodes).
 650      *  \param IdsOfNodes List of node IDs for creation of element.
 651      *  Needed order of nodes in this list corresponds to description
 652      *  of MED. This description is located by the following link:
 653      *   http://www.salome-platform.org/salome2/web_med_internet/logiciels/
 654      *     medV2.2.2_doc_html/html/modele_de_donnees.html#3.
 655      */
 656     long AddEdge(in long_array IDsOfNodes);
 657
 658     long AddFace(in long_array IDsOfNodes);
 659
 660     long AddPolygonalFace(in long_array IdsOfNodes);
 661
 662     long AddVolume(in long_array IDsOfNodes);
 663
 664     /*!
 665      *  Create volume of many faces, giving nodes for each face.
 666      *  \param IdsOfNodes List of node IDs for volume creation face by face.
 667      *  \param Quantities List of integer values, Quantities[i]
 668      *         gives quantity of nodes in face number i.
 669      */
 670     long AddPolyhedralVolume (in long_array IdsOfNodes,
 671                                  in long_array Quantities);
 672
 673     /*!
 674      *  Create volume of many faces, giving IDs of existing faces.
 675      *  \param IdsOfFaces List of face IDs for volume creation.
 676      *  \note The created volume will refer only to nodes
 677      *        of the given faces, not to the faces itself.
 678      */
 679     long AddPolyhedralVolumeByFaces (in long_array IdsOfFaces);
 680
 681     boolean MoveNode(in long NodeID, in double x, in double y, in double z);
 682
 683     boolean InverseDiag(in long NodeID1, in long NodeID2);
 684
 685     boolean DeleteDiag(in long NodeID1, in long NodeID2);
 686
 687     boolean Reorient(in long_array IDsOfElements);
 688
 689     boolean ReorientObject(in SMESH_IDSource theObject);
 690
 691     /*!
 692      * \brief Fuse neighbour triangles into quadrangles.
 693      * \param theElems     The triangles to be fused.
 694      * \param theCriterion Is used to choose a neighbour to fuse with.
 695      * \param theMaxAngle  Is a max angle between element normals at which fusion
 696      *                     is still performed; theMaxAngle is mesured in radians.
 697      * \return TRUE in case of success, FALSE otherwise.
 698      */
 699     boolean TriToQuad (in long_array       IDsOfElements,
 700                        in NumericalFunctor Criterion,
 701                        in double           MaxAngle);
 702
 703     /*!
 704      * \brief Fuse neighbour triangles into quadrangles.
 705      *
 706      * Behaves like the above method, taking list of elements from \a theObject
 707      */
 708     boolean TriToQuadObject (in SMESH_IDSource   theObject,
 709                              in NumericalFunctor Criterion,
 710                              in double           MaxAngle);
 711
 712     /*!
 713      * \brief Split quadrangles into triangles.
 714      * \param theElems     The faces to be splitted.
 715      * \param theCriterion Is used to choose a diagonal for splitting.
 716      * \return TRUE in case of success, FALSE otherwise.
 717      */
 718     boolean QuadToTri (in long_array       IDsOfElements,
 719                        in NumericalFunctor Criterion);
 720
 721     /*!
 722      * \brief Split quadrangles into triangles.
 723      *
 724      * Behaves like the above method, taking list of elements from \a theObject
 725      */
 726     boolean QuadToTriObject (in SMESH_IDSource   theObject,
 727                              in NumericalFunctor Criterion);
 728
 729     /*!
 730      * \brief Split quadrangles into triangles.
 731      * \param theElems  The faces to be splitted.
 732      * \param the13Diag Is used to choose a diagonal for splitting.
 733      * \return TRUE in case of success, FALSE otherwise.
 734      */
 735     boolean SplitQuad (in long_array IDsOfElements,
 736                        in boolean    Diag13);
 737
 738     /*!
 739      * \brief Split quadrangles into triangles.
 740      *
 741      * Behaves like the above method, taking list of elements from \a theObject
 742      */
 743     boolean SplitQuadObject (in SMESH_IDSource theObject,
 744                              in boolean        Diag13);
 745
 746     /*!
 747      *  Find better splitting of the given quadrangle.
 748      *  \param IDOfQuad  ID of the quadrangle to be splitted.
 749      *  \param Criterion A criterion to choose a diagonal for splitting.
 750      *  \return 1 if 1-3 diagonal is better, 2 if 2-4
 751      *          diagonal is better, 0 if error occurs.
 752      */
 753     long BestSplit (in long             IDOfQuad,
 754                     in NumericalFunctor Criterion);
 755
 756     enum Smooth_Method { LAPLACIAN_SMOOTH, CENTROIDAL_SMOOTH };
 757
 758     boolean Smooth(in long_array    IDsOfElements,
 759                    in long_array    IDsOfFixedNodes,
 760                    in long          MaxNbOfIterations,
 761                    in double        MaxAspectRatio,
 762                    in Smooth_Method Method);
 763
 764     boolean SmoothObject(in SMESH_IDSource  theObject,
 765                          in long_array      IDsOfFixedNodes,
 766                          in long            MaxNbOfIterations,
 767                          in double          MaxAspectRatio,
 768                          in Smooth_Method   Method);
 769
 770     boolean SmoothParametric(in long_array    IDsOfElements,
 771                              in long_array    IDsOfFixedNodes,
 772                              in long          MaxNbOfIterations,
 773                              in double        MaxAspectRatio,
 774                              in Smooth_Method Method);
 775
 776     boolean SmoothParametricObject(in SMESH_IDSource  theObject,
 777                                    in long_array      IDsOfFixedNodes,
 778                                    in long            MaxNbOfIterations,
 779                                    in double          MaxAspectRatio,
 780                                    in Smooth_Method   Method);
 781
 782     void ConvertToQuadratic(in boolean theForce3d);
 783
 784     boolean ConvertFromQuadratic();
 785
 786     void RenumberNodes();
 787
 788     void RenumberElements();
 789
 790     void RotationSweep(in long_array       IDsOfElements,
 791                        in AxisStruct       Axix,
 792                        in double           AngleInRadians,
 793                        in long             NbOfSteps,
 794                        in double           Tolerance);
 795
 796     void RotationSweepObject(in SMESH_IDSource  theObject,
 797                              in AxisStruct      Axix,
 798                              in double          AngleInRadians,
 799                              in long            NbOfSteps,
 800                              in double          Tolerance);
 801
 802     void ExtrusionSweep(in long_array      IDsOfElements,
 803                         in DirStruct       StepVector,
 804                         in long            NbOfSteps);
 805
 806    /*!
 807     * Generate new elements by extrusion of theElements
 808     * by StepVector by NbOfSteps
 809     * param ExtrFlags set flags for performing extrusion
 810     * param SewTolerance - uses for comparing locations of nodes if flag
 811     *   EXTRUSION_FLAG_SEW is set
 812     */
 813     void AdvancedExtrusion(in long_array      IDsOfElements,
 814                            in DirStruct       StepVector,
 815                            in long            NbOfSteps,
 816                            in long            ExtrFlags,
 817                            in double          SewTolerance);
 818
 819     void ExtrusionSweepObject(in SMESH_IDSource  theObject,
 820                               in DirStruct       StepVector,
 821                               in long            NbOfSteps);
 822
 823     void ExtrusionSweepObject1D(in SMESH_IDSource theObject,
 824                                 in DirStruct      StepVector,
 825                                 in long           NbOfSteps);
 826
 827     void ExtrusionSweepObject2D(in SMESH_IDSource theObject,
 828                                 in DirStruct      StepVector,
 829                                 in long           NbOfSteps);
 830
 831     enum Extrusion_Error {
 832       EXTR_OK,
 833       EXTR_NO_ELEMENTS,
 834       EXTR_PATH_NOT_EDGE,
 835       EXTR_BAD_PATH_SHAPE,
 836       EXTR_BAD_STARTING_NODE,
 837       EXTR_BAD_ANGLES_NUMBER,
 838       EXTR_CANT_GET_TANGENT
 839       };
 840
 841     Extrusion_Error ExtrusionAlongPath(in long_array        IDsOfElements,
 842                                        in SMESH_Mesh        PathMesh,
 843                                        in GEOM::GEOM_Object PathShape,
 844                                        in long              NodeStart,
 845                                        in boolean           HasAngles,
 846                                        in double_array      Angles,
 847                                        in boolean           HasRefPoint,
 848                                        in PointStruct       RefPoint);
 849
 850     Extrusion_Error ExtrusionAlongPathObject(in SMESH_IDSource    theObject,
 851                                              in SMESH_Mesh        PathMesh,
 852                                              in GEOM::GEOM_Object PathShape,
 853                                              in long              NodeStart,
 854                                              in boolean           HasAngles,
 855                                              in double_array      Angles,
 856                                              in boolean           HasRefPoint,
 857                                              in PointStruct       RefPoint);
 858
 859     enum MirrorType { POINT, AXIS, PLANE };
 860
 861     void Mirror (in long_array       IDsOfElements,
 862                  in AxisStruct       Mirror,
 863                  in MirrorType       theMirrorType,
 864                  in boolean          Copy);
 865
 866     void MirrorObject (in SMESH_IDSource  theObject,
 867                        in AxisStruct      Mirror,
 868                        in MirrorType      theMirrorType,
 869                        in boolean         Copy);
 870
 871     void Translate (in long_array      IDsOfElements,
 872                     in DirStruct       Vector,
 873                     in boolean         Copy);
 874
 875     void TranslateObject (in SMESH_IDSource  theObject,
 876                           in DirStruct       Vector,
 877                           in boolean         Copy);
 878
 879     void Rotate (in long_array       IDsOfElements,
 880                  in AxisStruct       Axis,
 881                  in double           AngleInRadians,
 882                  in boolean          Copy);
 883
 884     void RotateObject (in SMESH_IDSource  theObject,
 885                        in AxisStruct      Axis,
 886                        in double          AngleInRadians,
 887                        in boolean         Copy);
 888
 889     void FindCoincidentNodes (in  double              Tolerance,
 890                               out array_of_long_array GroupsOfNodes);
 891
 892     void MergeNodes (in array_of_long_array GroupsOfNodes);
 893
 894     void MergeEqualElements();
 895
 896     enum Sew_Error {
 897       SEW_OK,
 898       SEW_BORDER1_NOT_FOUND,
 899       SEW_BORDER2_NOT_FOUND,
 900       SEW_BOTH_BORDERS_NOT_FOUND,
 901       SEW_BAD_SIDE_NODES,
 902       SEW_VOLUMES_TO_SPLIT,
 903       // for SewSideElements() only:
 904       SEW_DIFF_NB_OF_ELEMENTS,
 905       SEW_TOPO_DIFF_SETS_OF_ELEMENTS,
 906       SEW_BAD_SIDE1_NODES,
 907       SEW_BAD_SIDE2_NODES
 908       };
 909
 910     Sew_Error SewFreeBorders (in long FirstNodeID1,
 911                               in long SecondNodeID1,
 912                               in long LastNodeID1,
 913                               in long FirstNodeID2,
 914                               in long SecondNodeID2,
 915                               in long LastNodeID2,
 916                               in boolean CreatePolygons,
 917                               in boolean CreatePolyedrs);
 918
 919     Sew_Error SewConformFreeBorders (in long FirstNodeID1,
 920                                      in long SecondNodeID1,
 921                                      in long LastNodeID1,
 922                                      in long FirstNodeID2,
 923                                      in long SecondNodeID2);
 924
 925     Sew_Error SewBorderToSide (in long FirstNodeIDOnFreeBorder,
 926                                in long SecondNodeIDOnFreeBorder,
 927                                in long LastNodeIDOnFreeBorder,
 928                                in long FirstNodeIDOnSide,
 929                                in long LastNodeIDOnSide,
 930                                in boolean CreatePolygons,
 931                                in boolean CreatePolyedrs);
 932
 933     Sew_Error SewSideElements (in long_array IDsOfSide1Elements,
 934                                in long_array IDsOfSide2Elements,
 935                                in long       NodeID1OfSide1ToMerge,
 936                                in long       NodeID1OfSide2ToMerge,
 937                                in long       NodeID2OfSide1ToMerge,
 938                                in long       NodeID2OfSide2ToMerge);
 939
 940    /*!
 941     * Set new nodes for given element.
 942     * If number of nodes is not corresponded to type of
 943     * element - returns false
 944     */
 945     boolean ChangeElemNodes(in long ide, in long_array newIDs);
 946
 947    /*!
 948     * If during last operation of MeshEditor some nodes were
 949     * created this method returns list of it's IDs, if new nodes
 950     * not creared - returns empty list
 951     */
 952     long_array GetLastCreatedNodes();
 953
 954    /*!
 955     * If during last operation of MeshEditor some elements were
 956     * created this method returns list of it's IDs, if new elements
 957     * not creared - returns empty list
 958     */
 959     long_array GetLastCreatedElems();
 960
 961   };
 962 };
 963
 964 #endif