idl/SMESH_MeshEditor.idl

   1 // Copyright (C) 2007-2012  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 //  File   : SMESH_MeshEditor.idl
  23
  24 #ifndef _SMESH_MESHEDITOR_IDL_
  25 #define _SMESH_MESHEDITOR_IDL_
  26
  27 #include "SMESH_Mesh.idl"
  28
  29 module SMESH
  30 {
  31   enum Bnd_Dimension { BND_2DFROM3D, BND_1DFROM3D, BND_1DFROM2D };
  32
  33   /*!
  34    * This interface makes modifications on the Mesh - removing elements and nodes etc.
  35    */
  36   interface NumericalFunctor;
  37   interface SMESH_MeshEditor
  38   {
  39     /*!
  40      * \brief Wrap a sequence of ids in a SMESH_IDSource
  41      * \param IDsOfElements list of mesh elements identifiers
  42      * \return new ID source object
  43      */
  44     SMESH_IDSource MakeIDSource(in long_array IDsOfElements, in ElementType type);
  45
  46     /*!
  47      * \brief Remove mesh elements specified by their identifiers.
  48      * \param IDsOfElements list of mesh elements identifiers
  49      * \return \c true if elements are correctly removed or \c false otherwise
  50      */
  51     boolean RemoveElements(in long_array IDsOfElements);
  52
  53     /*!
  54      * \brief Remove mesh nodes specified by their identifiers.
  55      * \param IDsOfNodes list of mesh nodes identifiers
  56      * \return \c true if nodes are correctly removed or \c false otherwise
  57      */
  58     boolean RemoveNodes(in long_array IDsOfNodes);
  59
  60     /*!
  61      * \brief Remove all orphan nodes.
  62      * \return number of removed nodes
  63      */
  64     long RemoveOrphanNodes();
  65
  66     /*!
  67      * \brief Add a new node.
  68      * \param x X coordinate of new node
  69      * \param y Y coordinate of new node
  70      * \param z Z coordinate of new node
  71      * \return integer identifier of new node
  72      */
  73     long AddNode(in double x, in double y, in double z);
  74
  75     /*!
  76      *  Create a 0D element on the given node.
  77      *  \param IdOfNode Node IDs for creation of element.
  78      */
  79     long Add0DElement(in long IDOfNode);
  80
  81     /*!
  82      *  Create a ball element on the given node.
  83      *  \param IdOfNode Node IDs for creation of element.
  84      */
  85     long AddBall(in long IDOfNode, in double diameter);
  86
  87     /*!
  88      *  Create an edge, either linear and quadratic (this is determed
  89      *  by number of given nodes, two or three).
  90      *  \param IdsOfNodes List of node IDs for creation of element.
  91      *  Needed order of nodes in this list corresponds to description
  92      *  of MED. This description is located by the following link:
  93      *   http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
  94      */
  95     long AddEdge(in long_array IDsOfNodes);
  96
  97     /*!
  98      *  Create face, either linear and quadratic (this is determed
  99      *  by number of given nodes).
 100      *  \param IdsOfNodes List of node IDs for creation of element.
 101      *  Needed order of nodes in this list corresponds to description
 102      *  of MED. This description is located by the following link:
 103      *   http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
 104      */
 105     long AddFace(in long_array IDsOfNodes);
 106
 107     long AddPolygonalFace(in long_array IdsOfNodes);
 108
 109     /*!
 110      *  Create volume, either linear and quadratic (this is determed
 111      *  by number of given nodes).
 112      *  \param IdsOfNodes List of node IDs for creation of element.
 113      *  Needed order of nodes in this list corresponds to description
 114      *  of MED. This description is located by the following link:
 115      *   http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
 116      */
 117     long AddVolume(in long_array IDsOfNodes);
 118
 119     /*!
 120      *  Create volume of many faces, giving nodes for each face.
 121      *  \param IdsOfNodes List of node IDs for volume creation face by face.
 122      *  \param Quantities List of integer values, Quantities[i]
 123      *         gives quantity of nodes in face number i.
 124      */
 125     long AddPolyhedralVolume (in long_array IdsOfNodes,
 126                               in long_array Quantities);
 127
 128     /*!
 129      *  Create volume of many faces, giving IDs of existing faces.
 130      *  \param IdsOfFaces List of face IDs for volume creation.
 131      *  \note The created volume will refer only to nodes
 132      *        of the given faces, not to the faces itself.
 133      */
 134     long AddPolyhedralVolumeByFaces (in long_array IdsOfFaces);
 135
 136     /*!
 137      * \brief Bind a node to a vertex
 138       * \param NodeID - node ID
 139       * \param VertexID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
 140      */
 141     void SetNodeOnVertex(in long NodeID, in long VertexID)
 142       raises (SALOME::SALOME_Exception);
 143     /*!
 144      * \brief Store node position on an edge
 145       * \param NodeID - node ID
 146       * \param EdgeID - edge ID available through GEOM_Object.GetSubShapeIndices()[0]
 147       * \param paramOnEdge - parameter on edge where the node is located
 148      */
 149     void SetNodeOnEdge(in long NodeID, in long EdgeID, in double paramOnEdge)
 150       raises (SALOME::SALOME_Exception);
 151     /*!
 152      * \brief Store node position on a face
 153       * \param NodeID - node ID
 154       * \param FaceID - face ID available through GEOM_Object.GetSubShapeIndices()[0]
 155       * \param u - U parameter on face where the node is located
 156       * \param v - V parameter on face where the node is located
 157      */
 158     void SetNodeOnFace(in long NodeID, in long FaceID, in double u, in double v)
 159       raises (SALOME::SALOME_Exception);
 160     /*!
 161      * \brief Bind a node to a solid
 162       * \param NodeID - node ID
 163       * \param SolidID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
 164      */
 165     void SetNodeInVolume(in long NodeID, in long SolidID)
 166       raises (SALOME::SALOME_Exception);
 167     /*!
 168      * \brief Bind an element to a shape
 169       * \param ElementID - element ID
 170       * \param ShapeID - shape ID available through GEOM_Object.GetSubShapeIndices()[0]
 171      */
 172     void SetMeshElementOnShape(in long ElementID, in long ShapeID)
 173       raises (SALOME::SALOME_Exception);
 174
 175
 176     boolean MoveNode(in long NodeID, in double x, in double y, in double z);
 177
 178     boolean InverseDiag(in long NodeID1, in long NodeID2);
 179
 180     boolean DeleteDiag(in long NodeID1, in long NodeID2);
 181
 182     boolean Reorient(in long_array IDsOfElements);
 183
 184     boolean ReorientObject(in SMESH_IDSource theObject);
 185     /*!
 186      * \brief Reorient faces contained in \a the2Dgroup.
 187      * \param the2Dgroup - the mesh or its part to reorient
 188      * \param theDirection - desired direction of normal of \a theFace
 189      * \param theFace - ID of face whose orientation is checked.
 190      *        It can be < 1 then \a thePoint is used to find a face.
 191      * \param thePoint - is used to find a face if \a theFace < 1.
 192      * \return number of reoriented elements.
 193      */
 194     long Reorient2D(in SMESH_IDSource the2Dgroup,
 195                     in DirStruct      theDirection,
 196                     in long           theFace,
 197                     in PointStruct    thePoint) raises (SALOME::SALOME_Exception);
 198
 199     /*!
 200      * \brief Fuse neighbour triangles into quadrangles.
 201      * \param theElems     The triangles to be fused.
 202      * \param theCriterion Is used to choose a neighbour to fuse with.
 203      * \param theMaxAngle  Is a max angle between element normals at which fusion
 204      *                     is still performed; theMaxAngle is mesured in radians.
 205      * \return TRUE in case of success, FALSE otherwise.
 206      */
 207     boolean TriToQuad (in long_array       IDsOfElements,
 208                        in NumericalFunctor Criterion,
 209                        in double           MaxAngle);
 210
 211     /*!
 212      * \brief Fuse neighbour triangles into quadrangles.
 213      *
 214      * Behaves like the above method, taking list of elements from \a theObject
 215      */
 216     boolean TriToQuadObject (in SMESH_IDSource   theObject,
 217                              in NumericalFunctor Criterion,
 218                              in double           MaxAngle);
 219
 220     /*!
 221      * \brief Split quadrangles into triangles.
 222      * \param theElems     The faces to be splitted.
 223      * \param theCriterion Is used to choose a diagonal for splitting.
 224      * \return TRUE in case of success, FALSE otherwise.
 225      */
 226     boolean QuadToTri (in long_array       IDsOfElements,
 227                        in NumericalFunctor Criterion);
 228
 229     /*!
 230      * \brief Split quadrangles into triangles.
 231      *
 232      * Behaves like the above method, taking list of elements from \a theObject
 233      */
 234     boolean QuadToTriObject (in SMESH_IDSource   theObject,
 235                              in NumericalFunctor Criterion);
 236
 237     /*!
 238      * \brief Split quadrangles into triangles.
 239      * \param theElems  The faces to be splitted.
 240      * \param the13Diag Is used to choose a diagonal for splitting.
 241      * \return TRUE in case of success, FALSE otherwise.
 242      */
 243     boolean SplitQuad (in long_array IDsOfElements,
 244                        in boolean    Diag13);
 245
 246     /*!
 247      * \brief Split quadrangles into triangles.
 248      *
 249      * Behaves like the above method, taking list of elements from \a theObject
 250      */
 251     boolean SplitQuadObject (in SMESH_IDSource theObject,
 252                              in boolean        Diag13);
 253
 254     /*!
 255      *  Find better splitting of the given quadrangle.
 256      *  \param IDOfQuad  ID of the quadrangle to be splitted.
 257      *  \param Criterion A criterion to choose a diagonal for splitting.
 258      *  \return 1 if 1-3 diagonal is better, 2 if 2-4
 259      *          diagonal is better, 0 if error occurs.
 260      */
 261     long BestSplit (in long             IDOfQuad,
 262                     in NumericalFunctor Criterion);
 263
 264     /*!
 265      * \brief Split volumic elements into tetrahedrons
 266      *  \param elems - elements to split
 267      *  \param methodFlags - flags passing splitting method:
 268      *         1 - split the hexahedron into 5 tetrahedrons
 269      *         2 - split the hexahedron into 6 tetrahedrons
 270      *         3 - split the hexahedron into 24 tetrahedrons
 271      */
 272     void SplitVolumesIntoTetra(in SMESH_IDSource elems, in short methodFlags)
 273       raises (SALOME::SALOME_Exception);
 274
 275
 276     enum Smooth_Method { LAPLACIAN_SMOOTH, CENTROIDAL_SMOOTH };
 277
 278     boolean Smooth(in long_array    IDsOfElements,
 279                    in long_array    IDsOfFixedNodes,
 280                    in long          MaxNbOfIterations,
 281                    in double        MaxAspectRatio,
 282                    in Smooth_Method Method);
 283
 284     boolean SmoothObject(in SMESH_IDSource  theObject,
 285                          in long_array      IDsOfFixedNodes,
 286                          in long            MaxNbOfIterations,
 287                          in double          MaxAspectRatio,
 288                          in Smooth_Method   Method);
 289
 290     boolean SmoothParametric(in long_array    IDsOfElements,
 291                              in long_array    IDsOfFixedNodes,
 292                              in long          MaxNbOfIterations,
 293                              in double        MaxAspectRatio,
 294                              in Smooth_Method Method);
 295
 296     boolean SmoothParametricObject(in SMESH_IDSource  theObject,
 297                                    in long_array      IDsOfFixedNodes,
 298                                    in long            MaxNbOfIterations,
 299                                    in double          MaxAspectRatio,
 300                                    in Smooth_Method   Method);
 301
 302     void ConvertToQuadratic(in boolean theForce3d);
 303
 304     boolean ConvertFromQuadratic();
 305
 306     void ConvertToQuadraticObject(in boolean        theForce3d,
 307                                   in SMESH_IDSource theObject)
 308       raises (SALOME::SALOME_Exception);
 309
 310     void ConvertFromQuadraticObject(in SMESH_IDSource theObject)
 311       raises (SALOME::SALOME_Exception);
 312
 313     void RenumberNodes();
 314
 315     void RenumberElements();
 316
 317     /*!
 318      * \brief Genarate dim+1 elements by rotation of given elements around axis
 319      * \param IDsOfElements - elements to ratate
 320      * \param Axix - rotation axis
 321      * \param AngleInRadians - rotation angle
 322      * \param NbOfSteps - number of elements to generate from one element
 323      */
 324     void RotationSweep(in long_array       IDsOfElements,
 325                        in AxisStruct       Axix,
 326                        in double           AngleInRadians,
 327                        in long             NbOfSteps,
 328                        in double           Tolerance);
 329     /*!
 330      * \brief Same as previous but additionally create groups of elements
 331      *  generated from elements belonging to preexisting groups
 332      */
 333     ListOfGroups RotationSweepMakeGroups(in long_array       IDsOfElements,
 334                                          in AxisStruct       Axix,
 335                                          in double           AngleInRadians,
 336                                          in long             NbOfSteps,
 337                                          in double           Tolerance);
 338     /*!
 339      * \brief Genarate dim+1 elements by rotation of the object around axis
 340      * \param theObject - object containing elements to ratate
 341      * \param Axix - rotation axis
 342      * \param AngleInRadians - rotation angle
 343      * \param NbOfSteps - number of elements to generate from one element
 344      */
 345     void RotationSweepObject(in SMESH_IDSource  theObject,
 346                              in AxisStruct      Axix,
 347                              in double          AngleInRadians,
 348                              in long            NbOfSteps,
 349                              in double          Tolerance);
 350     /*!
 351      * \brief Same as previous but additionally create groups of elements
 352      *  generated from elements belonging to preexisting groups
 353      */
 354     ListOfGroups RotationSweepObjectMakeGroups(in SMESH_IDSource  theObject,
 355                                                in AxisStruct      Axix,
 356                                                in double          AngleInRadians,
 357                                                in long            NbOfSteps,
 358                                                in double          Tolerance);
 359     /*!
 360      * \brief Genarate dim+1 elements by rotation of the object around axis
 361      * \param theObject - object containing elements to ratate
 362      * \param Axix - rotation axis
 363      * \param AngleInRadians - rotation angle
 364      * \param NbOfSteps - number of elements to generate from one element
 365      */
 366     void RotationSweepObject1D(in SMESH_IDSource  theObject,
 367                                in AxisStruct      Axix,
 368                                in double          AngleInRadians,
 369                                in long            NbOfSteps,
 370                                in double          Tolerance);
 371     /*!
 372      * \brief Same as previous but additionally create groups of elements
 373      *  generated from elements belonging to preexisting groups
 374      */
 375     ListOfGroups RotationSweepObject1DMakeGroups(in SMESH_IDSource  theObject,
 376                                                  in AxisStruct      Axix,
 377                                                  in double          AngleInRadians,
 378                                                  in long            NbOfSteps,
 379                                                  in double          Tolerance);
 380     /*!
 381      * \brief Genarate dim+1 elements by rotation of the object around axis
 382      * \param theObject - object containing elements to ratate
 383      * \param Axix - rotation axis
 384      * \param AngleInRadians - rotation angle
 385      * \param NbOfSteps - number of elements to generate from one element
 386      */
 387     void RotationSweepObject2D(in SMESH_IDSource  theObject,
 388                                in AxisStruct      Axix,
 389                                in double          AngleInRadians,
 390                                in long            NbOfSteps,
 391                                in double          Tolerance);
 392     /*!
 393      * \brief Same as previous but additionally create groups of elements
 394      *  generated from elements belonging to preexisting groups
 395      */
 396     ListOfGroups RotationSweepObject2DMakeGroups(in SMESH_IDSource  theObject,
 397                                                  in AxisStruct      Axix,
 398                                                  in double          AngleInRadians,
 399                                                  in long            NbOfSteps,
 400                                                  in double          Tolerance);
 401     /*!
 402      * \brief Genarate dim+1 elements by extrusion of elements along vector
 403      * \param IDsOfElements - elements to sweep
 404      * \param StepVector - vector giving direction and distance of an extrusion step
 405      * \param NbOfSteps - number of elements to generate from one element
 406      */
 407     void ExtrusionSweep(in long_array      IDsOfElements,
 408                         in DirStruct       StepVector,
 409                         in long            NbOfSteps);
 410     /*!
 411      * \brief Genarate dim+1 elements by extrusion of elements along vector
 412      * \param IDsOfElements - elements to sweep
 413      * \param StepVector - vector giving direction and distance of an extrusion step
 414      * \param NbOfSteps - number of elements to generate from one element
 415      */
 416     void ExtrusionSweep0D(in long_array    IDsOfElements,
 417                         in DirStruct       StepVector,
 418                         in long            NbOfSteps);
 419     /*!
 420      * \brief Same as previous but additionally create groups of elements
 421      *  generated from elements belonging to preexisting groups
 422      */
 423     ListOfGroups ExtrusionSweepMakeGroups(in long_array      IDsOfElements,
 424                                           in DirStruct       StepVector,
 425                                           in long            NbOfSteps);
 426    /*!
 427      * \brief Same as previous but elements are nodes
 428      */
 429     ListOfGroups ExtrusionSweepMakeGroups0D(in long_array      IDsOfElements,
 430                                           in DirStruct       StepVector,
 431                                           in long            NbOfSteps);
 432    /*!
 433     * Generate new elements by extrusion of theElements
 434     * by StepVector by NbOfSteps
 435     * param ExtrFlags set flags for performing extrusion
 436     * param SewTolerance - uses for comparing locations of nodes if flag
 437     *   EXTRUSION_FLAG_SEW is set
 438     */
 439     void AdvancedExtrusion(in long_array      IDsOfElements,
 440                            in DirStruct       StepVector,
 441                            in long            NbOfSteps,
 442                            in long            ExtrFlags,
 443                            in double          SewTolerance);
 444     /*!
 445      * \brief Same as previous but additionally create groups of elements
 446      *  generated from elements belonging to preexisting groups
 447      */
 448     ListOfGroups AdvancedExtrusionMakeGroups(in long_array      IDsOfElements,
 449                                              in DirStruct       StepVector,
 450                                              in long            NbOfSteps,
 451                                              in long            ExtrFlags,
 452                                              in double          SewTolerance);
 453
 454     void ExtrusionSweepObject(in SMESH_IDSource  theObject,
 455                               in DirStruct       StepVector,
 456                               in long            NbOfSteps);
 457     ListOfGroups ExtrusionSweepObjectMakeGroups(in SMESH_IDSource  theObject,
 458                                                 in DirStruct       StepVector,
 459                                                 in long            NbOfSteps);
 460
 461     void ExtrusionSweepObject0D(in SMESH_IDSource theObject,
 462                                 in DirStruct      StepVector,
 463                                 in long           NbOfSteps);
 464     ListOfGroups ExtrusionSweepObject0DMakeGroups(in SMESH_IDSource theObject,
 465                                                   in DirStruct      StepVector,
 466                                                   in long           NbOfSteps);
 467
 468     void ExtrusionSweepObject1D(in SMESH_IDSource theObject,
 469                                 in DirStruct      StepVector,
 470                                 in long           NbOfSteps);
 471     ListOfGroups ExtrusionSweepObject1DMakeGroups(in SMESH_IDSource theObject,
 472                                                   in DirStruct      StepVector,
 473                                                   in long           NbOfSteps);
 474
 475     void ExtrusionSweepObject2D(in SMESH_IDSource theObject,
 476                                 in DirStruct      StepVector,
 477                                 in long           NbOfSteps);
 478     ListOfGroups ExtrusionSweepObject2DMakeGroups(in SMESH_IDSource theObject,
 479                                                   in DirStruct      StepVector,
 480                                                   in long           NbOfSteps);
 481
 482     enum Extrusion_Error {
 483       EXTR_OK,
 484       EXTR_NO_ELEMENTS,
 485       EXTR_PATH_NOT_EDGE,
 486       EXTR_BAD_PATH_SHAPE,
 487       EXTR_BAD_STARTING_NODE,
 488       EXTR_BAD_ANGLES_NUMBER,
 489       EXTR_CANT_GET_TANGENT
 490       };
 491
 492     ListOfGroups ExtrusionAlongPathX(in long_array        IDsOfElements,
 493                                      in SMESH_IDSource    Path,
 494                                      in long              NodeStart,
 495                                      in boolean           HasAngles,
 496                                      in double_array      Angles,
 497                                      in boolean           LinearVariation,
 498                                      in boolean           HasRefPoint,
 499                                      in PointStruct       RefPoint,
 500                                      in boolean           MakeGroups,
 501                                      in ElementType       ElemType,
 502                                      out Extrusion_Error  Error);
 503
 504     ListOfGroups ExtrusionAlongPathObjX(in SMESH_IDSource    theObject,
 505                                         in SMESH_IDSource    Path,
 506                                         in long              NodeStart,
 507                                         in boolean           HasAngles,
 508                                         in double_array      Angles,
 509                                         in boolean           LinearVariation,
 510                                         in boolean           HasRefPoint,
 511                                         in PointStruct       RefPoint,
 512                                         in boolean           MakeGroups,
 513                                         in ElementType       ElemType,
 514                                         out Extrusion_Error  Error);
 515
 516     Extrusion_Error ExtrusionAlongPath(in long_array        IDsOfElements,
 517                                        in SMESH_Mesh        PathMesh,
 518                                        in GEOM::GEOM_Object PathShape,
 519                                        in long              NodeStart,
 520                                        in boolean           HasAngles,
 521                                        in double_array      Angles,
 522                                        in boolean           HasRefPoint,
 523                                        in PointStruct       RefPoint);
 524     ListOfGroups ExtrusionAlongPathMakeGroups(in long_array        IDsOfElements,
 525                                               in SMESH_Mesh        PathMesh,
 526                                               in GEOM::GEOM_Object PathShape,
 527                                               in long              NodeStart,
 528                                               in boolean           HasAngles,
 529                                               in double_array      Angles,
 530                                               in boolean           HasRefPoint,
 531                                               in PointStruct       RefPoint,
 532                                               out Extrusion_Error  Error);
 533
 534     Extrusion_Error ExtrusionAlongPathObject(in SMESH_IDSource    theObject,
 535                                              in SMESH_Mesh        PathMesh,
 536                                              in GEOM::GEOM_Object PathShape,
 537                                              in long              NodeStart,
 538                                              in boolean           HasAngles,
 539                                              in double_array      Angles,
 540                                              in boolean           HasRefPoint,
 541                                              in PointStruct       RefPoint);
 542     ListOfGroups ExtrusionAlongPathObjectMakeGroups(in SMESH_IDSource    theObject,
 543                                                     in SMESH_Mesh        PathMesh,
 544                                                     in GEOM::GEOM_Object PathShape,
 545                                                     in long              NodeStart,
 546                                                     in boolean           HasAngles,
 547                                                     in double_array      Angles,
 548                                                     in boolean           HasRefPoint,
 549                                                     in PointStruct       RefPoint,
 550                                                     out Extrusion_Error  Error);
 551
 552     Extrusion_Error ExtrusionAlongPathObject1D(in SMESH_IDSource    theObject,
 553                                                in SMESH_Mesh        PathMesh,
 554                                                in GEOM::GEOM_Object PathShape,
 555                                                in long              NodeStart,
 556                                                in boolean           HasAngles,
 557                                                in double_array      Angles,
 558                                                in boolean           HasRefPoint,
 559                                                in PointStruct       RefPoint);
 560     ListOfGroups ExtrusionAlongPathObject1DMakeGroups(in SMESH_IDSource    theObject,
 561                                                       in SMESH_Mesh        PathMesh,
 562                                                       in GEOM::GEOM_Object PathShape,
 563                                                       in long              NodeStart,
 564                                                       in boolean           HasAngles,
 565                                                       in double_array      Angles,
 566                                                       in boolean           HasRefPoint,
 567                                                       in PointStruct       RefPoint,
 568                                                       out Extrusion_Error  Error);
 569
 570     Extrusion_Error ExtrusionAlongPathObject2D(in SMESH_IDSource    theObject,
 571                                                in SMESH_Mesh        PathMesh,
 572                                                in GEOM::GEOM_Object PathShape,
 573                                                in long              NodeStart,
 574                                                in boolean           HasAngles,
 575                                                in double_array      Angles,
 576                                                in boolean           HasRefPoint,
 577                                                in PointStruct       RefPoint);
 578     ListOfGroups ExtrusionAlongPathObject2DMakeGroups(in SMESH_IDSource    theObject,
 579                                                       in SMESH_Mesh        PathMesh,
 580                                                       in GEOM::GEOM_Object PathShape,
 581                                                       in long              NodeStart,
 582                                                       in boolean           HasAngles,
 583                                                       in double_array      Angles,
 584                                                       in boolean           HasRefPoint,
 585                                                       in PointStruct       RefPoint,
 586                                                       out Extrusion_Error  Error);
 587
 588    /*!
 589     * Compute rotation angles for ExtrusionAlongPath as linear variation
 590     * of given angles along path steps
 591     * param PathMesh mesh containing a 1D sub-mesh on the edge, along
 592     *                which proceeds the extrusion
 593     * param PathShape is shape(edge); as the mesh can be complex, the edge
 594     *                 is used to define the sub-mesh for the path
 595     */
 596     double_array LinearAnglesVariation(in SMESH_Mesh        PathMesh,
 597                                        in GEOM::GEOM_Object PathShape,
 598                                        in double_array      Angles);
 599
 600     enum MirrorType { POINT, AXIS, PLANE };
 601
 602     void Mirror (in long_array IDsOfElements,
 603                  in AxisStruct Mirror,
 604                  in MirrorType Type,
 605                  in boolean    Copy);
 606     ListOfGroups MirrorMakeGroups (in long_array IDsOfElements,
 607                                    in AxisStruct Mirror,
 608                                    in MirrorType Type);
 609     SMESH_Mesh MirrorMakeMesh (in long_array IDsOfElements,
 610                                in AxisStruct Mirror,
 611                                in MirrorType Type,
 612                                in boolean    CopyGroups,
 613                                in string     MeshName);
 614
 615     void MirrorObject (in SMESH_IDSource theObject,
 616                        in AxisStruct     Mirror,
 617                        in MirrorType     Type,
 618                        in boolean        Copy);
 619     ListOfGroups MirrorObjectMakeGroups (in SMESH_IDSource theObject,
 620                                          in AxisStruct     Mirror,
 621                                          in MirrorType     Type);
 622     SMESH_Mesh MirrorObjectMakeMesh (in SMESH_IDSource theObject,
 623                                      in AxisStruct     Mirror,
 624                                      in MirrorType     Type,
 625                                      in boolean        CopyGroups,
 626                                      in string         MeshName);
 627
 628     void Translate (in long_array IDsOfElements,
 629                     in DirStruct  Vector,
 630                     in boolean    Copy);
 631     ListOfGroups TranslateMakeGroups (in long_array IDsOfElements,
 632                                       in DirStruct  Vector);
 633     SMESH_Mesh TranslateMakeMesh (in long_array IDsOfElements,
 634                                   in DirStruct  Vector,
 635                                   in boolean    CopyGroups,
 636                                   in string     MeshName);
 637
 638     void TranslateObject (in SMESH_IDSource theObject,
 639                           in DirStruct      Vector,
 640                           in boolean        Copy);
 641     ListOfGroups TranslateObjectMakeGroups (in SMESH_IDSource theObject,
 642                                             in DirStruct      Vector);
 643     SMESH_Mesh TranslateObjectMakeMesh (in SMESH_IDSource theObject,
 644                                         in DirStruct      Vector,
 645                                         in boolean        CopyGroups,
 646                                         in string         MeshName);
 647
 648     void Scale (in SMESH_IDSource theObject,
 649                 in PointStruct    thePoint,
 650                 in double_array   theScaleFact,
 651                 in boolean        Copy);
 652     ListOfGroups ScaleMakeGroups (in SMESH_IDSource theObject,
 653                                   in PointStruct    thePoint,
 654                                   in double_array   theScaleFact);
 655     SMESH_Mesh ScaleMakeMesh (in SMESH_IDSource theObject,
 656                               in PointStruct    thePoint,
 657                               in double_array   theScaleFact,
 658                               in boolean        CopyGroups,
 659                               in string         MeshName);
 660
 661     void Rotate (in long_array IDsOfElements,
 662                  in AxisStruct Axis,
 663                  in double     AngleInRadians,
 664                  in boolean    Copy);
 665     ListOfGroups RotateMakeGroups (in long_array IDsOfElements,
 666                                    in AxisStruct Axis,
 667                                    in double     AngleInRadians);
 668     SMESH_Mesh RotateMakeMesh (in long_array IDsOfElements,
 669                                in AxisStruct Axis,
 670                                in double     AngleInRadians,
 671                                in boolean    CopyGroups,
 672                                in string     MeshName);
 673
 674     void RotateObject (in SMESH_IDSource theObject,
 675                        in AxisStruct     Axis,
 676                        in double         AngleInRadians,
 677                        in boolean        Copy);
 678     ListOfGroups RotateObjectMakeGroups (in SMESH_IDSource theObject,
 679                                          in AxisStruct     Axis,
 680                                          in double         AngleInRadians);
 681     SMESH_Mesh RotateObjectMakeMesh (in SMESH_IDSource theObject,
 682                                      in AxisStruct     Axis,
 683                                      in double         AngleInRadians,
 684                                      in boolean        CopyGroups,
 685                                      in string         MeshName);
 686
 687     void FindCoincidentNodes (in  double              Tolerance,
 688                               out array_of_long_array GroupsOfNodes);
 689
 690     void FindCoincidentNodesOnPart (in  SMESH_IDSource      SubMeshOrGroup,
 691                                     in  double              Tolerance,
 692                                     out array_of_long_array GroupsOfNodes);
 693
 694     void FindCoincidentNodesOnPartBut (in  SMESH_IDSource      SubMeshOrGroup,
 695                                        in  double              Tolerance,
 696                                        out array_of_long_array GroupsOfNodes,
 697                                        in  ListOfIDSources     ExceptSubMeshOrGroups);
 698
 699     void MergeNodes (in array_of_long_array GroupsOfNodes);
 700
 701     /*!
 702      * \brief Find elements built on the same nodes.
 703      * \param MeshOrSubMeshOrGroup Mesh or SubMesh, or Group of elements for searching.
 704      * \return List of groups of equal elements.
 705      */
 706     void FindEqualElements (in  SMESH_IDSource      MeshOrSubMeshOrGroup,
 707                             out array_of_long_array GroupsOfElementsID);
 708
 709     /*!
 710      * \brief Merge elements in each given group.
 711      * \param GroupsOfElementsID Groups of elements for merging.
 712      */
 713     void MergeElements(in array_of_long_array GroupsOfElementsID);
 714
 715     /*!
 716      * \brief Merge equal elements in the whole mesh.
 717      */
 718     void MergeEqualElements();
 719
 720     /*!
 721      * If the given ID is a valid node ID (nodeID > 0), just move this node, else
 722      * move the node closest to the point to point's location and return ID of the node
 723      */
 724     long MoveClosestNodeToPoint(in double x, in double y, in double z, in long nodeID);
 725
 726     /*!
 727      * Return ID of node closest to a given point
 728      */
 729     long FindNodeClosestTo(in double x, in double y, in double z);
 730
 731     /*!
 732      * Return elements of given type where the given point is IN or ON.
 733      *
 734      * 'ALL' type means elements of any type excluding nodes and 0D elements
 735      */
 736     long_array FindElementsByPoint(in double x, in double y, in double z, in ElementType type);
 737
 738     /*!
 739      * Searching among the given elements, return elements of given type
 740      * where the given point is IN or ON.
 741      *
 742      * 'ALL' type means elements of any type excluding nodes and 0D elements
 743      */
 744     long_array FindAmongElementsByPoint(in SMESH_IDSource elements,
 745                                         in double x, in double y, in double z,
 746                                         in ElementType type);
 747
 748     /*!
 749      * Return point state in a closed 2D mesh in terms of TopAbs_State enumeration.
 750      * TopAbs_UNKNOWN state means that either mesh is wrong or the analysis fails.
 751      */
 752     short GetPointState(in double x, in double y, in double z);
 753
 754     enum Sew_Error {
 755       SEW_OK,
 756       SEW_BORDER1_NOT_FOUND,
 757       SEW_BORDER2_NOT_FOUND,
 758       SEW_BOTH_BORDERS_NOT_FOUND,
 759       SEW_BAD_SIDE_NODES,
 760       SEW_VOLUMES_TO_SPLIT,
 761       // for SewSideElements() only:
 762       SEW_DIFF_NB_OF_ELEMENTS,
 763       SEW_TOPO_DIFF_SETS_OF_ELEMENTS,
 764       SEW_BAD_SIDE1_NODES,
 765       SEW_BAD_SIDE2_NODES
 766       };
 767
 768     Sew_Error SewFreeBorders (in long FirstNodeID1,
 769                               in long SecondNodeID1,
 770                               in long LastNodeID1,
 771                               in long FirstNodeID2,
 772                               in long SecondNodeID2,
 773                               in long LastNodeID2,
 774                               in boolean CreatePolygons,
 775                               in boolean CreatePolyedrs);
 776
 777     Sew_Error SewConformFreeBorders (in long FirstNodeID1,
 778                                      in long SecondNodeID1,
 779                                      in long LastNodeID1,
 780                                      in long FirstNodeID2,
 781                                      in long SecondNodeID2);
 782
 783     Sew_Error SewBorderToSide (in long FirstNodeIDOnFreeBorder,
 784                                in long SecondNodeIDOnFreeBorder,
 785                                in long LastNodeIDOnFreeBorder,
 786                                in long FirstNodeIDOnSide,
 787                                in long LastNodeIDOnSide,
 788                                in boolean CreatePolygons,
 789                                in boolean CreatePolyedrs);
 790
 791     Sew_Error SewSideElements (in long_array IDsOfSide1Elements,
 792                                in long_array IDsOfSide2Elements,
 793                                in long       NodeID1OfSide1ToMerge,
 794                                in long       NodeID1OfSide2ToMerge,
 795                                in long       NodeID2OfSide1ToMerge,
 796                                in long       NodeID2OfSide2ToMerge);
 797
 798    /*!
 799     * Set new nodes for given element.
 800     * If number of nodes is not corresponded to type of
 801     * element - returns false
 802     */
 803     boolean ChangeElemNodes(in long ide, in long_array newIDs);
 804
 805    /*!
 806     * Return data of mesh edition preview which is computed provided
 807     * that the editor was obtained trough SMESH_Mesh::GetMeshEditPreviewer()
 808     */
 809     MeshPreviewStruct GetPreviewData();
 810
 811    /*!
 812     * If during last operation of MeshEditor some nodes were
 813     * created this method returns list of it's IDs, if new nodes
 814     * not creared - returns empty list
 815     */
 816     long_array GetLastCreatedNodes();
 817
 818    /*!
 819     * If during last operation of MeshEditor some elements were
 820     * created this method returns list of it's IDs, if new elements
 821     * not creared - returns empty list
 822     */
 823     long_array GetLastCreatedElems();
 824
 825     /*!
 826      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
 827      * \param theNodes - identifiers of nodes to be doubled
 828      * \param theModifiedElems - identifiers of elements to be updated by the new (doubled)
 829      *        nodes. If list of element identifiers is empty then nodes are doubled but
 830      *        they not assigned to elements
 831      *        \return TRUE if operation has been completed successfully, FALSE otherwise
 832      * \sa DoubleNode(), DoubleNodeGroup(), DoubleNodeGroups()
 833      */
 834     boolean DoubleNodes( in long_array theNodes, in long_array theModifiedElems );
 835
 836     /*!
 837      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
 838      * This method provided for convenience works as DoubleNodes() described above.
 839      * \param theNodeId - identifier of node to be doubled.
 840      * \param theModifiedElems - identifiers of elements to be updated.
 841      * \return TRUE if operation has been completed successfully, FALSE otherwise
 842      * \sa DoubleNodes(), DoubleNodeGroup(), DoubleNodeGroups()
 843      */
 844     boolean DoubleNode( in long theNodeId, in long_array theModifiedElems );
 845
 846     /*!
 847      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
 848      * This method provided for convenience works as DoubleNodes() described above.
 849      * \param theNodes - group of nodes to be doubled.
 850      * \param theModifiedElems - group of elements to be updated.
 851      * \return TRUE if operation has been completed successfully, FALSE otherwise
 852      * \sa DoubleNode(), DoubleNodes(), DoubleNodeGroups(), DoubleNodeGroupNew()
 853      */
 854     boolean DoubleNodeGroup( in SMESH_GroupBase theNodes,
 855                              in SMESH_GroupBase theModifiedElems );
 856     /*!
 857      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
 858      * Works as DoubleNodeGroup() described above, but returns a new group with
 859      * newly created nodes.
 860      * \param theNodes - group of nodes to be doubled.
 861      * \param theModifiedElems - group of elements to be updated.
 862      * \return a new group with newly created nodes
 863      * \sa DoubleNodeGroup()
 864      */
 865     SMESH_Group DoubleNodeGroupNew( in SMESH_GroupBase theNodes,
 866                                     in SMESH_GroupBase theModifiedElems );
 867
 868     /*!
 869      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
 870      * This method provided for convenience works as DoubleNodes() described above.
 871      * \param theNodes - list of groups of nodes to be doubled
 872      * \param theModifiedElems - list of groups of elements to be updated.
 873      * \return TRUE if operation has been completed successfully, FALSE otherwise
 874      * \sa DoubleNode(), DoubleNodeGroup(), DoubleNodes()
 875      */
 876     boolean DoubleNodeGroups( in ListOfGroups theNodes,
 877                               in ListOfGroups theModifiedElems );
 878     /*!
 879      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
 880      * Works as DoubleNodeGroups() described above, but returns a new group with
 881      * newly created nodes.
 882      * \param theNodes - list of groups of nodes to be doubled
 883      * \param theModifiedElems - list of groups of elements to be updated.
 884      * \return a new group with newly created nodes
 885      * \sa DoubleNodeGroups()
 886      */
 887     SMESH_Group DoubleNodeGroupsNew( in ListOfGroups theNodes,
 888                                      in ListOfGroups theModifiedElems );
 889
 890     /*!
 891      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
 892      * \param theElems - the list of elements (edges or faces) to be replicated
 893      *        The nodes for duplication could be found from these elements
 894      * \param theNodesNot - list of nodes to NOT replicate
 895      * \param theAffectedElems - the list of elements (cells and edges) to which the
 896      *        replicated nodes should be associated to.
 897      * \return TRUE if operation has been completed successfully, FALSE otherwise
 898      * \sa DoubleNodeGroup(), DoubleNodeGroups()
 899      */
 900     boolean DoubleNodeElem( in long_array theElems,
 901                             in long_array theNodesNot,
 902                             in long_array theAffectedElems );
 903
 904     /*!
 905      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
 906      * \param theElems - the list of elements (edges or faces) to be replicated
 907      *        The nodes for duplication could be found from these elements
 908      * \param theNodesNot - list of nodes to NOT replicate
 909      * \param theShape - shape to detect affected elements (element which geometric center
 910      *        located on or inside shape).
 911      *        The replicated nodes should be associated to affected elements.
 912      * \return TRUE if operation has been completed successfully, FALSE otherwise
 913      * \sa DoubleNodeGroupInRegion(), DoubleNodeGroupsInRegion()
 914      */
 915     boolean DoubleNodeElemInRegion( in long_array theElems,
 916                                     in long_array theNodesNot,
 917                                     in GEOM::GEOM_Object theShape );
 918
 919     /*!
 920      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
 921      * This method provided for convenience works as DoubleNodes() described above.
 922      * \param theElems - group of of elements (edges or faces) to be replicated
 923      * \param theNodesNot - group of nodes not to replicated
 924      * \param theAffectedElems - group of elements to which the replicated nodes
 925      *        should be associated to.
 926      * \return TRUE if operation has been completed successfully, FALSE otherwise
 927      * \sa DoubleNodes(), DoubleNodeGroups(), DoubleNodeElemGroupNew()
 928      */
 929     boolean DoubleNodeElemGroup( in SMESH_GroupBase theElems,
 930                                  in SMESH_GroupBase theNodesNot,
 931                                  in SMESH_GroupBase theAffectedElems );
 932     /*!
 933      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
 934      * Works as DoubleNodeElemGroup() described above, but returns a new group with
 935      * newly created elements.
 936      * \param theElems - group of of elements (edges or faces) to be replicated
 937      * \param theNodesNot - group of nodes not to replicated
 938      * \param theAffectedElems - group of elements to which the replicated nodes
 939      *        should be associated to.
 940      * \return a new group with newly created elements
 941      * \sa DoubleNodeElemGroup()
 942      */
 943     SMESH_Group DoubleNodeElemGroupNew( in SMESH_GroupBase theElems,
 944                                         in SMESH_GroupBase theNodesNot,
 945                                         in SMESH_GroupBase theAffectedElems );
 946     /*!
 947      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
 948      * Works as DoubleNodeElemGroup() described above, but returns two new groups:
 949      * a group of newly created elements and a group of newly created nodes
 950      * \param theElems - group of of elements (edges or faces) to be replicated
 951      * \param theNodesNot - group of nodes not to replicated
 952      * \param theAffectedElems - group of elements to which the replicated nodes
 953      *        should be associated to.
 954      * \param theElemGroupNeeded - to create group of new elements or not
 955      * \param theNodeGroupNeeded - to create group of new nodes or not
 956      * \return two new groups of newly created elements (1st) and nodes (2nd)
 957      * \sa DoubleNodeElemGroup()
 958      */
 959     ListOfGroups DoubleNodeElemGroup2New( in SMESH_GroupBase theElems,
 960                                           in SMESH_GroupBase theNodesNot,
 961                                           in SMESH_GroupBase theAffectedElems,
 962                                           in boolean         theElemGroupNeeded,
 963                                           in boolean         theNodeGroupNeeded);
 964
 965     /*!
 966      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
 967      * This method provided for convenience works as DoubleNodes() described above.
 968      * \param theElems - group of elements (edges or faces) to be replicated
 969      * \param theNodesNot - group of nodes not to replicated
 970      * \param theShape - shape to detect affected elements (element which geometric center
 971      *        located on or inside shape).
 972      *        The replicated nodes should be associated to affected elements.
 973      * \return TRUE if operation has been completed successfully, FALSE otherwise
 974      * \sa DoubleNodesInRegion(), DoubleNodeGroupsInRegion()
 975      */
 976     boolean DoubleNodeElemGroupInRegion( in SMESH_GroupBase theElems,
 977                                          in SMESH_GroupBase theNodesNot,
 978                                          in GEOM::GEOM_Object theShape );
 979
 980     /*!
 981      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
 982      * This method provided for convenience works as DoubleNodes() described above.
 983      * \param theElems - list of groups of elements (edges or faces) to be replicated
 984      * \param theNodesNot - list of groups of nodes not to replicated
 985      * \param theAffectedElems - group of elements to which the replicated nodes
 986      *        should be associated to.
 987      * \return TRUE if operation has been completed successfully, FALSE otherwise
 988      * \sa DoubleNodeGroup(), DoubleNodes(), DoubleNodeElemGroupsNew()
 989      */
 990     boolean DoubleNodeElemGroups( in ListOfGroups theElems,
 991                                   in ListOfGroups theNodesNot,
 992                                   in ListOfGroups theAffectedElems );
 993     /*!
 994      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
 995      * Works as DoubleNodeElemGroups() described above, but returns a new group with
 996      * newly created elements.
 997      * \param theElems - list of groups of elements (edges or faces) to be replicated
 998      * \param theNodesNot - list of groups of nodes not to replicated
 999      * \param theAffectedElems - group of elements to which the replicated nodes
1000      *        should be associated to.
1001      * \return a new group with newly created elements
1002      * \sa DoubleNodeElemGroups()
1003      */
1004     SMESH_Group DoubleNodeElemGroupsNew( in ListOfGroups theElems,
1005                                          in ListOfGroups theNodesNot,
1006                                          in ListOfGroups theAffectedElems );
1007     /*!
1008      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
1009      * Works as DoubleNodeElemGroups() described above, but returns two new groups:
1010      * a group of newly created elements and a group of newly created nodes.
1011      * \param theElems - list of groups of elements (edges or faces) to be replicated
1012      * \param theNodesNot - list of groups of nodes not to replicated
1013      * \param theAffectedElems - group of elements to which the replicated nodes
1014      *        should be associated to.
1015      * \param theElemGroupNeeded - to create group of new elements or not
1016      * \param theNodeGroupNeeded - to create group of new nodes or not
1017      * \return two new groups of newly created elements (1st) and nodes (2nd)
1018      * \sa DoubleNodeElemGroups()
1019      */
1020     ListOfGroups DoubleNodeElemGroups2New( in ListOfGroups theElems,
1021                                            in ListOfGroups theNodesNot,
1022                                            in ListOfGroups theAffectedElems,
1023                                            in boolean         theElemGroupNeeded,
1024                                            in boolean         theNodeGroupNeeded );
1025
1026     /*!
1027      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
1028      * This method provided for convenience works as DoubleNodes() described above.
1029      * \param theElems - list of groups of elements (edges or faces) to be replicated
1030      * \param theNodesNot - list of groups of nodes not to replicated
1031      * \param theShape - shape to detect affected elements (element which geometric center
1032      *        located on or inside shape).
1033      *        The replicated nodes should be associated to affected elements.
1034      * \return TRUE if operation has been completed successfully, FALSE otherwise
1035      * \sa DoubleNodeGroupInRegion(), DoubleNodesInRegion()
1036      */
1037     boolean DoubleNodeElemGroupsInRegion( in ListOfGroups theElems,
1038                                           in ListOfGroups theNodesNot,
1039                                           in GEOM::GEOM_Object theShape );
1040
1041     /*!
1042      * \brief Generates skin mesh (containing 2D cells) from 3D mesh
1043      * The created 2D mesh elements based on nodes of free faces of boundary volumes
1044      * \return TRUE if operation has been completed successfully, FALSE otherwise
1045      */
1046     boolean Make2DMeshFrom3D();
1047
1048     /*!
1049      * \brief Creates missing boundary elements
1050      *  \param elements - elements whose boundary is to be checked
1051      *  \param dimension - defines type of boundary elements to create
1052      *    BND_1DFROM3D creates mesh edges on all borders of free facets of 3D elements.
1053      *  \param groupName - a name of group to store created boundary elements in,
1054      *                     "" means not to create the group
1055      *  \param meshName - a name of new mesh to store created boundary elements in,
1056      *                     "" means not to create the new mesh
1057      *  \param toCopyElements - if true, the checked elements will be copied into the new mesh
1058      *                          else only boundary elements will be copied into the new mesh
1059      *  \param toCopyExistingBondary - if true, not only new but also pre-existing
1060      *                                boundary elements will be copied into the new mesh
1061      *  \param group - returns the create group, if any
1062      *  \retval SMESH::SMESH_Mesh - the mesh where elements were added to
1063      */
1064     SMESH_Mesh MakeBoundaryMesh(in SMESH_IDSource elements,
1065                                 in Bnd_Dimension  dimension,
1066                                 in string         groupName,
1067                                 in string         meshName,
1068                                 in boolean        toCopyElements,
1069                                 in boolean        toCopyExistingBondary,
1070                                 out SMESH_Group   group);
1071     /*!
1072      * \brief Creates missing boundary elements around either the whole mesh or
1073      *    groups of 2D elements
1074      *  \param dimension - defines type of boundary elements to create
1075      *  \param groupName - a name of group to store all boundary elements in,
1076      *    "" means not to create the group
1077      *  \param meshName - a name of a new mesh, which is a copy of the initial
1078      *    mesh + created boundary elements; "" means not to create the new mesh
1079      *  \param toCopyAll - if true, the whole initial mesh will be copied into
1080      *    the new mesh else only boundary elements will be copied into the new mesh
1081      *  \param groups - optional groups of 2D elements to make boundary around
1082      *  \param mesh - returns the mesh where elements were added to
1083      *  \param group - returns the created group, if any
1084      *  \retval long - number of added boundary elements
1085      */
1086     long MakeBoundaryElements(in Bnd_Dimension   dimension,
1087                               in string          groupName,
1088                               in string          meshName,
1089                               in boolean         toCopyAll,
1090                               in ListOfIDSources groups,
1091                               out SMESH_Mesh     mesh,
1092                               out SMESH_Group    group) raises (SALOME::SALOME_Exception);
1093
1094     /*!
1095      * \brief Double nodes on shared faces between groups of volumes and create flat elements on demand.
1096      * Flat elements are mainly used by some types of mechanic calculations.
1097      *
1098      * The list of groups must describe a partition of the mesh volumes.
1099      * The nodes of the internal faces at the boundaries of the groups are doubled.
1100      * In option, the internal faces are replaced by flat elements.
1101      * Triangles are transformed in prisms, and quadrangles in hexahedrons.
1102      * \param theDomains - list of groups of volumes
1103      * \param createJointElems - if TRUE, create the elements
1104      * \return TRUE if operation has been completed successfully, FALSE otherwise
1105      */
1106     boolean DoubleNodesOnGroupBoundaries( in ListOfGroups theDomains,
1107                                           in boolean createJointElems )
1108       raises (SALOME::SALOME_Exception);
1109
1110     /*!
1111      * \brief Double nodes on some external faces and create flat elements.
1112      * Flat elements are mainly used by some types of mechanic calculations.
1113      *
1114      * Each group of the list must be constituted of faces.
1115      * Triangles are transformed in prisms, and quadrangles in hexahedrons.
1116      * \param theGroupsOfFaces - list of groups of faces
1117      * \return TRUE if operation has been completed successfully, FALSE otherwise
1118      */
1119     boolean CreateFlatElementsOnFacesGroups( in ListOfGroups theGroupsOfFaces );
1120   };
1121 };
1122
1123 #endif