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