0020834]: EDF 1362 SMESH : Add a 2D quadrangle mesher of reduced type

Make Mesh_Quadrangle always create QuadranglePreference hyp

src/SMESH_SWIG/smeshDC.py

@@ -50,6 +50,7 @@
 ##     @defgroup l3_hypos_ghs3dh GHS3D Parameters hypothesis
 ##     @defgroup l3_hypos_blsurf BLSURF Parameters hypothesis
 ##     @defgroup l3_hypos_hexotic Hexotic Parameters hypothesis
+##     @defgroup l3_hypos_quad Quadrangle Parameters hypothesis
 ##     @defgroup l3_hypos_additi Additional Hypotheses
 
 ##   @}
@@ -201,6 +202,8 @@ PrecisionConfusion = 1e-07
 # Methods of splitting a hexahedron into tetrahedra
 Hex_5Tet, Hex_6Tet, Hex_24Tet = 1, 2, 3
 
+# import items of enum QuadType
+for e in StdMeshers.QuadType._items: exec('%s = StdMeshers.%s'%(e,e))
 
 ## Converts an angle from degrees to radians
 def DegreesToRadians(AngleInDegrees):
@@ -4693,48 +4696,96 @@ class Mesh_Triangle(Mesh_Algorithm):
 #  @ingroup l3_algos_basic
 class Mesh_Quadrangle(Mesh_Algorithm):
 
+    params=0
+
     ## Private constructor.
     def __init__(self, mesh, geom=0):
         Mesh_Algorithm.__init__(self)
         self.Create(mesh, geom, "Quadrangle_2D")
+        return
 
-    ## Defines "QuadranglePreference" hypothesis, forcing construction
+    ## Defines "QuadrangleParameters" hypothesis
-    #  of quadrangles if the number of nodes on the opposite edges is not the same
+    #  @param quadType defines the algorithm of transition between differently descretized
-    #  while the total number of nodes on edges is even
+    #                  sides of a geometrical face:
-    #
+    #  - QUAD_STANDARD - both triangles and quadrangles are possible in the transition
-    #  @ingroup l3_hypos_additi
+    #                    area along the finer meshed sides. 
-    def QuadranglePreference(self):
+    #  - QUAD_TRIANGLE_PREF - only triangles are built in the transition area along the
-        hyp = self.Hypothesis("QuadranglePreference", UseExisting=1,
+    #                    finer meshed sides.
-                              CompareMethod=self.CompareEqualHyp)
+    #  - QUAD_QUADRANGLE_PREF - only quadrangles are built in the transition area along
-        return hyp
+    #                    the finer meshed sides, iff the total quantity of segments on
+    #                    all four sides of the face is even (divisible by 2).
+    #  - QUAD_QUADRANGLE_PREF_REVERSED - same as QUAD_QUADRANGLE_PREF but the transition
+    #                    area is located along the coarser meshed sides. 
+    #  - QUAD_REDUCED - only quadrangles are built and the transition between the sides
+    #                    is made gradually, layer by layer. This type has a limitation on
+    #                    the number of segments: one pair of opposite sides must have the
+    #                    same number of segments, the other pair must have an even difference
+    #                    between the numbers of segments on the sides.
+    #  @param triangleVertex: vertex of a trilateral geometrical face, around which triangles
+    #                  will be created while other elements will be quadrangles.
+    #                  Vertex can be either a GEOM_Object or a vertex ID within the
+    #                  shape to mesh
+    #  @param UseExisting: if ==true - searches for the existing hypothesis created with
+    #                  the same parameters, else (default) - creates a new one
+    #  @ingroup l3_hypos_quad
+    def QuadrangleParameters(self, quadType=StdMeshers.QUAD_STANDARD, triangleVertex=0, UseExisting=0):
+        vertexID = triangleVertex
+        if isinstance( triangleVertex, geompyDC.GEOM._objref_GEOM_Object ):
+            vertexID = self.mesh.geompyD.GetSubShapeID( self.mesh.geom, triangleVertex )
+        if not self.params:
+            compFun = lambda hyp,args: \
+                hyp.GetQuadType() == args[0] and \
+                ( hyp.GetTriaVertex()==args[1] or ( hyp.GetTriaVertex()<1 and args[1]<1))
+            self.params = self.Hypothesis("QuadrangleParams", [quadType,vertexID],
+                                          UseExisting = UseExisting, CompareMethod=compFun)
+            pass
+        if self.params.GetQuadType() != quadType:
+            self.params.SetQuadType(quadType)
+        if vertexID > 0:
+            self.params.SetTriaVertex( vertexID )
+        return self.params
 
