ASERIS: Return a group from FillHole()

+
1) Minor doc imp
2) Fix a bug that some filters can't work with SMESH::ALL element type
3) Fix an icon of imported meshes

diff --git a/doc/salome/gui/SMESH/collect_mesh_methods.py b/doc/salome/gui/SMESH/collect_mesh_methods.py
index 3566741ade9557c1b45120a3678e2980752fe671..a4ba60f17d3af4d757afe54bb42a2e905e867b66 100755 (executable)
--- a/doc/salome/gui/SMESH/collect_mesh_methods.py
+++ b/doc/salome/gui/SMESH/collect_mesh_methods.py
@@ -127,7 +127,7 @@ def main(plugin_name, dummymeshhelp = True, output_file = "smeshBuilder.py", for
                     if hasattr( algo, "docHelper" ): docHelper = getattr( algo, "docHelper" )
                     if docHelper: break
                     pass
                     if hasattr( algo, "docHelper" ): docHelper = getattr( algo, "docHelper" )
                     if docHelper: break
                     pass

-                if not docHelper: docHelper = "Creates new algorithm."
+                if not docHelper: docHelper = "Create new algorithm."

                 if format == "doxygen":
                     output.append( " ## %s" % docHelper )
                     output.append( " #" )
                 if format == "doxygen":
                     output.append( " ## %s" % docHelper )
                     output.append( " #" )

diff --git a/doc/salome/gui/SMESH/input/modules.rst b/doc/salome/gui/SMESH/input/modules.rst
index 35349ee00efec24b1d177c1e5c2823c3149f579e..45494b2a5c09d3d1941bc82ba3a184338cb68fe2 100644 (file)
--- a/doc/salome/gui/SMESH/input/modules.rst
+++ b/doc/salome/gui/SMESH/input/modules.rst
@@ -48,6 +48,7 @@ Constructing meshes
    Mesh.Clear
    Mesh.GetMesh
    Mesh.GetShape
    Mesh.Clear
    Mesh.GetMesh
    Mesh.GetShape

+   Mesh.HasShapeToMesh

    Mesh.GetComputeErrors
    Mesh.GetAlgoState
    Mesh.GetFailedShapes
    Mesh.GetComputeErrors
    Mesh.GetAlgoState
    Mesh.GetFailedShapes

diff --git a/idl/SMESH_MeshEditor.idl b/idl/SMESH_MeshEditor.idl
index 21a6374c1ce2e761c5a45bdfd88a1eb698edcd70..86493fe3464c924ee3110cf4b4eef289efaa867b 100644 (file)
--- a/idl/SMESH_MeshEditor.idl
+++ b/idl/SMESH_MeshEditor.idl
@@ -800,8 +800,9 @@ module SMESH
 
     /*!
      * Fill with 2D elements a hole defined by a FreeBorder.
 
     /*!
      * Fill with 2D elements a hole defined by a FreeBorder.

+     * Optionally add new faces to a given group, which is returned.

      */
      */

-    void FillHole(in FreeBorder hole)
+    SMESH_Group FillHole(in FreeBorder hole, in string groupName)

       raises (SALOME::SALOME_Exception);
 
     /*!
       raises (SALOME::SALOME_Exception);
 
     /*!

diff --git a/src/Controls/SMESH_Controls.cxx b/src/Controls/SMESH_Controls.cxx
index 2a1e274fd530f72d4f5c50243c87b622421cbff7..f71565018cb61459c3a39f638d4c493cc59a891e 100644 (file)
--- a/src/Controls/SMESH_Controls.cxx
+++ b/src/Controls/SMESH_Controls.cxx
@@ -3043,7 +3043,7 @@ bool ConnectedElements::IsSatisfy( long theElementId )
       {
         // keep elements of myType
         const SMDS_MeshElement* element = eIt->next();
       {
         // keep elements of myType
         const SMDS_MeshElement* element = eIt->next();

-        if ( element->GetType() == myType )
+        if ( myType == SMDSAbs_All || element->GetType() == myType )

           myOkIDs.insert( myOkIDs.end(), element->GetID() );
 
         // enqueue nodes of the element
           myOkIDs.insert( myOkIDs.end(), element->GetID() );
 
         // enqueue nodes of the element


@@ -4869,7 +4869,7 @@ bool BelongToGeom::IsSatisfy (long theId)
   {
     if ( const SMDS_MeshElement* anElem = myMeshDS->FindElement( theId ))
     {
   {
     if ( const SMDS_MeshElement* anElem = myMeshDS->FindElement( theId ))
     {

-      if ( anElem->GetType() == myType )
+      if ( myType == SMDSAbs_All || anElem->GetType() == myType )

       {
         if ( anElem->getshapeId() < 1 )
           return myElementsOnShapePtr->IsSatisfy(theId);
       {
         if ( anElem->getshapeId() < 1 )
           return myElementsOnShapePtr->IsSatisfy(theId);


@@ -5009,7 +5009,8 @@ bool LyingOnGeom::IsSatisfy( long theId )
   if ( mySubShapesIDs.Contains( elem->getshapeId() ))
     return true;
 
   if ( mySubShapesIDs.Contains( elem->getshapeId() ))
     return true;
 

-  if ( elem->GetType() != SMDSAbs_Node && elem->GetType() == myType )
+  if (( elem->GetType() != SMDSAbs_Node ) &&
+      ( myType == SMDSAbs_All || elem->GetType() == myType ))

   {
     SMDS_ElemIteratorPtr nodeItr = elem->nodesIterator();
     while ( nodeItr->more() )
   {
     SMDS_ElemIteratorPtr nodeItr = elem->nodesIterator();
     while ( nodeItr->more() )

diff --git a/src/SMESH/SMESH_Mesh.cxx b/src/SMESH/SMESH_Mesh.cxx
index c1bbb1702bdfb881d632662a65d4b21f28d9aa54..dcdb4f0ac8975d6b16f5f9c9b9e50890adc9be98 100644 (file)
--- a/src/SMESH/SMESH_Mesh.cxx
+++ b/src/SMESH/SMESH_Mesh.cxx
@@ -1347,8 +1347,8 @@ bool SMESH_Mesh::IsComputedOK()
   if ( NbNodes() == 0 )
     return false;
 
   if ( NbNodes() == 0 )
     return false;
 

-  if ( !HasShapeToMesh() )
-    return true;
+  // if ( !HasShapeToMesh() )
+  //   return true;

 
   if ( SMESH_subMesh* mainSM = GetSubMeshContaining( 1 ))
   {
 
   if ( SMESH_subMesh* mainSM = GetSubMeshContaining( 1 ))
   {

diff --git a/src/SMESH_I/SMESH_Gen_i_1.cxx b/src/SMESH_I/SMESH_Gen_i_1.cxx
index a73f93c3c0417fcd49ad3dd738dc02fb01b7f0aa..9e54cbd4987608a54c71dc274445d5e902abe857 100644 (file)
--- a/src/SMESH_I/SMESH_Gen_i_1.cxx
+++ b/src/SMESH_I/SMESH_Gen_i_1.cxx
@@ -891,8 +891,10 @@ void SMESH_Gen_i::UpdateIcons( SMESH::SMESH_Mesh_ptr theMesh )
     SetPixMap( so, "ICON_SMESH_TREE_MESH_WARN" );
   else if ( mesh_i->IsComputedOK() )
     SetPixMap( so, "ICON_SMESH_TREE_MESH" );
     SetPixMap( so, "ICON_SMESH_TREE_MESH_WARN" );
   else if ( mesh_i->IsComputedOK() )
     SetPixMap( so, "ICON_SMESH_TREE_MESH" );

-  else
+  else if ( mesh_i->HasShapeToMesh() )

     SetPixMap( so, "ICON_SMESH_TREE_MESH_PARTIAL" );
     SetPixMap( so, "ICON_SMESH_TREE_MESH_PARTIAL" );

+  else
+    SetPixMap( so, "ICON_SMESH_TREE_MESH_IMPORTED" );

 
   // set icons of sub-objects
   SALOMEDS::Study_var         study = getStudyServant();
 
   // set icons of sub-objects
   SALOMEDS::Study_var         study = getStudyServant();

diff --git a/src/SMESH_I/SMESH_MeshEditor_i.cxx b/src/SMESH_I/SMESH_MeshEditor_i.cxx
index dd2d442ce53e28e74ed916916f663e31b04a1373..1628af333ae73581417b70eca80a566662b9c023 100644 (file)
--- a/src/SMESH_I/SMESH_MeshEditor_i.cxx
+++ b/src/SMESH_I/SMESH_MeshEditor_i.cxx
@@ -4751,7 +4751,9 @@ SMESH::ListOfFreeBorders* SMESH_MeshEditor_i::FindFreeBorders(CORBA::Boolean clo
 //purpose  : Fill with 2D elements a hole defined by a FreeBorder.
 //=======================================================================
 
 //purpose  : Fill with 2D elements a hole defined by a FreeBorder.
 //=======================================================================
 

-void SMESH_MeshEditor_i::FillHole(const SMESH::FreeBorder& theHole)
+SMESH::SMESH_Group_ptr 
+SMESH_MeshEditor_i::FillHole(const SMESH::FreeBorder& theHole,
+                             const char*              theGroupName)

   throw (SALOME::SALOME_Exception)
 {
   initData();
   throw (SALOME::SALOME_Exception)
 {
   initData();


@@ -4774,6 +4776,7 @@ void SMESH_MeshEditor_i::FillHole(const SMESH::FreeBorder& theHole)
 
   SMESH_TRY;
 
 
   SMESH_TRY;
 

+  // prepare a preview mesh

   MeshEditor_I::TPreviewMesh* previewMesh = 0;
   SMDS_Mesh* meshDS = getMeshDS();
   if ( myIsPreviewMode )
   MeshEditor_I::TPreviewMesh* previewMesh = 0;
   SMDS_Mesh* meshDS = getMeshDS();
   if ( myIsPreviewMode )


@@ -4796,26 +4799,66 @@ void SMESH_MeshEditor_i::FillHole(const SMESH::FreeBorder& theHole)
     meshDS = previewMesh->GetMeshDS();
   }
 
     meshDS = previewMesh->GetMeshDS();
   }
 

+  // fill the hole

   std::vector<const SMDS_MeshElement*> newFaces;
   SMESH_MeshAlgos::FillHole( bordNodes, *meshDS, newFaces );
 
   if ( myIsPreviewMode )
   {
   std::vector<const SMDS_MeshElement*> newFaces;
   SMESH_MeshAlgos::FillHole( bordNodes, *meshDS, newFaces );
 
   if ( myIsPreviewMode )
   {

+    // show new faces

     previewMesh->Clear();
     for ( size_t i = 0; i < newFaces.size(); ++i )
       previewMesh->Copy( newFaces[i] );
   }
   else
   {
     previewMesh->Clear();
     for ( size_t i = 0; i < newFaces.size(); ++i )
       previewMesh->Copy( newFaces[i] );
   }
   else
   {

+    // return new faces via a group
+    SMESH::SMESH_Group_var group;
+    if ( theGroupName && theGroupName[0] && !newFaces.empty() )
+    {
+      SMESH::ListOfGroups_var groups = myMesh_i->GetGroups();
+      for ( CORBA::ULong i = 0; i < groups->length(); ++i )
+      {
+        SMESH::SMESH_GroupBase_var g = groups[ i ];
+        if ( g->GetType() != SMESH::FACE ) continue;
+        SMESH::SMESH_Group_var standalone = SMESH::SMESH_Group::_narrow( g );
+        if ( standalone->_is_nil() ) continue;
+        CORBA::String_var name = g->GetName();
+        if ( strcmp( theGroupName, name.in() ) == 0 )
+        {
+          group = standalone;
+          break;
+        }
+      }
+      if ( group->_is_nil() )
+        group = myMesh_i->CreateGroup( SMESH::FACE, theGroupName );
+
+      if ( !group->_is_nil() )
+      {
+        SMESH_GroupBase_i * grpI = SMESH::DownCast< SMESH_GroupBase_i* >( group );
+        SMESHDS_Group*     grpDS = static_cast< SMESHDS_Group* >( grpI->GetGroupDS() );
+        for ( size_t i = 0; i < newFaces.size(); ++i )
+          grpDS->Add( newFaces[ i ]);
+      }
+    }
+
+    // fill LastCreated

     getEditor().ClearLastCreated();
     SMESH_SequenceOfElemPtr& aSeq =
       const_cast<SMESH_SequenceOfElemPtr&>( getEditor().GetLastCreatedElems() );
     aSeq.swap( newFaces );
 
     getEditor().ClearLastCreated();
     SMESH_SequenceOfElemPtr& aSeq =
       const_cast<SMESH_SequenceOfElemPtr&>( getEditor().GetLastCreatedElems() );
     aSeq.swap( newFaces );
 

-    TPythonDump() << this << ".FillHole( SMESH.FreeBorder(" << theHole.nodeIDs << " ))";
+    TPythonDump pyDump;
+    if ( group->_is_nil() ) pyDump << "_group = ";
+    else                    pyDump << group << " = ";
+    pyDump << this << ".FillHole( SMESH.FreeBorder(" << theHole.nodeIDs << " ))";
+
+    return group._retn();

   }
 
   SMESH_CATCH( SMESH::throwCorbaException );
   }
 
   SMESH_CATCH( SMESH::throwCorbaException );

+
+  return SMESH::SMESH_Group::_nil();

 }
 
 //=======================================================================
 }
 
 //=======================================================================

diff --git a/src/SMESH_I/SMESH_MeshEditor_i.hxx b/src/SMESH_I/SMESH_MeshEditor_i.hxx
index c5818522e4362db02f95180559baff8c88732ef0..44a87ba45aea27eaa79a66b0a48c8f3019acd7fc 100644 (file)
--- a/src/SMESH_I/SMESH_MeshEditor_i.hxx
+++ b/src/SMESH_I/SMESH_MeshEditor_i.hxx
@@ -573,8 +573,10 @@ public:
 
   /*!
    * Fill with 2D elements a hole defined by a FreeBorder.
 
   /*!
    * Fill with 2D elements a hole defined by a FreeBorder.

+   * Optionally add new faces to a given group, which is returned

    */
    */

-  void FillHole(const SMESH::FreeBorder& hole)
+  SMESH::SMESH_Group_ptr FillHole(const SMESH::FreeBorder& hole,
+                                  const char*              groupName)

     throw (SALOME::SALOME_Exception);
 
   SMESH::CoincidentFreeBorders* FindCoincidentFreeBorders(CORBA::Double tolerance);
     throw (SALOME::SALOME_Exception);
 
   SMESH::CoincidentFreeBorders* FindCoincidentFreeBorders(CORBA::Double tolerance);

diff --git a/src/SMESH_SWIG/SMESH_fixation.py b/src/SMESH_SWIG/SMESH_fixation.py
index b4a4f72244291ad4b164e37452c5d3e275b91dfb..985457e11f0c94317c8479c267d169b2519b4033 100644 (file)
--- a/src/SMESH_SWIG/SMESH_fixation.py
+++ b/src/SMESH_SWIG/SMESH_fixation.py
@@ -38,7 +38,7 @@ import math
 
 def MakeFace(lstEdges) :
     """
 
 def MakeFace(lstEdges) :
     """

-    Creates a planar face from 4 edges
+    Create a planar face from 4 edges

     """
     wire = geompy.MakeWire(lstEdges)
     face = geompy.MakeFace(wire, 1)
     """
     wire = geompy.MakeWire(lstEdges)
     face = geompy.MakeFace(wire, 1)

diff --git a/src/SMESH_SWIG/StdMeshersBuilder.py b/src/SMESH_SWIG/StdMeshersBuilder.py
index 9c039d146616595b057dbde3d9873fd82d40b7e8..26433141c5f6d7dac968a62cd3c2922451d6a1b9 100644 (file)
--- a/src/SMESH_SWIG/StdMeshersBuilder.py
+++ b/src/SMESH_SWIG/StdMeshersBuilder.py
@@ -107,7 +107,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
     of smeshBuilder.Mesh class    
     """
 
     of smeshBuilder.Mesh class    
     """
 

-    docHelper  = "Creates segment 1D algorithm for edges"
+    docHelper  = "Create segment 1D algorithm for edges"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -131,7 +131,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
         Parameters:
             l : for the length of segments that cut an edge
             UseExisting : if == true - searches for an  existing hypothesis created with
         Parameters:
             l : for the length of segments that cut an edge
             UseExisting : if == true - searches for an  existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

             p : precision, used for calculation of the number of segments.
                 The precision should be a positive, meaningful value within the range [0,1].
                 In general, the number of segments is calculated with the formula:
             p : precision, used for calculation of the number of segments.
                 The precision should be a positive, meaningful value within the range [0,1].
                 In general, the number of segments is calculated with the formula:


@@ -161,7 +161,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
             length : is optional maximal allowed length of segment, if it is omitted
                 the preestimated length is used that depends on geometry size
             UseExisting : if ==true - searches for an existing hypothesis created with
             length : is optional maximal allowed length of segment, if it is omitted
                 the preestimated length is used that depends on geometry size
             UseExisting : if ==true - searches for an existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

         
         Returns:
             an instance of StdMeshers_MaxLength hypothesis
         
         Returns:
             an instance of StdMeshers_MaxLength hypothesis


@@ -252,7 +252,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
             maxSize: defines the maximal allowed segment length
             deflection: defines the maximal allowed distance from a segment to an edge
             UseExisting: if ==true - searches for an existing hypothesis created with
             maxSize: defines the maximal allowed segment length
             deflection: defines the maximal allowed distance from a segment to an edge
             UseExisting: if ==true - searches for an existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

 
         Returns:
             an instance of StdMeshers_Adaptive1D hypothesis
 
         Returns:
             an instance of StdMeshers_Adaptive1D hypothesis


@@ -280,7 +280,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
             reversedEdges: is a list of edges to mesh using reversed orientation.
                 A list item can also be a tuple (edge, 1st_vertex_of_edge)
             UseExisting: if ==true - searches for an existing hypothesis created with
             reversedEdges: is a list of edges to mesh using reversed orientation.
                 A list item can also be a tuple (edge, 1st_vertex_of_edge)
             UseExisting: if ==true - searches for an existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

 
         Returns:
                 an instance of StdMeshers_Arithmetic1D hypothesis
 
         Returns:
                 an instance of StdMeshers_Arithmetic1D hypothesis


@@ -314,7 +314,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
                 reversedEdges: is a list of edges to mesh using reversed orientation.
                     A list item can also be a tuple (edge, 1st_vertex_of_edge)
                 UseExisting: if ==true - searches for an existing hypothesis created with
                 reversedEdges: is a list of edges to mesh using reversed orientation.
                     A list item can also be a tuple (edge, 1st_vertex_of_edge)
                 UseExisting: if ==true - searches for an existing hypothesis created with

-                    the same parameters, else (default) - creates a new one
+                    the same parameters, else (default) - Create a new one

 
             Returns:
                 an instance of StdMeshers_Geometric1D hypothesis
 
             Returns:
                 an instance of StdMeshers_Geometric1D hypothesis


@@ -349,7 +349,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
             reversedEdges: is a list of edges to mesh using reversed orientation.
                 A list item can also be a tuple (edge, 1st_vertex_of_edge)
             UseExisting: if ==true - searches for an existing hypothesis created with
             reversedEdges: is a list of edges to mesh using reversed orientation.
                 A list item can also be a tuple (edge, 1st_vertex_of_edge)
             UseExisting: if ==true - searches for an existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

 
         Returns:
                 an instance of StdMeshers_FixedPoints1D hypothesis
 
         Returns:
                 an instance of StdMeshers_FixedPoints1D hypothesis


@@ -381,7 +381,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
             reversedEdges: is a list of edges to mesh using reversed orientation.
                 A list item can also be a tuple (edge, 1st_vertex_of_edge)
             UseExisting: if ==true - searches for an existing hypothesis created with
             reversedEdges: is a list of edges to mesh using reversed orientation.
                 A list item can also be a tuple (edge, 1st_vertex_of_edge)
             UseExisting: if ==true - searches for an existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

 
         Returns:
             an instance of StdMeshers_StartEndLength hypothesis
 
         Returns:
             an instance of StdMeshers_StartEndLength hypothesis


@@ -468,7 +468,7 @@ class StdMeshersBuilder_Segment(Mesh_Algorithm):
                 Any other integer value means that the hypothesis will be set on the
                 whole 1D shape, where Mesh_Segment algorithm is assigned.
             UseExisting: if ==true - searches for an  existing hypothesis created with
                 Any other integer value means that the hypothesis will be set on the
                 whole 1D shape, where Mesh_Segment algorithm is assigned.
             UseExisting: if ==true - searches for an  existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

         """
         
         import types
         """
         
         import types


@@ -545,7 +545,7 @@ class StdMeshersBuilder_CompositeSegment(StdMeshersBuilder_Segment):
         of smeshBuilder.Mesh class
     """
 
         of smeshBuilder.Mesh class
     """
 

-    docHelper  = "Creates segment 1D algorithm for edges"
+    docHelper  = "Create segment 1D algorithm for edges"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -579,7 +579,7 @@ class StdMeshersBuilder_Segment_Python(Mesh_Algorithm):
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """

-    docHelper  = "Creates segment 1D algorithm for edges"
+    docHelper  = "Create segment 1D algorithm for edges"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -605,7 +605,7 @@ class StdMeshersBuilder_Segment_Python(Mesh_Algorithm):
             n: for the number of segments that cut an edge
             func: for the python function that calculates the length of all segments
             UseExisting: if ==true - searches for the existing hypothesis created with
             n: for the number of segments that cut an edge
             func: for the python function that calculates the length of all segments
             UseExisting: if ==true - searches for the existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

         """
         
         compFun = lambda hyp, args: False
         """
         
         compFun = lambda hyp, args: False


@@ -637,7 +637,7 @@ class StdMeshersBuilder_Triangle_MEFISTO(Mesh_Algorithm):
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """

-    docHelper  = "Creates triangle 2D algorithm for faces"
+    docHelper  = "Create triangle 2D algorithm for faces"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -662,7 +662,7 @@ class StdMeshersBuilder_Triangle_MEFISTO(Mesh_Algorithm):
         Parameters:
             area: for the maximum area of each triangle
             UseExisting: if ==true - searches for an  existing hypothesis created with the
         Parameters:
             area: for the maximum area of each triangle
             UseExisting: if ==true - searches for an  existing hypothesis created with the

-                same parameters, else (default) - creates a new one
+                same parameters, else (default) - Create a new one

         """
         
         from salome.smesh.smeshBuilder import IsEqual
         """
         
         from salome.smesh.smeshBuilder import IsEqual


@@ -703,7 +703,7 @@ class StdMeshersBuilder_Quadrangle(Mesh_Algorithm):
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """

-    docHelper  = "Creates quadrangle 2D algorithm for faces"
+    docHelper  = "Create quadrangle 2D algorithm for faces"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -763,7 +763,7 @@ class StdMeshersBuilder_Quadrangle(Mesh_Algorithm):
                 In the case if the defined QuadrangleParameters() refer to a sole face,
                 all given points must lie on this face, else the mesher fails.
             UseExisting: if *True* - searches for the existing hypothesis created with
                 In the case if the defined QuadrangleParameters() refer to a sole face,
                 all given points must lie on this face, else the mesher fails.
             UseExisting: if *True* - searches for the existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

         """
         
 
         """
         
 


@@ -810,7 +810,7 @@ class StdMeshersBuilder_Quadrangle(Mesh_Algorithm):
         Parameters:
             reversed: if True, transition area is located along the coarser meshed sides.
         UseExisting: if ==true - searches for the existing hypothesis created with
         Parameters:
             reversed: if True, transition area is located along the coarser meshed sides.
         UseExisting: if ==true - searches for the existing hypothesis created with

-            the same parameters, else (default) - creates a new one
+            the same parameters, else (default) - Create a new one

         """
         
         if reversed:
         """
         
         if reversed:


@@ -824,7 +824,7 @@ class StdMeshersBuilder_Quadrangle(Mesh_Algorithm):
 
         Parameters:
             UseExisting: if ==true - searches for the existing hypothesis created with
 
         Parameters:
             UseExisting: if ==true - searches for the existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

         """
     
         return self.QuadrangleParameters(QUAD_TRIANGLE_PREF,UseExisting=UseExisting)
         """
     
         return self.QuadrangleParameters(QUAD_TRIANGLE_PREF,UseExisting=UseExisting)


@@ -839,7 +839,7 @@ class StdMeshersBuilder_Quadrangle(Mesh_Algorithm):
 
         Parameters:
             UseExisting: if ==true - searches for the existing hypothesis created with
 
         Parameters:
             UseExisting: if ==true - searches for the existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

         """
         
         return self.QuadrangleParameters(QUAD_REDUCED,UseExisting=UseExisting)
         """
         
         return self.QuadrangleParameters(QUAD_REDUCED,UseExisting=UseExisting)


@@ -854,7 +854,7 @@ class StdMeshersBuilder_Quadrangle(Mesh_Algorithm):
                 Vertex can be either a GEOM_Object or a vertex ID within the
                 shape to mesh
              UseExisting: if ==true - searches for the existing hypothesis created with
                 Vertex can be either a GEOM_Object or a vertex ID within the
                 shape to mesh
              UseExisting: if ==true - searches for the existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

         """
         
         return self.QuadrangleParameters(QUAD_STANDARD,vertex,UseExisting)
         """
         
         return self.QuadrangleParameters(QUAD_STANDARD,vertex,UseExisting)


@@ -881,7 +881,7 @@ class StdMeshersBuilder_Hexahedron(Mesh_Algorithm):
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """

-    docHelper  = "Creates hexahedron 3D algorithm for volumes"
+    docHelper  = "Create hexahedron 3D algorithm for volumes"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -921,7 +921,7 @@ class StdMeshersBuilder_Projection1D(Mesh_Algorithm):
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """

-    docHelper  = "Creates projection 1D algorithm for edges"
+    docHelper  = "Create projection 1D algorithm for edges"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -950,7 +950,7 @@ class StdMeshersBuilder_Projection1D(Mesh_Algorithm):
             srcV: a vertex of *edge* to associate with *tgtV* (optional)
             tgtV: a vertex of *the edge* to which the algorithm is assigned, to associate with *srcV* (optional)
             UseExisting: if ==true - searches for the existing hypothesis created with
             srcV: a vertex of *edge* to associate with *tgtV* (optional)
             tgtV: a vertex of *the edge* to which the algorithm is assigned, to associate with *srcV* (optional)
             UseExisting: if ==true - searches for the existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

         """
         from salome.smesh.smeshBuilder import AssureGeomPublished, Mesh
         AssureGeomPublished( self.mesh, edge )
         """
         from salome.smesh.smeshBuilder import AssureGeomPublished, Mesh
         AssureGeomPublished( self.mesh, edge )


@@ -989,7 +989,7 @@ class StdMeshersBuilder_Projection2D(Mesh_Algorithm):
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """

-    docHelper  = "Creates projection 2D algorithm for faces"
+    docHelper  = "Create projection 2D algorithm for faces"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -1061,7 +1061,7 @@ class StdMeshersBuilder_Projection1D2D(StdMeshersBuilder_Projection2D):
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """

-    docHelper  = "Creates projection 1D-2D algorithm for faces"
+    docHelper  = "Create projection 1D-2D algorithm for faces"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -1095,7 +1095,7 @@ class StdMeshersBuilder_Projection3D(Mesh_Algorithm):
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """

-    docHelper  = "Creates projection 3D algorithm for volumes"
+    docHelper  = "Create projection 3D algorithm for volumes"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -1128,7 +1128,7 @@ class StdMeshersBuilder_Projection3D(Mesh_Algorithm):
             srcV2: a vertex of *solid* to associate with *tgtV1* (optional)
             tgtV2: a vertex of *the solid* to which the algorithm is assigned,to associate with *srcV2* (optional)
             UseExisting: if ==true - searches for the existing hypothesis created with
             srcV2: a vertex of *solid* to associate with *tgtV1* (optional)
             tgtV2: a vertex of *the solid* to which the algorithm is assigned,to associate with *srcV2* (optional)
             UseExisting: if ==true - searches for the existing hypothesis created with

-                    the same parameters, else (default) - creates a new one
+                    the same parameters, else (default) - Create a new one

 
         Note: 
             association vertices must belong to one edge of a solid
 
         Note: 
             association vertices must belong to one edge of a solid


@@ -1169,7 +1169,7 @@ class StdMeshersBuilder_Prism3D(Mesh_Algorithm):
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """

-    docHelper  = "Creates prism 3D algorithm for volumes"
+    docHelper  = "Create prism 3D algorithm for volumes"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -1245,7 +1245,7 @@ class StdMeshersBuilder_Prism3D(Mesh_Algorithm):
         Parameters:
             n: number of layers
             UseExisting: if ==true - searches for the existing hypothesis created with
         Parameters:
             n: number of layers
             UseExisting: if ==true - searches for the existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

         """
         if self.algoType != "RadialPrism_3D":
             print("Prism_3D algorithm doesn't support any hypothesis")
         """
         if self.algoType != "RadialPrism_3D":
             print("Prism_3D algorithm doesn't support any hypothesis")


@@ -1381,7 +1381,7 @@ class StdMeshersBuilder_RadialPrism3D(StdMeshersBuilder_Prism3D):
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """

-    docHelper  = "Creates Raial Prism 3D algorithm for volumes"
+    docHelper  = "Create Raial Prism 3D algorithm for volumes"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -1453,7 +1453,7 @@ class StdMeshersBuilder_RadialAlgorithm(Mesh_Algorithm):
         Parameters:
             n: number of layers
             UseExisting: if ==true - searches for the existing hypothesis created with
         Parameters:
             n: number of layers
             UseExisting: if ==true - searches for the existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

         """
         if self.distribHyp:
             self.mesh.GetMesh().RemoveHypothesis( self.geom, self.distribHyp )
         """
         if self.distribHyp:
             self.mesh.GetMesh().RemoveHypothesis( self.geom, self.distribHyp )


@@ -1563,7 +1563,7 @@ class StdMeshersBuilder_RadialQuadrangle1D2D(StdMeshersBuilder_RadialAlgorithm):
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """

-    docHelper  = "Creates quadrangle 1D-2D algorithm for faces having a shape of disk or a disk segment"
+    docHelper  = "Create quadrangle 1D-2D algorithm for faces having a shape of disk or a disk segment"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -1599,7 +1599,7 @@ class StdMeshersBuilder_QuadMA_1D2D(StdMeshersBuilder_RadialAlgorithm):
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """

-    docHelper  = "Creates quadrangle 1D-2D algorithm for faces"
+    docHelper  = "Create quadrangle 1D-2D algorithm for faces"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -1637,7 +1637,7 @@ class StdMeshersBuilder_PolygonPerFace(Mesh_Algorithm):
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """

-    docHelper  = "Creates polygon 2D algorithm for faces"
+    docHelper  = "Create polygon 2D algorithm for faces"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -1677,7 +1677,7 @@ class StdMeshersBuilder_UseExistingElements_1D(Mesh_Algorithm):
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """

-    docHelper  = "Creates 1D algorithm for edges with reusing of existing mesh elements"
+    docHelper  = "Create 1D algorithm for edges with reusing of existing mesh elements"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -1704,7 +1704,7 @@ class StdMeshersBuilder_UseExistingElements_1D(Mesh_Algorithm):
             toCopyMesh: if True, the whole mesh *groups* belong to is imported
             toCopyGroups: if True, all groups of the mesh *groups* belong to are imported
             UseExisting: if ==true - searches for the existing hypothesis created with
             toCopyMesh: if True, the whole mesh *groups* belong to is imported
             toCopyGroups: if True, all groups of the mesh *groups* belong to are imported
             UseExisting: if ==true - searches for the existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

         """
         for group in groups:
             from salome.smesh.smeshBuilder import AssureGeomPublished
         """
         for group in groups:
             from salome.smesh.smeshBuilder import AssureGeomPublished


@@ -1739,7 +1739,7 @@ class StdMeshersBuilder_UseExistingElements_1D2D(Mesh_Algorithm):
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """

-    docHelper  = "Creates 1D-2D algorithm for faces with reusing of existing mesh elements"
+    docHelper  = "Create 1D-2D algorithm for faces with reusing of existing mesh elements"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -1766,7 +1766,7 @@ class StdMeshersBuilder_UseExistingElements_1D2D(Mesh_Algorithm):
             toCopyMesh: if True, the whole mesh *groups* belong to is imported
             toCopyGroups: if True, all groups of the mesh *groups* belong to are imported
             UseExisting: if ==true - searches for the existing hypothesis created with
             toCopyMesh: if True, the whole mesh *groups* belong to is imported
             toCopyGroups: if True, all groups of the mesh *groups* belong to are imported
             UseExisting: if ==true - searches for the existing hypothesis created with

-                the same parameters, else (default) - creates a new one
+                the same parameters, else (default) - Create a new one

         """
         import SMESH
         compFun = lambda hyp, args: ( hyp.GetSourceFaces() == args[0] and \
         """
         import SMESH
         compFun = lambda hyp, args: ( hyp.GetSourceFaces() == args[0] and \


@@ -1802,7 +1802,7 @@ class StdMeshersBuilder_Cartesian_3D(Mesh_Algorithm):
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """
     flag pointing whether this algorithm should be used by default in dynamic method
         of smeshBuilder.Mesh class
     """

-    docHelper  = "Creates Body Fitting 3D algorithm for volumes"
+    docHelper  = "Create Body Fitting 3D algorithm for volumes"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -1959,7 +1959,7 @@ class StdMeshersBuilder_UseExisting_1D(Mesh_Algorithm):
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """

-    docHelper  = "Creates 1D algorithm allowing batch meshing of edges"
+    docHelper  = "Create 1D algorithm allowing batch meshing of edges"

     """
     doc string of the method
     """
     """
     doc string of the method
     """


@@ -1994,7 +1994,7 @@ class StdMeshersBuilder_UseExisting_2D(Mesh_Algorithm):
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """
     """
     type of algorithm used with helper function in smeshBuilder.Mesh class
     """

-    docHelper  = "Creates 2D algorithm allowing batch meshing of faces"
+    docHelper  = "Create 2D algorithm allowing batch meshing of faces"

     """
     doc string of the method
     """
     """
     doc string of the method
     """

diff --git a/src/SMESH_SWIG/smeshBuilder.py b/src/SMESH_SWIG/smeshBuilder.py
index 8b62ca6d2a34bebde51c5c90e858b7840147bbc0..147d8dd9cd7b839156ed410c1611559b1483d893 100644 (file)
--- a/src/SMESH_SWIG/smeshBuilder.py
+++ b/src/SMESH_SWIG/smeshBuilder.py
@@ -1598,7 +1598,7 @@ class Mesh(metaclass = MeshMeta):
 
                    algo1D = mesh.Segment(geom=Edge_1)
 
 
                    algo1D = mesh.Segment(geom=Edge_1)
 

-                creates a sub-mesh on *Edge_1* and assign Wire Discretization algorithm to it.
+                create a sub-mesh on *Edge_1* and assign Wire Discretization algorithm to it.

                 The created sub-mesh can be retrieved from the algorithm::
 
                    submesh = algo1D.GetSubMesh()
                 The created sub-mesh can be retrieved from the algorithm::
 
                    submesh = algo1D.GetSubMesh()


@@ -1628,6 +1628,12 @@ class Mesh(metaclass = MeshMeta):
 
         self.mesh = self.smeshpyD.CreateMesh(geom)
 
 
         self.mesh = self.smeshpyD.CreateMesh(geom)
 

+    def HasShapeToMesh(self):
+        """
+        Return ``True`` if this mesh is based on geometry
+        """
+        return self.mesh.HasShapeToMesh()
+

     def Load(self):
         """
         Load mesh from the study after opening the study
     def Load(self):
         """
         Load mesh from the study after opening the study


@@ -2404,7 +2410,7 @@ class Mesh(metaclass = MeshMeta):
     # ----------------------
     def CreateEmptyGroup(self, elementType, name):
         """
     # ----------------------
     def CreateEmptyGroup(self, elementType, name):
         """

-        Create an empty mesh group
+        Create an empty standalone mesh group

 
         Parameters:
                 elementType: the :class:`type <SMESH.ElementType>` of elements in the group; 
 
         Parameters:
                 elementType: the :class:`type <SMESH.ElementType>` of elements in the group; 


@@ -2439,7 +2445,7 @@ class Mesh(metaclass = MeshMeta):
     def GroupOnGeom(self, grp, name="", typ=None):
         """
         Create a mesh group based on the geometrical object *grp*
     def GroupOnGeom(self, grp, name="", typ=None):
         """
         Create a mesh group based on the geometrical object *grp*

-        and gives a *name*.
+        and give it a *name*.

         if *name* is not defined the name of the geometric group is used
 
         Parameters:
         if *name* is not defined the name of the geometric group is used
 
         Parameters:


@@ -2484,8 +2490,8 @@ class Mesh(metaclass = MeshMeta):
 
     def GroupOnFilter(self, typ, name, filter):
         """
 
     def GroupOnFilter(self, typ, name, filter):
         """

-        Create a mesh group with given *name* based on the *filter* which
-        is a special type of group dynamically updating it's contents during
+        Create a mesh group with given *name* based on the *filter*.
+        It is a special type of group dynamically updating it's contents during

         mesh modification
 
         Parameters:
         mesh modification
 
         Parameters:


@@ -2635,15 +2641,15 @@ class Mesh(metaclass = MeshMeta):
 
     def GetGroups(self, elemType = SMESH.ALL):
         """
 
     def GetGroups(self, elemType = SMESH.ALL):
         """

-        Get the list of groups existing in the mesh in the order
-        of creation (starting from the oldest one)
+        Get the list of groups existing in the mesh in the order of creation 
+        (starting from the oldest one)

 
         Parameters:
                 elemType (SMESH.ElementType): type of elements the groups contain;
                         by default groups of elements of all types are returned
 
         Returns:
 
         Parameters:
                 elemType (SMESH.ElementType): type of elements the groups contain;
                         by default groups of elements of all types are returned
 
         Returns:

-                a sequence of :class:`SMESH.SMESH_GroupBase`
+                a list of :class:`SMESH.SMESH_GroupBase`

         """
 
         groups = self.mesh.GetGroups()
         """
 
         groups = self.mesh.GetGroups()


@@ -3997,7 +4003,7 @@ class Mesh(metaclass = MeshMeta):
 
     def SetNodeOnVertex(self, NodeID, Vertex):
         """
 
     def SetNodeOnVertex(self, NodeID, Vertex):
         """

-        Binds a node to a vertex
+        Bind a node to a vertex

 
         Parameters:
                 NodeID: a node ID
 
         Parameters:
                 NodeID: a node ID


@@ -4020,7 +4026,7 @@ class Mesh(metaclass = MeshMeta):
 
     def SetNodeOnEdge(self, NodeID, Edge, paramOnEdge):
         """
 
     def SetNodeOnEdge(self, NodeID, Edge, paramOnEdge):
         """

-        Stores the node position on an edge
+        Store the node position on an edge

 
         Parameters:
                 NodeID: a node ID
 
         Parameters:
                 NodeID: a node ID


@@ -4043,7 +4049,7 @@ class Mesh(metaclass = MeshMeta):
 
     def SetNodeOnFace(self, NodeID, Face, u, v):
         """
 
     def SetNodeOnFace(self, NodeID, Face, u, v):
         """

-        Stores node position on a face
+        Store node position on a face

 
         Parameters:
                 NodeID: a node ID
 
         Parameters:
                 NodeID: a node ID


@@ -4067,7 +4073,7 @@ class Mesh(metaclass = MeshMeta):
 
     def SetNodeInVolume(self, NodeID, Solid):
         """
 
     def SetNodeInVolume(self, NodeID, Solid):
         """

-        Binds a node to a solid
+        Bind a node to a solid

 
         Parameters:
                 NodeID: a node ID
 
         Parameters:
                 NodeID: a node ID


@@ -6140,7 +6146,7 @@ class Mesh(metaclass = MeshMeta):
 
         return self.editor.FindFreeBorders( ClosedOnly )
 
 
         return self.editor.FindFreeBorders( ClosedOnly )
 

-    def FillHole(self, holeNodes):
+    def FillHole(self, holeNodes, groupName=""):

         """
         Fill with 2D elements a hole defined by a SMESH.FreeBorder.
 
         """
         Fill with 2D elements a hole defined by a SMESH.FreeBorder.
 


@@ -6148,6 +6154,9 @@ class Mesh(metaclass = MeshMeta):
             FreeBorder: either a SMESH.FreeBorder or a list on node IDs. These nodes
                 must describe all sequential nodes of the hole border. The first and the last
                 nodes must be the same. Use :meth:`FindFreeBorders` to get nodes of holes.
             FreeBorder: either a SMESH.FreeBorder or a list on node IDs. These nodes
                 must describe all sequential nodes of the hole border. The first and the last
                 nodes must be the same. Use :meth:`FindFreeBorders` to get nodes of holes.

+            groupName (string): name of a group to add new faces
+        Returns:
+            a :class:`group <SMESH.SMESH_GroupBase>` containing the new faces; or :code:`None` if :option:`groupName` == ""

         """
 
 
         """
 
 


@@ -6155,7 +6164,7 @@ class Mesh(metaclass = MeshMeta):
             holeNodes = SMESH.FreeBorder(nodeIDs=holeNodes)
         if not isinstance( holeNodes, SMESH.FreeBorder ):
             raise TypeError("holeNodes must be either SMESH.FreeBorder or list of integer and not %s" % holeNodes)
             holeNodes = SMESH.FreeBorder(nodeIDs=holeNodes)
         if not isinstance( holeNodes, SMESH.FreeBorder ):
             raise TypeError("holeNodes must be either SMESH.FreeBorder or list of integer and not %s" % holeNodes)

-        self.editor.FillHole( holeNodes )
+        self.editor.FillHole( holeNodes, groupName )

 
     def FindCoincidentFreeBorders (self, tolerance=0.):
         """
 
     def FindCoincidentFreeBorders (self, tolerance=0.):
         """