idl/SMESH_MeshEditor.idl

   1 // Copyright (C) 2007-2021  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, or (at your option) any later version.
  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 #include "SMESH_Gen.idl"
  29 #include "SMESH_smIdType.idl"
  30
  31 module SMESH
  32 {
  33   interface NumericalFunctor;
  34
  35   enum Bnd_Dimension { BND_2DFROM3D, BND_1DFROM3D, BND_1DFROM2D };
  36
  37
  38   struct FreeBorder
  39   {
  40     SMESH::smIdType_array nodeIDs; // all nodes defining a free border
  41     // 1st and last node is same in a closed border
  42   };
  43   struct FreeBorderPart
  44   {
  45     short border; // border index within a sequence<FreeBorder>
  46     long  node1;  // node index within the border-th FreeBorder
  47     long  node2;
  48     long  nodeLast;
  49   };
  50   typedef sequence<FreeBorder>       ListOfFreeBorders;
  51   typedef sequence<FreeBorderPart>   FreeBordersGroup;
  52   typedef sequence<FreeBordersGroup> ListOfFreeBorderGroups;
  53
  54   struct CoincidentFreeBorders
  55   {
  56     ListOfFreeBorders      borders;          // nodes of all free borders
  57     ListOfFreeBorderGroups coincidentGroups; // groups of coincident parts of borders
  58   };
  59
  60
  61   // structure used in MakePolyLine() to define a cutting plane
  62   struct PolySegment
  63   {
  64     // a point is defined as follows:
  65     // ( node*ID1 > 0 && node*ID2 > 0 ) ==> point is in the middle of an edge defined by two nodes
  66     // ( node*ID1 > 0 && node*ID2 <=0 ) ==> point is at node*ID1
  67     // else                             ==> point is at xyz*
  68
  69     // point 1
  70     smIdType node1ID1;
  71     smIdType node1ID2;
  72     PointStruct xyz1;
  73
  74     // point 2
  75     smIdType node2ID1;
  76     smIdType node2ID2;
  77     PointStruct xyz2;
  78
  79     // vector on the plane; to use a default plane set vector = (0,0,0)
  80     DirStruct vector;
  81   };
  82   typedef sequence<PolySegment> ListOfPolySegments;
  83
  84   // face edge defined by two nodes + optional medium node
  85   struct FaceEdge
  86   {
  87     smIdType node1;
  88     smIdType node2;
  89     smIdType medium;
  90   };
  91   typedef sequence<FaceEdge> ListOfEdges;
  92
  93
  94   /*!
  95    * This interface makes modifications on the Mesh - removing elements and nodes etc.
  96    * Also provides some analysis functions.
  97    */
  98   interface SMESH_MeshEditor
  99   {
 100    /*!
 101     * Returns a mesh subject to edition
 102     */
 103     SMESH_Mesh GetMesh();
 104
 105    /*!
 106     * Return data of mesh edition preview which is computed provided
 107     * that the editor was obtained through SMESH_Mesh::GetMeshEditPreviewer()
 108     */
 109     MeshPreviewStruct GetPreviewData() raises (SALOME::SALOME_Exception);
 110
 111    /*!
 112     * If during last operation of MeshEditor some nodes were
 113     * created, this method returns list of their IDs, if new nodes
 114     * not created - returns empty list
 115     */
 116     smIdType_array GetLastCreatedNodes() raises (SALOME::SALOME_Exception);
 117
 118    /*!
 119     * If during last operation of MeshEditor some elements were
 120     * created, this method returns list of their IDs, if new elements
 121     * not created - returns empty list
 122     */
 123     smIdType_array GetLastCreatedElems() raises (SALOME::SALOME_Exception);
 124
 125     /*!
 126      * \brief Clears sequences of last created elements and nodes
 127      */
 128     void ClearLastCreated() raises (SALOME::SALOME_Exception);
 129
 130     /*!
 131      * \brief Returns description of an error/warning occurred during the last operation
 132      */
 133     ComputeError GetLastError() raises (SALOME::SALOME_Exception);
 134
 135     /*!
 136      * \brief Wrap a sequence of ids in a SMESH_IDSource
 137      * \param IDsOfElements list of mesh elements identifiers
 138      * \return new ID source object
 139      */
 140     SMESH_IDSource MakeIDSource(in smIdType_array IDsOfElements, in ElementType type);
 141
 142     /*!
 143      * \brief Remove mesh elements specified by their identifiers.
 144      * \param IDsOfElements list of mesh elements identifiers
 145      * \return \c true if elements are correctly removed or \c false otherwise
 146      */
 147     boolean RemoveElements(in smIdType_array IDsOfElements) raises (SALOME::SALOME_Exception);
 148
 149     /*!
 150      * \brief Remove mesh nodes specified by their identifiers.
 151      * \param IDsOfNodes list of mesh nodes identifiers
 152      * \return \c true if nodes are correctly removed or \c false otherwise
 153      */
 154     boolean RemoveNodes(in smIdType_array IDsOfNodes) raises (SALOME::SALOME_Exception);
 155
 156     /*!
 157      * \brief Remove all orphan nodes.
 158      * \return number of removed nodes
 159      */
 160     smIdType RemoveOrphanNodes() raises (SALOME::SALOME_Exception);
 161
 162     /*!
 163      * \brief Add a new node.
 164      * \param x X coordinate of new node
 165      * \param y Y coordinate of new node
 166      * \param z Z coordinate of new node
 167      * \return integer identifier of new node
 168      */
 169     smIdType AddNode(in double x, in double y, in double z) raises (SALOME::SALOME_Exception);
 170
 171     /*!
 172      *  Create a 0D element on the given node.
 173      *  \param IdOfNode Node IDs for creation of element.
 174      *  \param DuplicateElements to add one more 0D element to a node or not
 175      */
 176     smIdType Add0DElement(in smIdType    IDOfNode,
 177                           in boolean DuplicateElements) raises (SALOME::SALOME_Exception);
 178
 179     /*!
 180      *  Create a ball element on the given node.
 181      *  \param IdOfNode Node IDs for creation of element.
 182      */
 183     smIdType AddBall(in smIdType IDOfNode, in double diameter) raises (SALOME::SALOME_Exception);
 184
 185     /*!
 186      *  Create an edge, either linear and quadratic (this is determed
 187      *  by number of given nodes, two or three).
 188      *  \param IdsOfNodes List of node IDs for creation of element.
 189      *  Needed order of nodes in this list corresponds to description
 190      *  of MED. This description is located by the following link:
 191      *   http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
 192      */
 193     smIdType AddEdge(in smIdType_array IDsOfNodes) raises (SALOME::SALOME_Exception);
 194
 195     /*!
 196      *  Create face, either linear and quadratic (this is determed
 197      *  by number of given nodes).
 198      *  \param IdsOfNodes List of node IDs for creation of element.
 199      *  Needed order of nodes in this list corresponds to description
 200      *  of MED. This description is located by the following link:
 201      *   http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
 202      */
 203     smIdType AddFace(in smIdType_array IDsOfNodes) raises (SALOME::SALOME_Exception);
 204
 205     smIdType AddPolygonalFace(in smIdType_array IdsOfNodes) raises (SALOME::SALOME_Exception);
 206
 207     /*!
 208      * Create a quadratic polygonal face
 209      *  \param IdsOfNodes - nodes of the polygon; corner nodes follow first
 210      *  \return smIdType- ID of a new polygon
 211      */
 212     smIdType AddQuadPolygonalFace(in smIdType_array IdsOfNodes) raises (SALOME::SALOME_Exception);
 213
 214     /*!
 215      *  Create volume, either linear and quadratic (this is determed
 216      *  by number of given nodes).
 217      *  \param IdsOfNodes List of node IDs for creation of element.
 218      *  Needed order of nodes in this list corresponds to description
 219      *  of MED. This description is located by the following link:
 220      *   http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
 221      */
 222     smIdType AddVolume(in smIdType_array IDsOfNodes) raises (SALOME::SALOME_Exception);
 223
 224     /*!
 225      *  Create volume of many faces, giving nodes for each face.
 226      *  \param IdsOfNodes List of node IDs for volume creation face by face.
 227      *  \param Quantities List of integer values, Quantities[i]
 228      *         gives quantity of nodes in face number i.
 229      */
 230     smIdType AddPolyhedralVolume (in smIdType_array IdsOfNodes,
 231                                   in long_array Quantities) raises (SALOME::SALOME_Exception);
 232     /*!
 233      *  Create volume of many faces, giving IDs of existing faces.
 234      *  \param IdsOfFaces List of face IDs for volume creation.
 235      *  \note The created volume will refer only to nodes
 236      *        of the given faces, not to the faces itself.
 237      */
 238     smIdType AddPolyhedralVolumeByFaces (in smIdType_array IdsOfFaces) raises (SALOME::SALOME_Exception);
 239
 240     /*!
 241      * Create 0D elements on all nodes of the given object.
 242      *  \param theObject object on whose nodes 0D elements will be created.
 243      *  \param theGroupName optional name of a group to add 0D elements created
 244      *         and/or found on nodes of \a theObject.
 245      *  \param theDuplicateElements to add one more 0D element to a node or not
 246      *  \return an object (a new group or a temporary SMESH_IDSource) holding
 247      *          ids of new and/or found 0D elements.
 248      */
 249     SMESH_IDSource Create0DElementsOnAllNodes(in SMESH_IDSource theObject,
 250                                               in string         theGroupName,
 251                                               in boolean        theDuplicateElements)
 252       raises (SALOME::SALOME_Exception);
 253
 254     /*!
 255      * \brief Bind a node to a vertex
 256       * \param NodeID - node ID
 257       * \param VertexID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
 258      */
 259     void SetNodeOnVertex(in smIdType NodeID, in long VertexID)
 260       raises (SALOME::SALOME_Exception);
 261     /*!
 262      * \brief Store node position on an edge
 263       * \param NodeID - node ID
 264       * \param EdgeID - edge ID available through GEOM_Object.GetSubShapeIndices()[0]
 265       * \param paramOnEdge - parameter on edge where the node is located
 266      */
 267     void SetNodeOnEdge(in smIdType NodeID, in long EdgeID, in double paramOnEdge)
 268       raises (SALOME::SALOME_Exception);
 269     /*!
 270      * \brief Store node position on a face
 271       * \param NodeID - node ID
 272       * \param FaceID - face ID available through GEOM_Object.GetSubShapeIndices()[0]
 273       * \param u - U parameter on face where the node is located
 274       * \param v - V parameter on face where the node is located
 275      */
 276     void SetNodeOnFace(in smIdType NodeID, in long FaceID, in double u, in double v)
 277       raises (SALOME::SALOME_Exception);
 278     /*!
 279      * \brief Bind a node to a solid
 280       * \param NodeID - node ID
 281       * \param SolidID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
 282      */
 283     void SetNodeInVolume(in smIdType NodeID, in long SolidID)
 284       raises (SALOME::SALOME_Exception);
 285     /*!
 286      * \brief Bind an element to a shape
 287       * \param ElementID - element ID
 288       * \param ShapeID - shape ID available through GEOM_Object.GetSubShapeIndices()[0]
 289      */
 290     void SetMeshElementOnShape(in smIdType ElementID, in long ShapeID)
 291       raises (SALOME::SALOME_Exception);
 292
 293
 294     boolean MoveNode(in smIdType NodeID, in double x, in double y, in double z)
 295       raises (SALOME::SALOME_Exception);
 296
 297     boolean InverseDiag(in smIdType NodeID1, in smIdType NodeID2)
 298       raises (SALOME::SALOME_Exception);
 299
 300     boolean DeleteDiag(in smIdType NodeID1, in smIdType NodeID2)
 301       raises (SALOME::SALOME_Exception);
 302
 303     boolean Reorient(in smIdType_array IDsOfElements)
 304       raises (SALOME::SALOME_Exception);
 305
 306     boolean ReorientObject(in SMESH_IDSource theObject)
 307       raises (SALOME::SALOME_Exception);
 308     /*!
 309      * \brief Reorient faces contained in \a the2Dgroup.
 310      * \param the2Dgroup - the mesh or its part to reorient
 311      * \param theDirection - desired direction of normal of \a theFace
 312      * \param theFace - ID of face whose orientation is checked.
 313      *        It can be < 1 then \a thePoint is used to find a face.
 314      * \param thePoint - is used to find a face if \a theFace < 1.
 315      * \return number of reoriented faces.
 316      */
 317     long Reorient2D(in SMESH_IDSource the2Dgroup,
 318                     in DirStruct      theDirection,
 319                     in long           theFace,
 320                     in PointStruct    thePoint) raises (SALOME::SALOME_Exception);
 321     /*!
 322      * \brief Reorient faces contained in a list of \a objectFaces
 323      *        equally to faces contained in a list of \a referenceFaces.
 324      * \param objectFaces - faces to reorient in a list including either
 325      *        the whole mesh or groups and/or sub-meshes.
 326      * \param referenceFaces  - correctly oriented faces in a list of groups and/or sub-meshes.
 327      *        It can be empty, then the 1st face in \a objectFaces is used as the reference.
 328      * \return number of reoriented faces.
 329      */
 330     long Reorient2DByNeighbours(in SMESH::ListOfIDSources objectFaces,
 331                                 in SMESH::ListOfIDSources referenceFaces)
 332       raises (SALOME::SALOME_Exception);
 333
 334     /*!
 335      * \brief Reorient faces basing on orientation of adjacent volumes.
 336      * \param faces - a list of objects containing face to reorient
 337      * \param volumes - an object containing volumes.
 338      * \param outsideNormal - to orient faces to have their normal
 339      *        pointing either \a outside or \a inside the adjacent volumes.
 340      * \return number of reoriented faces.
 341      */
 342     long Reorient2DBy3D(in ListOfIDSources faces,
 343                         in SMESH_IDSource  volumes,
 344                         in boolean         outsideNormal) raises (SALOME::SALOME_Exception);
 345
 346     /*!
 347      * \brief Fuse neighbour triangles into quadrangles.
 348      * \param IDsOfElements Ids of triangles to be fused.
 349      * \param theCriterion Is used to choose a neighbour to fuse with.
 350      * \param theMaxAngle  Is a max angle between element normals at which fusion
 351      *                     is still performed; theMaxAngle is measured in radians.
 352      * \return \c true in case of success, FALSE otherwise.
 353      */
 354
 355     boolean TriToQuad (in smIdType_array   IDsOfElements,
 356                        in NumericalFunctor Criterion,
 357                        in double           MaxAngle) raises (SALOME::SALOME_Exception);
 358     /*!
 359      * \brief Fuse neighbour triangles into quadrangles.
 360      *
 361      * Behaves like the above method, taking a list of elements from \a theObject
 362      */
 363     boolean TriToQuadObject (in SMESH_IDSource   theObject,
 364                              in NumericalFunctor Criterion,
 365                              in double           MaxAngle) raises (SALOME::SALOME_Exception);
 366
 367     /*!
 368      * \brief Split quadrangles into triangles.
 369      * \param IDsOfElements Ids of quadrangles to split.
 370      * \param theCriterion Is used to choose a diagonal for splitting.
 371      * \return TRUE in case of success, FALSE otherwise.
 372      */
 373     boolean QuadToTri (in smIdType_array   IDsOfElements,
 374                        in NumericalFunctor Criterion) raises (SALOME::SALOME_Exception);
 375     /*!
 376      * \brief Split quadrangles into triangles.
 377      *
 378      * Behaves like the above method, taking a list of elements from \a theObject
 379      */
 380     boolean QuadToTriObject (in SMESH_IDSource   theObject,
 381                              in NumericalFunctor Criterion) raises (SALOME::SALOME_Exception);
 382     /*!
 383      * \brief Split each of quadrangles into 4 triangles.
 384      * \param theQuads Container of quadrangles to split.
 385      */
 386     void QuadTo4Tri (in SMESH_IDSource theQuads) raises (SALOME::SALOME_Exception);
 387
 388     /*!
 389      * \brief Split quadrangles into triangles.
 390      * \param theElems  The faces to be split.
 391      * \param the13Diag Is used to choose a diagonal for splitting.
 392      * \return TRUE in case of success, FALSE otherwise.
 393      */
 394     boolean SplitQuad (in smIdType_array IDsOfElements,
 395                        in boolean        Diag13) raises (SALOME::SALOME_Exception);
 396     /*!
 397      * \brief Split quadrangles into triangles.
 398      *
 399      * Behaves like the above method, taking list of elements from \a theObject
 400      */
 401     boolean SplitQuadObject (in SMESH_IDSource theObject,
 402                              in boolean        Diag13) raises (SALOME::SALOME_Exception);
 403
 404     /*!
 405      *  Find better splitting of the given quadrangle.
 406      *  \param IDOfQuad  ID of the quadrangle to be split.
 407      *  \param Criterion A criterion to choose a diagonal for splitting.
 408      *  \return 1 if 1-3 diagonal is better, 2 if 2-4
 409      *          diagonal is better, 0 if error occurs.
 410      */
 411     long BestSplit (in long            IDOfQuad,
 412                     in NumericalFunctor Criterion) raises (SALOME::SALOME_Exception);
 413
 414     /*!
 415      * \brief Split volumic elements into tetrahedrons
 416      *  \param elems - elements to split
 417      *  \param methodFlags - flags passing splitting method:
 418      *         1 - split the hexahedron into 5 tetrahedrons
 419      *         2 - split the hexahedron into 6 tetrahedrons
 420      *         3 - split the hexahedron into 24 tetrahedrons
 421      */
 422     void SplitVolumesIntoTetra(in SMESH_IDSource elems, in short methodFlags)
 423       raises (SALOME::SALOME_Exception);
 424
 425     /*!
 426      * \brief Split hexahedra into triangular prisms
 427      *  \param elems - elements to split
 428      *  \param startHexPoint - a point used to find a hexahedron for which \a facetToSplitNormal
 429      *         gives a normal vector defining facets to split into triangles.
 430      *  \param facetToSplitNormal - normal used to find a facet of hexahedron
 431      *         to split into triangles.
 432      *  \param methodFlags - flags passing splitting method:
 433      *         1 - split the hexahedron into 2 prisms
 434      *         2 - split the hexahedron into 4 prisms
 435      *  \param allDomains - if \c False, only hexahedra adjacent to one closest
 436      *         to \a facetToSplitNormal location are split, else \a facetToSplitNormal
 437      *         is used to find the facet to split in all domains present in \a elems.
 438      */
 439     void SplitHexahedraIntoPrisms(in SMESH_IDSource     elems,
 440                                   in SMESH::PointStruct startHexPoint,
 441                                   in SMESH::DirStruct   facetToSplitNormal,
 442                                   in short              methodFlags,
 443                                   in boolean            allDomains)
 444       raises (SALOME::SALOME_Exception);
 445
 446     /*!
 447      * \brief Split bi-quadratic elements into linear ones without creation of additional nodes.
 448      *   - bi-quadratic triangle will be split into 3 linear quadrangles;
 449      *   - bi-quadratic quadrangle will be split into 4 linear quadrangles;
 450      *   - tri-quadratic hexahedron will be split into 8 linear hexahedra;
 451      *   Quadratic elements of lower dimension  adjacent to the split bi-quadratic element
 452      *   will be split in order to keep the mesh conformal.
 453      *  \param elems - elements to split
 454      */
 455     void SplitBiQuadraticIntoLinear(in ListOfIDSources elems)
 456       raises (SALOME::SALOME_Exception);
 457
 458
 459     enum Smooth_Method { LAPLACIAN_SMOOTH, CENTROIDAL_SMOOTH };
 460
 461     boolean Smooth(in smIdType_array IDsOfElements,
 462                    in smIdType_array IDsOfFixedNodes,
 463                    in short          MaxNbOfIterations,
 464                    in double         MaxAspectRatio,
 465                    in Smooth_Method  Method) raises (SALOME::SALOME_Exception);
 466
 467     boolean SmoothObject(in SMESH_IDSource theObject,
 468                          in smIdType_array IDsOfFixedNodes,
 469                          in short          MaxNbOfIterations,
 470                          in double         MaxAspectRatio,
 471                          in Smooth_Method  Method) raises (SALOME::SALOME_Exception);
 472
 473     boolean SmoothParametric(in smIdType_array IDsOfElements,
 474                              in smIdType_array IDsOfFixedNodes,
 475                              in short          MaxNbOfIterations,
 476                              in double         MaxAspectRatio,
 477                              in Smooth_Method  Method) raises (SALOME::SALOME_Exception);
 478
 479     boolean SmoothParametricObject(in SMESH_IDSource theObject,
 480                                    in smIdType_array IDsOfFixedNodes,
 481                                    in short          MaxNbOfIterations,
 482                                    in double         MaxAspectRatio,
 483                                    in Smooth_Method  Method) raises (SALOME::SALOME_Exception);
 484
 485     void ConvertToQuadratic(in boolean theForce3d)
 486       raises (SALOME::SALOME_Exception);
 487     void ConvertToQuadraticObject(in boolean        theForce3d,
 488                                   in SMESH_IDSource theObject)
 489       raises (SALOME::SALOME_Exception);
 490
 491     boolean ConvertFromQuadratic()
 492       raises (SALOME::SALOME_Exception);
 493     void    ConvertFromQuadraticObject(in SMESH_IDSource theObject)
 494       raises (SALOME::SALOME_Exception);
 495
 496     void ConvertToBiQuadratic(in boolean        theForce3d,
 497                               in SMESH_IDSource theObject)
 498       raises (SALOME::SALOME_Exception);
 499
 500     void RenumberNodes() raises (SALOME::SALOME_Exception);
 501
 502     void RenumberElements() raises (SALOME::SALOME_Exception);
 503
 504     /*!
 505      * \brief Generate dim+1 elements by rotation of the object around axis
 506      *  \param Nodes - nodes to revolve: a list including groups, sub-meshes or a mesh
 507      *  \param Edges - edges to revolve: a list including groups, sub-meshes or a mesh
 508      *  \param Faces - faces to revolve: a list including groups, sub-meshes or a mesh
 509      *  \param Axis - rotation axis
 510      *  \param AngleInRadians - rotation angle
 511      *  \param NbOfSteps - number of elements to generate from one element
 512      *  \param ToMakeGroups - if true, new elements will be included into new groups
 513      *         corresponding to groups the input elements included in.
 514      *  \return ListOfGroups - new groups created if \a ToMakeGroups is true
 515      */
 516     ListOfGroups RotationSweepObjects(in ListOfIDSources Nodes,
 517                                       in ListOfIDSources Edges,
 518                                       in ListOfIDSources Faces,
 519                                       in AxisStruct      Axis,
 520                                       in double          AngleInRadians,
 521                                       in long            NbOfSteps,
 522                                       in double          Tolerance,
 523                                       in boolean         ToMakeGroups)
 524       raises (SALOME::SALOME_Exception);
 525
 526     /*!
 527      * \brief Generate dim+1 elements by extrusion of elements along vector
 528      *  \param nodes - nodes to extrude: a list including groups, sub-meshes or a mesh.
 529      *  \param edges - edges to extrude: a list including groups, sub-meshes or a mesh.
 530      *  \param faces - faces to extrude: a list including groups, sub-meshes or a mesh.
 531      *  \param stepVector - vector giving direction and distance of an extrusion step.
 532      *  \param nbOfSteps - number of elements to generate from one element.
 533      *  \param toMakeGroups - if true, new elements will be included into new groups
 534      *         corresponding to groups the input elements included in.
 535      *  \param scaleFactors - optional scale factors to apply during extrusion; it's
 536      *         usage depends on \a scalesVariation parameter.
 537      *  \param scalesVariation - if \c True, \a scaleFactors are spread over all \a NbOfSteps,
 538                 otherwise \a scaleFactors[i] is applied to nodes at the i-th extrusion step.
 539      *  \param angles - optional rotation angles to apply during extrusion; it's
 540      *         usage depends on \a anglesVariation parameter.
 541      *  \param anglesVariation - if \c True, \a angles are spread over all \a NbOfSteps,
 542                 otherwise \a angle[i] is applied to nodes at the i-th extrusion step.
 543      *  \return ListOfGroups - new groups created if \a toMakeGroups is true
 544      */
 545     ListOfGroups ExtrusionSweepObjects(in ListOfIDSources nodes,
 546                                        in ListOfIDSources edges,
 547                                        in ListOfIDSources faces,
 548                                        in DirStruct       stepVector,
 549                                        in long            nbOfSteps,
 550                                        in boolean         toMakeGroups,
 551                                        in double_array    scaleFactors,
 552                                        in boolean         scaleVariation,
 553                                        in double_array    basePoint,
 554                                        in double_array    angles,
 555                                        in boolean         angleVariation)
 556       raises (SALOME::SALOME_Exception);
 557
 558     /*! Generates new elements by extrusion along the normal to a discretized surface or wire
 559      */
 560     ListOfGroups ExtrusionByNormal(in ListOfIDSources theObjects,
 561                                    in double          stepSize,
 562                                    in long            nbOfSteps,
 563                                    in boolean         byAverageNormal,
 564                                    in boolean         useInputElemsOnly,
 565                                    in boolean         makeGroups,
 566                                    in short           dim)
 567       raises (SALOME::SALOME_Exception);
 568
 569     /*!
 570      * Generate new elements by extrusion of theElements
 571      * by StepVector by NbOfSteps
 572      *  \param ExtrFlags set flags for performing extrusion
 573      *  \param SewTolerance - uses for comparing locations of nodes if flag
 574      *         EXTRUSION_FLAG_SEW is set
 575      *  \param ToMakeGroups - if true, new elements will be included into new groups
 576      *         corresponding to groups the input elements included in.
 577      *  \return ListOfGroups - new groups created if \a ToMakeGroups is true
 578      */
 579     ListOfGroups AdvancedExtrusion(in smIdType_array IDsOfElements,
 580                                    in DirStruct      StepVector,
 581                                    in long           NbOfSteps,
 582                                    in long           ExtrFlags,
 583                                    in double         SewTolerance,
 584                                    in boolean        ToMakeGroups)
 585       raises (SALOME::SALOME_Exception);
 586
 587     enum Extrusion_Error {
 588       EXTR_OK,
 589       EXTR_NO_ELEMENTS,
 590       EXTR_PATH_NOT_EDGE,
 591       EXTR_BAD_PATH_SHAPE,
 592       EXTR_BAD_STARTING_NODE,
 593       EXTR_BAD_ANGLES_NUMBER,
 594       EXTR_CANT_GET_TANGENT
 595     };
 596
 597     ListOfGroups ExtrusionAlongPathObjects(in ListOfIDSources   Nodes,
 598                                            in ListOfIDSources   Edges,
 599                                            in ListOfIDSources   Faces,
 600                                            in SMESH_IDSource    Path,
 601                                            in GEOM::GEOM_Object PathShape,
 602                                            in smIdType          NodeStart,
 603                                            in boolean           HasAngles,
 604                                            in double_array      Angles,
 605                                            in boolean           AnglesVariation,
 606                                            in boolean           HasRefPoint,
 607                                            in PointStruct       RefPoint,
 608                                            in boolean           MakeGroups,
 609                                            in double_array      ScaleFactors,
 610                                            in boolean           ScaleVariation,
 611                                            out Extrusion_Error  Error)
 612       raises (SALOME::SALOME_Exception);
 613
 614    /*!
 615     * Compute rotation angles for ExtrusionAlongPath as linear variation
 616     * of given angles along path steps
 617     * param PathMesh mesh containing a 1D sub-mesh on the edge, along
 618     *                which proceeds the extrusion
 619     * param PathShape is shape(edge); as the mesh can be complex, the edge
 620     *                 is used to define the sub-mesh for the path
 621     */
 622     double_array LinearAnglesVariation(in SMESH_Mesh        PathMesh,
 623                                        in GEOM::GEOM_Object PathShape,
 624                                        in double_array      Angles);
 625
 626     enum MirrorType { POINT, AXIS, PLANE };
 627
 628     void Mirror (in smIdType_array IDsOfElements,
 629                  in AxisStruct     Mirror,
 630                  in MirrorType     Type,
 631                  in boolean        Copy)
 632       raises (SALOME::SALOME_Exception);
 633     ListOfGroups MirrorMakeGroups (in smIdType_array IDsOfElements,
 634                                    in AxisStruct     Mirror,
 635                                    in MirrorType     Type)
 636       raises (SALOME::SALOME_Exception);
 637     SMESH_Mesh MirrorMakeMesh (in smIdType_array IDsOfElements,
 638                                in AxisStruct     Mirror,
 639                                in MirrorType     Type,
 640                                in boolean        CopyGroups,
 641                                in string         MeshName)
 642       raises (SALOME::SALOME_Exception);
 643
 644     void MirrorObject (in SMESH_IDSource theObject,
 645                        in AxisStruct     Mirror,
 646                        in MirrorType     Type,
 647                        in boolean        Copy)
 648       raises (SALOME::SALOME_Exception);
 649     ListOfGroups MirrorObjectMakeGroups (in SMESH_IDSource theObject,
 650                                          in AxisStruct     Mirror,
 651                                          in MirrorType     Type)
 652       raises (SALOME::SALOME_Exception);
 653     SMESH_Mesh MirrorObjectMakeMesh (in SMESH_IDSource theObject,
 654                                      in AxisStruct     Mirror,
 655                                      in MirrorType     Type,
 656                                      in boolean        CopyGroups,
 657                                      in string         MeshName)
 658       raises (SALOME::SALOME_Exception);
 659
 660     void Translate (in smIdType_array IDsOfElements,
 661                     in DirStruct      Vector,
 662                     in boolean        Copy)
 663       raises (SALOME::SALOME_Exception);
 664     ListOfGroups TranslateMakeGroups (in smIdType_array IDsOfElements,
 665                                       in DirStruct       Vector)
 666       raises (SALOME::SALOME_Exception);
 667     SMESH_Mesh TranslateMakeMesh (in smIdType_array IDsOfElements,
 668                                   in DirStruct      Vector,
 669                                   in boolean        CopyGroups,
 670                                   in string         MeshName)
 671       raises (SALOME::SALOME_Exception);
 672
 673     void TranslateObject (in SMESH_IDSource theObject,
 674                           in DirStruct      Vector,
 675                           in boolean        Copy)
 676       raises (SALOME::SALOME_Exception);
 677     ListOfGroups TranslateObjectMakeGroups (in SMESH_IDSource theObject,
 678                                             in DirStruct      Vector)
 679       raises (SALOME::SALOME_Exception);
 680     SMESH_Mesh TranslateObjectMakeMesh (in SMESH_IDSource theObject,
 681                                         in DirStruct      Vector,
 682                                         in boolean        CopyGroups,
 683                                         in string         MeshName)
 684       raises (SALOME::SALOME_Exception);
 685
 686     void Scale (in SMESH_IDSource theObject,
 687                 in PointStruct    thePoint,
 688                 in double_array   theScaleFact,
 689                 in boolean        Copy)
 690       raises (SALOME::SALOME_Exception);
 691     ListOfGroups ScaleMakeGroups (in SMESH_IDSource theObject,
 692                                   in PointStruct    thePoint,
 693                                   in double_array   theScaleFact)
 694       raises (SALOME::SALOME_Exception);
 695     SMESH_Mesh ScaleMakeMesh (in SMESH_IDSource theObject,
 696                               in PointStruct    thePoint,
 697                               in double_array   theScaleFact,
 698                               in boolean        CopyGroups,
 699                               in string         MeshName)
 700       raises (SALOME::SALOME_Exception);
 701
 702     void Rotate (in smIdType_array IDsOfElements,
 703                  in AxisStruct     Axis,
 704                  in double         AngleInRadians,
 705                  in boolean        Copy)
 706       raises (SALOME::SALOME_Exception);
 707     ListOfGroups RotateMakeGroups (in smIdType_array IDsOfElements,
 708                                    in AxisStruct     Axis,
 709                                    in double         AngleInRadians)
 710       raises (SALOME::SALOME_Exception);
 711     SMESH_Mesh RotateMakeMesh (in smIdType_array IDsOfElements,
 712                                in AxisStruct     Axis,
 713                                in double         AngleInRadians,
 714                                in boolean        CopyGroups,
 715                                in string         MeshName)
 716       raises (SALOME::SALOME_Exception);
 717
 718     void RotateObject (in SMESH_IDSource theObject,
 719                        in AxisStruct     Axis,
 720                        in double         AngleInRadians,
 721                        in boolean        Copy)
 722       raises (SALOME::SALOME_Exception);
 723     ListOfGroups RotateObjectMakeGroups (in SMESH_IDSource theObject,
 724                                          in AxisStruct     Axis,
 725                                          in double         AngleInRadians)
 726       raises (SALOME::SALOME_Exception);
 727     SMESH_Mesh RotateObjectMakeMesh (in SMESH_IDSource theObject,
 728                                      in AxisStruct     Axis,
 729                                      in double         AngleInRadians,
 730                                      in boolean        CopyGroups,
 731                                      in string         MeshName)
 732       raises (SALOME::SALOME_Exception);
 733
 734     SMESH_Mesh Offset(in SMESH_IDSource theObject,
 735                       in double         Value,
 736                       in boolean        CopyGroups,
 737                       in boolean        CopyElements,
 738                       in string         MeshName,
 739                       out ListOfGroups  Groups)
 740       raises (SALOME::SALOME_Exception);
 741
 742     void FindCoincidentNodes (in  double              Tolerance,
 743                               out array_of_long_array GroupsOfNodes,
 744                               in  boolean             SeparateCornersAndMedium)
 745       raises (SALOME::SALOME_Exception);
 746
 747     void FindCoincidentNodesOnPart (in  SMESH_IDSource      SubMeshOrGroup,
 748                                     in  double              Tolerance,
 749                                     out array_of_long_array GroupsOfNodes,
 750                                     in  boolean             SeparateCornersAndMedium)
 751       raises (SALOME::SALOME_Exception);
 752
 753     void FindCoincidentNodesOnPartBut (in  ListOfIDSources     SubMeshOrGroup,
 754                                        in  double              Tolerance,
 755                                        out array_of_long_array GroupsOfNodes,
 756                                        in  ListOfIDSources     ExceptSubMeshOrGroups,
 757                                        in  boolean             SeparateCornersAndMedium)
 758       raises (SALOME::SALOME_Exception);
 759
 760     void MergeNodes (in array_of_long_array    GroupsOfNodes,
 761                      in SMESH::ListOfIDSources NodesToKeep,
 762                      in boolean                AvoidMakingHoles)
 763       raises (SALOME::SALOME_Exception);
 764
 765     /*!
 766      * \brief Find elements built on the same nodes.
 767      * \param MeshOrSubMeshOrGroup Mesh or SubMesh, or Group of elements for searching.
 768      * \return List of groups of equal elements.
 769      */
 770     void FindEqualElements (in  ListOfIDSources     MeshOrSubMeshOrGroup,
 771                             in  ListOfIDSources     ExceptSubMeshOrGroups,
 772                             out array_of_long_array GroupsOfElementsID)
 773       raises (SALOME::SALOME_Exception);
 774
 775     /*!
 776      * \brief Merge elements in each given group.
 777      * \param GroupsOfElementsID Groups of elements for merging.
 778      */
 779     void MergeElements(in array_of_long_array    GroupsOfElementsID,
 780                        in SMESH::ListOfIDSources ElementsToKeep)
 781       raises (SALOME::SALOME_Exception);
 782
 783     /*!
 784      * \brief Merge equal elements in the whole mesh.
 785      */
 786     void MergeEqualElements()
 787       raises (SALOME::SALOME_Exception);
 788
 789     /*!
 790      * If the given ID is a valid node ID (nodeID > 0), just move this node, else
 791      * move the node closest to the point to point's location and return ID of the node
 792      */
 793     smIdType MoveClosestNodeToPoint(in double x, in double y, in double z, in smIdType nodeID)
 794       raises (SALOME::SALOME_Exception);
 795
 796     /*!
 797      * Return ID of node closest to a given point
 798      */
 799     smIdType FindNodeClosestTo(in double x, in double y, in double z)
 800       raises (SALOME::SALOME_Exception);
 801
 802     /*!
 803      * Return elements of given type where the given point is IN or ON.
 804      *
 805      * 'ALL' type means elements of any type excluding nodes and 0D elements
 806      */
 807     smIdType_array FindElementsByPoint(in double x, in double y, in double z, in ElementType type)
 808       raises (SALOME::SALOME_Exception);
 809
 810     /*!
 811      * Searching among the given elements, return elements of given type
 812      * where the given point is IN or ON.
 813      *
 814      * 'ALL' type means elements of any type excluding nodes and 0D elements
 815      */
 816     smIdType_array FindAmongElementsByPoint(in SMESH_IDSource elements,
 817                                             in double x, in double y, in double z,
 818                                             in ElementType type)
 819       raises (SALOME::SALOME_Exception);
 820
 821     /*!
 822      * Project a point to a mesh object.
 823      * Return ID of an element of given type where the given point is projected
 824      * and coordinates of the projection point.
 825      * In the case if nothing found, return -1 and []
 826      */
 827     smIdType ProjectPoint(in double         x,
 828                           in double         y,
 829                           in double         z,
 830                           in ElementType    type,
 831                           in SMESH_IDSource meshObject,
 832                           out double_array  projecton)
 833       raises (SALOME::SALOME_Exception);
 834
 835     /*!
 836      * Return point state in a closed 2D mesh in terms of TopAbs_State enumeration.
 837      * TopAbs_UNKNOWN state means that either mesh is wrong or the analysis fails.
 838      */
 839     short GetPointState(in double x, in double y, in double z)
 840       raises (SALOME::SALOME_Exception);
 841
 842     /*!
 843      * Check if a 2D mesh is manifold
 844      */
 845     boolean IsManifold()
 846       raises (SALOME::SALOME_Exception);
 847
 848     /*!
 849      * Check if orientation of 2D elements is coherent
 850      */
 851     boolean IsCoherentOrientation2D()
 852       raises (SALOME::SALOME_Exception);
 853
 854     /*!
 855      * Partition given 1D elements into groups of contiguous edges.
 856      * A node where number of meeting edges != 2 is a group end.
 857      * An optional startNode is used to orient groups it belongs to.
 858      * \return a list of edge groups and a list of corresponding node groups.
 859      *         If a group is closed, the first and last nodes of the group are same.
 860      */
 861     array_of_long_array Get1DBranches( in SMESH_IDSource       edges,
 862                                        in smIdType             startNode,
 863                                        out array_of_long_array nodeGroups)
 864       raises (SALOME::SALOME_Exception);
 865
 866     /*!
 867      * Return sharp edges of faces and non-manifold ones.
 868      * Optionally add existing edges. Angle is in degrees.
 869      */
 870     ListOfEdges FindSharpEdges(in double angle, in boolean addExistingEdges)
 871       raises (SALOME::SALOME_Exception);
 872
 873     /*!
 874      * Returns all or only closed FreeBorder's.
 875      */
 876     ListOfFreeBorders FindFreeBorders(in boolean closedOnly)
 877       raises (SALOME::SALOME_Exception);
 878
 879     /*!
 880      * Fill with 2D elements a hole defined by a FreeBorder.
 881      * Optionally add new faces to a given group, which is returned.
 882      */
 883     SMESH_Group FillHole(in FreeBorder hole, in string groupName)
 884       raises (SALOME::SALOME_Exception);
 885
 886     /*!
 887      * Returns groups of FreeBorder's coincident within the given tolerance.
 888      * If the tolerance <= 0.0 then one tenth of an average size of elements adjacent
 889      * to free borders being compared is used.
 890      */
 891     CoincidentFreeBorders FindCoincidentFreeBorders(in double tolerance);
 892
 893     /*!
 894      * Sew FreeBorder's of each group
 895      */
 896     short SewCoincidentFreeBorders (in CoincidentFreeBorders freeBorders,
 897                                     in boolean               createPolygons,
 898                                     in boolean               createPolyedrs)
 899       raises (SALOME::SALOME_Exception);
 900
 901     enum Sew_Error {
 902       SEW_OK,
 903       SEW_BORDER1_NOT_FOUND,
 904       SEW_BORDER2_NOT_FOUND,
 905       SEW_BOTH_BORDERS_NOT_FOUND,
 906       SEW_BAD_SIDE_NODES,
 907       SEW_VOLUMES_TO_SPLIT,
 908       // for SewSideElements() only:
 909       SEW_DIFF_NB_OF_ELEMENTS,
 910       SEW_TOPO_DIFF_SETS_OF_ELEMENTS,
 911       SEW_BAD_SIDE1_NODES,
 912       SEW_BAD_SIDE2_NODES,
 913       SEW_INTERNAL_ERROR
 914     };
 915
 916     Sew_Error SewFreeBorders (in smIdType FirstNodeID1,
 917                               in smIdType SecondNodeID1,
 918                               in smIdType LastNodeID1,
 919                               in smIdType FirstNodeID2,
 920                               in smIdType SecondNodeID2,
 921                               in smIdType LastNodeID2,
 922                               in boolean  CreatePolygons,
 923                               in boolean  CreatePolyedrs)
 924       raises (SALOME::SALOME_Exception);
 925
 926     Sew_Error SewConformFreeBorders (in smIdType FirstNodeID1,
 927                                      in smIdType SecondNodeID1,
 928                                      in smIdType LastNodeID1,
 929                                      in smIdType FirstNodeID2,
 930                                      in smIdType SecondNodeID2)
 931       raises (SALOME::SALOME_Exception);
 932
 933     Sew_Error SewBorderToSide (in smIdType FirstNodeIDOnFreeBorder,
 934                                in smIdType SecondNodeIDOnFreeBorder,
 935                                in smIdType LastNodeIDOnFreeBorder,
 936                                in smIdType FirstNodeIDOnSide,
 937                                in smIdType LastNodeIDOnSide,
 938                                in boolean  CreatePolygons,
 939                                in boolean  CreatePolyedrs)
 940       raises (SALOME::SALOME_Exception);
 941
 942     Sew_Error SewSideElements (in smIdType_array IDsOfSide1Elements,
 943                                in smIdType_array IDsOfSide2Elements,
 944                                in smIdType       NodeID1OfSide1ToMerge,
 945                                in smIdType       NodeID1OfSide2ToMerge,
 946                                in smIdType       NodeID2OfSide1ToMerge,
 947                                in smIdType       NodeID2OfSide2ToMerge)
 948       raises (SALOME::SALOME_Exception);
 949
 950    /*!
 951     * Set new nodes for given element.
 952     * If number of nodes is not corresponded to type of
 953     * element - returns false
 954     */
 955     boolean ChangeElemNodes(in smIdType id, in smIdType_array newIDs)
 956       raises (SALOME::SALOME_Exception);
 957
 958     /*!
 959      * \brief Duplicates given elements, i.e. creates new elements based on the
 960      *        same nodes as the given ones.
 961      * \param theElements - container of elements to duplicate.
 962      * \param theGroupName - a name of group to contain the generated elements.
 963      *                    If a group with such a name already exists, the new elements
 964      *                    are added to the existing group, else a new group is created.
 965      *                    If \a theGroupName is empty, new elements are not added
 966      *                    in any group.
 967      * \return a group where the new elements are added. NULL if theGroupName == "".
 968      * \sa DoubleNode()
 969      */
 970     SMESH_Group DoubleElements( in SMESH_IDSource theElements,
 971                                 in string         theGroupName )
 972       raises (SALOME::SALOME_Exception);
 973
 974     /*!
 975      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
 976      * \param theNodes - identifiers of nodes to be doubled
 977      * \param theModifiedElems - identifiers of elements to be updated by the new (doubled)
 978      *        nodes. If list of element identifiers is empty then nodes are doubled but
 979      *        they not assigned to elements
 980      * \return TRUE if operation has been completed successfully, FALSE otherwise
 981      * \sa DoubleNode(), DoubleNodeGroup(), DoubleNodeGroups()
 982      */
 983     boolean DoubleNodes( in smIdType_array theNodes, in smIdType_array theModifiedElems )
 984       raises (SALOME::SALOME_Exception);
 985
 986     /*!
 987      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
 988      * This method provided for convenience works as DoubleNodes() described above.
 989      * \param theNodeId - identifier of node to be doubled.
 990      * \param theModifiedElems - identifiers of elements to be updated.
 991      * \return TRUE if operation has been completed successfully, FALSE otherwise
 992      * \sa DoubleNodes(), DoubleNodeGroup(), DoubleNodeGroups()
 993      */
 994     boolean DoubleNode( in smIdType theNodeId, in smIdType_array theModifiedElems )
 995       raises (SALOME::SALOME_Exception);
 996
 997     /*!
 998      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
 999      * This method provided for convenience works as DoubleNodes() described above.
1000      * \param theNodes - group of nodes to be doubled.
1001      * \param theModifiedElems - group of elements to be updated.
1002      * \return TRUE if operation has been completed successfully, FALSE otherwise
1003      * \sa DoubleNode(), DoubleNodes(), DoubleNodeGroups(), DoubleNodeGroupNew()
1004      */
1005     boolean DoubleNodeGroup( in SMESH_GroupBase theNodes,
1006                              in SMESH_GroupBase theModifiedElems )
1007       raises (SALOME::SALOME_Exception);
1008     /*!
1009      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
1010      * Works as DoubleNodeGroup() described above, but returns a new group with
1011      * newly created nodes.
1012      * \param theNodes - group of nodes to be doubled.
1013      * \param theModifiedElems - group of elements to be updated.
1014      * \return a new group with newly created nodes
1015      * \sa DoubleNodeGroup()
1016      */
1017     SMESH_Group DoubleNodeGroupNew( in SMESH_GroupBase theNodes,
1018                                     in SMESH_GroupBase theModifiedElems )
1019       raises (SALOME::SALOME_Exception);
1020
1021     /*!
1022      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
1023      * This method provided for convenience works as DoubleNodes() described above.
1024      * \param theNodes - list of groups of nodes to be doubled
1025      * \param theModifiedElems - list of groups of elements to be updated.
1026      * \return TRUE if operation has been completed successfully, FALSE otherwise
1027      * \sa DoubleNode(), DoubleNodeGroup(), DoubleNodes()
1028      */
1029     boolean DoubleNodeGroups( in ListOfGroups theNodes,
1030                               in ListOfGroups theModifiedElems )
1031       raises (SALOME::SALOME_Exception);
1032     /*!
1033      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
1034      * Works as DoubleNodeGroups() described above, but returns a new group with
1035      * newly created nodes.
1036      * \param theNodes - list of groups of nodes to be doubled
1037      * \param theModifiedElems - list of groups of elements to be updated.
1038      * \return a new group with newly created nodes
1039      * \sa DoubleNodeGroups()
1040      */
1041     SMESH_Group DoubleNodeGroupsNew( in ListOfGroups theNodes,
1042                                      in ListOfGroups theModifiedElems )
1043       raises (SALOME::SALOME_Exception);
1044
1045     /*!
1046      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
1047      * \param theElems - the list of elements (edges or faces) to be replicated
1048      *        The nodes for duplication could be found from these elements
1049      * \param theNodesNot - list of nodes to NOT replicate
1050      * \param theAffectedElems - the list of elements (cells and edges) to which the
1051      *        replicated nodes should be associated to.
1052      * \return TRUE if operation has been completed successfully, FALSE otherwise
1053      * \sa DoubleNodeGroup(), DoubleNodeGroups()
1054      */
1055     boolean DoubleNodeElem( in smIdType_array theElems,
1056                             in smIdType_array theNodesNot,
1057                             in smIdType_array theAffectedElems )
1058       raises (SALOME::SALOME_Exception);
1059
1060     /*!
1061      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
1062      * \param theElems - the list of elements (edges or faces) to be replicated
1063      *        The nodes for duplication could be found from these elements
1064      * \param theNodesNot - list of nodes to NOT replicate
1065      * \param theShape - shape to detect affected elements (element which geometric center
1066      *        located on or inside shape).
1067      *        The replicated nodes should be associated to affected elements.
1068      * \return TRUE if operation has been completed successfully, FALSE otherwise
1069      * \sa DoubleNodeGroupInRegion(), DoubleNodeGroupsInRegion()
1070      */
1071     boolean DoubleNodeElemInRegion( in smIdType_array    theElems,
1072                                     in smIdType_array    theNodesNot,
1073                                     in GEOM::GEOM_Object theShape )
1074       raises (SALOME::SALOME_Exception);
1075
1076     /*!
1077      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
1078      * This method provided for convenience works as DoubleNodes() described above.
1079      * \param theElems - group of of elements (edges or faces) to be replicated
1080      * \param theNodesNot - group of nodes not to replicated
1081      * \param theAffectedElems - group of elements to which the replicated nodes
1082      *        should be associated to.
1083      * \return TRUE if operation has been completed successfully, FALSE otherwise
1084      * \sa DoubleNodes(), DoubleNodeGroups(), DoubleNodeElemGroupNew()
1085      */
1086     boolean DoubleNodeElemGroup( in SMESH_GroupBase theElems,
1087                                  in SMESH_GroupBase theNodesNot,
1088                                  in SMESH_GroupBase theAffectedElems )
1089       raises (SALOME::SALOME_Exception);
1090     /*!
1091      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
1092      * Works as DoubleNodeElemGroup() described above, but returns a new group with
1093      * newly created elements.
1094      * \param theElems - group of of elements (edges or faces) to be replicated
1095      * \param theNodesNot - group of nodes not to replicated
1096      * \param theAffectedElems - group of elements to which the replicated nodes
1097      *        should be associated to.
1098      * \return a new group with newly created elements
1099      * \sa DoubleNodeElemGroup()
1100      */
1101     SMESH_Group DoubleNodeElemGroupNew( in SMESH_GroupBase theElems,
1102                                         in SMESH_GroupBase theNodesNot,
1103                                         in SMESH_GroupBase theAffectedElems )
1104       raises (SALOME::SALOME_Exception);
1105     /*!
1106      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
1107      * Works as DoubleNodeElemGroup() described above, but returns two new groups:
1108      * a group of newly created elements and a group of newly created nodes
1109      * \param theElems - group of of elements (edges or faces) to be replicated
1110      * \param theNodesNot - group of nodes not to replicated
1111      * \param theAffectedElems - group of elements to which the replicated nodes
1112      *        should be associated to.
1113      * \param theElemGroupNeeded - to create group of new elements or not
1114      * \param theNodeGroupNeeded - to create group of new nodes or not
1115      * \return two new groups of newly created elements (1st) and nodes (2nd)
1116      * \sa DoubleNodeElemGroup()
1117      */
1118     ListOfGroups DoubleNodeElemGroup2New( in SMESH_GroupBase theElems,
1119                                           in SMESH_GroupBase theNodesNot,
1120                                           in SMESH_GroupBase theAffectedElems,
1121                                           in boolean         theElemGroupNeeded,
1122                                           in boolean         theNodeGroupNeeded)
1123       raises (SALOME::SALOME_Exception);
1124
1125     /*!
1126      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
1127      * This method provided for convenience works as DoubleNodes() described above.
1128      * \param theElems - group of elements (edges or faces) to be replicated
1129      * \param theNodesNot - group of nodes not to replicated
1130      * \param theShape - shape to detect affected elements (element which geometric center
1131      *        located on or inside shape).
1132      *        The replicated nodes should be associated to affected elements.
1133      * \return TRUE if operation has been completed successfully, FALSE otherwise
1134      * \sa DoubleNodesInRegion(), DoubleNodeGroupsInRegion()
1135      */
1136     boolean DoubleNodeElemGroupInRegion( in SMESH_GroupBase theElems,
1137                                          in SMESH_GroupBase theNodesNot,
1138                                          in GEOM::GEOM_Object theShape )
1139       raises (SALOME::SALOME_Exception);
1140
1141     /*!
1142      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
1143      * This method provided for convenience works as DoubleNodes() described above.
1144      * \param theElems - list of groups of elements (edges or faces) to be replicated
1145      * \param theNodesNot - list of groups of nodes not to replicated
1146      * \param theAffectedElems - group of elements to which the replicated nodes
1147      *        should be associated to.
1148      * \return TRUE if operation has been completed successfully, FALSE otherwise
1149      * \sa DoubleNodeGroup(), DoubleNodes(), DoubleNodeElemGroupsNew()
1150      */
1151     boolean DoubleNodeElemGroups( in ListOfGroups theElems,
1152                                   in ListOfGroups theNodesNot,
1153                                   in ListOfGroups theAffectedElems )
1154       raises (SALOME::SALOME_Exception);
1155     /*!
1156      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
1157      * Works as DoubleNodeElemGroups() described above, but returns a new group with
1158      * newly created elements.
1159      * \param theElems - list of groups of elements (edges or faces) to be replicated
1160      * \param theNodesNot - list of groups of nodes not to replicated
1161      * \param theAffectedElems - group of elements to which the replicated nodes
1162      *        should be associated to.
1163      * \return a new group with newly created elements
1164      * \sa DoubleNodeElemGroups()
1165      */
1166     SMESH_Group DoubleNodeElemGroupsNew( in ListOfGroups theElems,
1167                                          in ListOfGroups theNodesNot,
1168                                          in ListOfGroups theAffectedElems )
1169       raises (SALOME::SALOME_Exception);
1170     /*!
1171      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
1172      * Works as DoubleNodeElemGroups() described above, but returns two new groups:
1173      * a group of newly created elements and a group of newly created nodes.
1174      * \param theElems - list of groups of elements (edges or faces) to be replicated
1175      * \param theNodesNot - list of groups of nodes not to replicated
1176      * \param theAffectedElems - group of elements to which the replicated nodes
1177      *        should be associated to.
1178      * \param theElemGroupNeeded - to create group of new elements or not
1179      * \param theNodeGroupNeeded - to create group of new nodes or not
1180      * \return two new groups of newly created elements (1st) and nodes (2nd)
1181      * \sa DoubleNodeElemGroups()
1182      */
1183     ListOfGroups DoubleNodeElemGroups2New( in ListOfGroups theElems,
1184                                            in ListOfGroups theNodesNot,
1185                                            in ListOfGroups theAffectedElems,
1186                                            in boolean         theElemGroupNeeded,
1187                                            in boolean         theNodeGroupNeeded )
1188       raises (SALOME::SALOME_Exception);
1189
1190     /*!
1191      * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
1192      * This method provided for convenience works as DoubleNodes() described above.
1193      * \param theElems - list of groups of elements (edges or faces) to be replicated
1194      * \param theNodesNot - list of groups of nodes not to replicated
1195      * \param theShape - shape to detect affected elements (element which geometric center
1196      *        located on or inside shape).
1197      *        The replicated nodes should be associated to affected elements.
1198      * \return TRUE if operation has been completed successfully, FALSE otherwise
1199      * \sa DoubleNodeGroupInRegion(), DoubleNodesInRegion()
1200      */
1201     boolean DoubleNodeElemGroupsInRegion( in ListOfGroups theElems,
1202                                           in ListOfGroups theNodesNot,
1203                                           in GEOM::GEOM_Object theShape )
1204       raises (SALOME::SALOME_Exception);
1205
1206     /*!
1207      * \brief Identify the elements that will be affected by node duplication (actual duplication is not performed).
1208      * This method is the first step of DoubleNodeElemGroupsInRegion.
1209      * \param theElems - list of groups of elements (edges or faces) to be replicated
1210      * \param theNodesNot - list of groups of nodes not to replicated
1211      * \param theShape - shape to detect affected elements (element which geometric center
1212      *        located on or inside shape).
1213      *        The replicated nodes should be associated to affected elements.
1214      * \return groups of affected elements
1215      * \sa DoubleNodeElemGroupsInRegion()
1216      */
1217     ListOfGroups AffectedElemGroupsInRegion( in ListOfGroups theElems,
1218                                              in ListOfGroups theNodesNot,
1219                                              in GEOM::GEOM_Object theShape )
1220       raises (SALOME::SALOME_Exception);
1221
1222     /*!
1223      * \brief Generates skin mesh (containing 2D cells) from 3D mesh
1224      * The created 2D mesh elements based on nodes of free faces of boundary volumes
1225      * \return TRUE if operation has been completed successfully, FALSE otherwise
1226      */
1227     boolean Make2DMeshFrom3D() raises (SALOME::SALOME_Exception);
1228
1229     /*!
1230      * \brief Creates missing boundary elements
1231      *  \param elements - elements whose boundary is to be checked
1232      *  \param dimension - defines type of boundary elements to create
1233      *    BND_1DFROM3D creates mesh edges on all borders of free facets of 3D elements.
1234      *  \param groupName - a name of group to store created boundary elements in,
1235      *                     "" means not to create the group
1236      *  \param meshName - a name of new mesh to store created boundary elements in,
1237      *                     "" means not to create the new mesh
1238      *  \param toCopyElements - if true, the checked elements will be copied into the new mesh
1239      *                          else only boundary elements will be copied into the new mesh
1240      *  \param toCopyExistingBondary - if true, not only new but also pre-existing
1241      *                                boundary elements will be copied into the new mesh
1242      *  \param group - returns the create group, if any
1243      *  \retval SMESH::SMESH_Mesh - the mesh where elements were added to
1244      */
1245     SMESH_Mesh MakeBoundaryMesh(in SMESH_IDSource elements,
1246                                 in Bnd_Dimension  dimension,
1247                                 in string         groupName,
1248                                 in string         meshName,
1249                                 in boolean        toCopyElements,
1250                                 in boolean        toCopyExistingBondary,
1251                                 out SMESH_Group   group) raises (SALOME::SALOME_Exception);
1252     /*!
1253      * \brief Creates missing boundary elements around either the whole mesh or
1254      *    groups of 2D elements
1255      *  \param dimension - defines type of boundary elements to create
1256      *  \param groupName - a name of group to store all boundary elements in,
1257      *    "" means not to create the group
1258      *  \param meshName - a name of a new mesh, which is a copy of the initial
1259      *    mesh + created boundary elements; "" means not to create the new mesh
1260      *  \param toCopyAll - if true, the whole initial mesh will be copied into
1261      *    the new mesh else only boundary elements will be copied into the new mesh
1262      *  \param groups - optional groups of 2D elements to make boundary around
1263      *  \param mesh - returns the mesh where elements were added to
1264      *  \param group - returns the created group, if any
1265      *  \retval long - number of added boundary elements
1266      */
1267     long MakeBoundaryElements(in Bnd_Dimension   dimension,
1268                               in string          groupName,
1269                               in string          meshName,
1270                               in boolean         toCopyAll,
1271                               in ListOfIDSources groups,
1272                               out SMESH_Mesh     mesh,
1273                               out SMESH_Group    group) raises (SALOME::SALOME_Exception);
1274
1275     /*!
1276      * \brief Double nodes on shared faces between groups of volumes and create flat elements on demand.
1277      * Flat elements are mainly used by some types of mechanic calculations.
1278      *
1279      * The list of groups must describe a partition of the mesh volumes.
1280      * The nodes of the internal faces at the boundaries of the groups are doubled.
1281      * In option, the internal faces are replaced by flat elements.
1282      * Triangles are transformed in prisms, and quadrangles in hexahedrons.
1283      * \param theDomains - list of groups of volumes
1284      * \param createJointElems - if TRUE, create the elements
1285      * \param onAllBoundaries - if TRUE, the nodes and elements are also created on
1286      *        the boundary between \a theDomains and the rest mesh
1287      * \return TRUE if operation has been completed successfully, FALSE otherwise
1288      */
1289     boolean DoubleNodesOnGroupBoundaries( in ListOfGroups theDomains,
1290                                           in boolean      createJointElems,
1291                                           in boolean      onAllBoundaries)
1292       raises (SALOME::SALOME_Exception);
1293
1294     /*!
1295      * \brief Double nodes on some external faces and create flat elements.
1296      * Flat elements are mainly used by some types of mechanic calculations.
1297      *
1298      * Each group of the list must be constituted of faces.
1299      * Triangles are transformed in prisms, and quadrangles in hexahedrons.
1300      * \param theGroupsOfFaces - list of groups of faces
1301      * \return TRUE if operation has been completed successfully, FALSE otherwise
1302      */
1303     boolean CreateFlatElementsOnFacesGroups( in ListOfGroups theGroupsOfFaces )
1304       raises (SALOME::SALOME_Exception);
1305
1306     /*!
1307      *  \brief identify all the elements around a geom shape, get the faces delimiting the hole
1308      *  Build groups of volume to remove, groups of faces to replace on the skin of the object,
1309      *  groups of faces to remove insidethe object, (idem edges).
1310      *  Build ordered list of nodes at the border of each group of faces to replace (to be used to build a geom subshape)
1311      */
1312     void CreateHoleSkin(in double radius,
1313                         in GEOM::GEOM_Object theShape,
1314                         in string groupName,
1315                         in double_array theNodesCoords,
1316                         out array_of_long_array GroupsOfNodes)
1317       raises (SALOME::SALOME_Exception);
1318
1319
1320     /*!
1321      * \brief Create a polyline consisting of 1D mesh elements each lying on a 2D element of
1322      *        the initial triangle mesh. Positions of new nodes are found by cutting the mesh by
1323      *        the plane passing through pairs of points specified by each PolySegment structure.
1324      *        If there are several paths connecting a pair of points, the shortest path is
1325      *        selected by the module. Position of the cutting plane is defined by the two
1326      *        points and an optional vector lying on the plane specified by a PolySegment.
1327      *        By default the vector is defined by Mesh module as following. A middle point
1328      *        of the two given points is computed. The middle point is projected to the mesh.
1329      *        The vector goes from the middle point to the projection point. In case of planar
1330      *        mesh, the vector is normal to the mesh.
1331      *  \param [inout] segments - PolySegment's defining positions of cutting planes.
1332      *        Return the used vector which goes from the middle point to its projection.
1333      *  \param [in] groupName - optional name of a group where created mesh segments will
1334      *        be added.
1335      */
1336     void MakePolyLine(inout ListOfPolySegments segments,
1337                       in    string             groupName)
1338       raises (SALOME::SALOME_Exception);
1339
1340     /*!
1341      * \brief Create a slot of given width around given 1D elements lying on a triangle mesh.
1342      *        The slot is constructed by cutting faces by cylindrical surfaces made
1343      *        around each segment. Segments are expected to be created by MakePolyLine().
1344      * \return Edges located at the slot boundary
1345      */
1346     ListOfEdges MakeSlot( in SMESH_GroupBase segments,
1347                           in double          width )
1348       raises (SALOME::SALOME_Exception);
1349
1350   };
1351 };
1352
1353 #endif