-    ## Defines "TrianglePreference" hypothesis, forcing construction
+    ## Defines "QuadrangleParams" hypothesis with a type of quadrangulation that only
-    #  of triangles in the refinement area if the number of nodes
+    #   quadrangles are built in the transition area along the finer meshed sides,
-    #  on the opposite edges is not the same
+    #   iff the total quantity of segments on all four sides of the face is even.
-    #
+    #  @param reversed if True, transition area is located along the coarser meshed sides.
-    #  @ingroup l3_hypos_additi
+    #  @param UseExisting: if ==true - searches for the existing hypothesis created with
-    def TrianglePreference(self):
+    #                  the same parameters, else (default) - creates a new one
-        hyp = self.Hypothesis("TrianglePreference", UseExisting=1,
+    #  @ingroup l3_hypos_quad
-                              CompareMethod=self.CompareEqualHyp)
+    def QuadranglePreference(self, reversed=False, UseExisting=0):
-        return hyp
+        if reversed:
+            return self.QuadrangleParameters(QUAD_QUADRANGLE_PREF_REVERSED,UseExisting=UseExisting)
+        return self.QuadrangleParameters(QUAD_QUADRANGLE_PREF,UseExisting=UseExisting)
 
-    ## Defines "QuadrangleParams" hypothesis
+    ## Defines "QuadrangleParams" hypothesis with a type of quadrangulation that only
+    #   triangles are built in the transition area along the finer meshed sides.
+    #  @param UseExisting: if ==true - searches for the existing hypothesis created with
+    #                  the same parameters, else (default) - creates a new one
+    #  @ingroup l3_hypos_quad
+    def TrianglePreference(self, UseExisting=0):
+        return self.QuadrangleParameters(QUAD_TRIANGLE_PREF,UseExisting=UseExisting)
+
+    ## Defines "QuadrangleParams" hypothesis with a type of quadrangulation that only
+    #   quadrangles are built and the transition between the sides is made gradually,
+    #   layer by layer. This type has a limitation on the number of segments: one pair
+    #   of opposite sides must have the same number of segments, the other pair must
+    #   have an even difference between the numbers of segments on the sides.
+    #  @param UseExisting: if ==true - searches for the existing hypothesis created with
+    #                  the same parameters, else (default) - creates a new one
+    #  @ingroup l3_hypos_quad
+    def Reduced(self, UseExisting=0):
+        return self.QuadrangleParameters(QUAD_REDUCED,UseExisting=UseExisting)
+
+    ## Defines "QuadrangleParams" hypothesis with QUAD_STANDARD type of quadrangulation
     #  @param vertex: vertex of a trilateral geometrical face, around which triangles
     #                 will be created while other elements will be quadrangles.
     #                 Vertex can be either a GEOM_Object or a vertex ID within the
     #                 shape to mesh
     #  @param UseExisting: if ==true - searches for the existing hypothesis created with
     #                   the same parameters, else (default) - creates a new one
-    #
+    #  @ingroup l3_hypos_quad
-    #  @ingroup l3_hypos_additi
     def TriangleVertex(self, vertex, UseExisting=0):
-        vertexID = vertex
+        return self.QuadrangleParameters(QUAD_STANDARD,vertex,UseExisting)
-        if isinstance( vertexID, geompyDC.GEOM._objref_GEOM_Object ):
-            vertexID = self.mesh.geompyD.GetSubShapeID( self.mesh.geom, vertex )
-        hyp = self.Hypothesis("QuadrangleParams", [vertexID], UseExisting = UseExisting,
-                              CompareMethod=lambda hyp,args: hyp.GetTriaVertex()==args[0])
-        hyp.SetTriaVertex( vertexID )
-        return hyp
 
 
 # Public class: Mesh_Tetrahedron