Merge branch 'master' into gni/evolution

[modules/smesh.git] / doc / salome / examples / use_existing_faces.py

diff --git a/doc/salome/examples/use_existing_faces.py b/doc/salome/examples/use_existing_faces.py
index c4b95fdafd945440e9733368422c9f6c32f90760..0ef132b66f6d5dbb92da95c9c0ed156314d2b64b 100644 (file)
--- a/doc/salome/examples/use_existing_faces.py
+++ b/doc/salome/examples/use_existing_faces.py
@@ -5,33 +5,32 @@ import salome
 salome.salome_init()
 import GEOM
 from salome.geom import geomBuilder
-geompy = geomBuilder.New(salome.myStudy)
+geompy = geomBuilder.New()
 
 import SMESH, SALOMEDS
 from salome.smesh import smeshBuilder
-smesh =  smeshBuilder.New(salome.myStudy)
+smesh =  smeshBuilder.New()
 import salome_notebook
 
-import numpy as np
-
 # define my 2D algorithm
-def my2DMeshing( geomFace ):
+def my2DMeshing(geomFace, geom_builder, smesh_builder):
+    import numpy as np
 
     # find gravity center of geomFace
-    gcXYZ = geompy.PointCoordinates( geompy.MakeCDG( geomFace ))
+    gcXYZ = geom_builder.PointCoordinates( geom_builder.MakeCDG( geomFace ))
 
     # define order and orientation of edges
     sortedEdges = []
-    geomEdges = geompy.SubShapeAll( geomFace, geompy.ShapeType["EDGE"])
+    geomEdges = geom_builder.SubShapeAll( geomFace, geom_builder.ShapeType["EDGE"])
     sortedEdges.append(( geomEdges.pop(0), True ))
     while geomEdges:
         prevEdge_rev = sortedEdges[ -1 ]
-        prevVV = geompy.SubShapeAll( prevEdge_rev[0], geompy.ShapeType["VERTEX"])
+        prevVV = geom_builder.SubShapeAll( prevEdge_rev[0], geom_builder.ShapeType["VERTEX"])
         prevV2 = prevVV[ prevEdge_rev[1] ]
         found = False
         for iE in range( len( geomEdges )):
-            v1,v2 = geompy.SubShapeAll( geomEdges[ iE ], geompy.ShapeType["VERTEX"])
-            same1,same2 = [( geompy.MinDistance( prevV2, v ) < 1e-7 ) for v in [v1,v2] ]
+            v1,v2 = geom_builder.SubShapeAll( geomEdges[ iE ], geom_builder.ShapeType["VERTEX"])
+            same1,same2 = [( geom_builder.MinDistance( prevV2, v ) < 1e-7 ) for v in [v1,v2] ]
             if not same1 and not same2: continue
             sortedEdges.append(( geomEdges.pop( iE ), same1 ))
             found = True
@@ -42,10 +41,10 @@ def my2DMeshing( geomFace ):
     # put nodes on edges in a right order
     nodes = []
     for edge, isForward in sortedEdges:
-        v1,v2 = geompy.SubShapeAll( edge, geompy.ShapeType["VERTEX"])
-        edgeNodes = mesh.GetSubMeshNodesId( v2,   all=False ) + \
-                    mesh.GetSubMeshNodesId( edge, all=False ) + \
-                    mesh.GetSubMeshNodesId( v1,   all=False )
+        v1,v2 = geom_builder.SubShapeAll( edge, geom_builder.ShapeType["VERTEX"])
+        edgeNodes = smesh_builder.GetSubMeshNodesId( v2,   all=False ) + \
+                    smesh_builder.GetSubMeshNodesId( edge, all=False ) + \
+                    smesh_builder.GetSubMeshNodesId( v1,   all=False )
         if not isForward: edgeNodes.reverse()
         nodes.extend( edgeNodes[:-1] )
 
@@ -54,23 +53,23 @@ def my2DMeshing( geomFace ):
     r2 = 1 - r1
     nodesInside = []
     for n in nodes:
-        nXYZ = mesh.GetNodeXYZ( n )
+        nXYZ = smesh_builder.GetNodeXYZ( n )
         newXYZ = np.add( np.multiply( r1, gcXYZ ), np.multiply( r2, nXYZ ))
-        nodesInside.append( mesh.AddNode( newXYZ[0], newXYZ[1], newXYZ[2] ))
-        mesh.SetNodeOnFace( nodesInside[-1], geomFace, 0, 0 )
+        nodesInside.append( smesh_builder.AddNode( newXYZ[0], newXYZ[1], newXYZ[2] ))
+        smesh_builder.SetNodeOnFace( nodesInside[-1], geomFace, 0, 0 )
 
     # find out orientation of faces to create
     #    geomFace normal
-    faceNorm = geompy.GetNormal( geomFace )
-    v1,v2 = [ geompy.PointCoordinates( v ) \
-              for v in geompy.SubShapeAll( faceNorm, geompy.ShapeType["VERTEX"]) ]
+    faceNorm = geom_builder.GetNormal( geomFace )
+    v1,v2 = [ geom_builder.PointCoordinates( v ) \
+              for v in geom_builder.SubShapeAll( faceNorm, geom_builder.ShapeType["VERTEX"]) ]
     faceNormXYZ = np.subtract( v2, v1 )
     outDirXYZ   = np.subtract( v1, [ 50, 50, 50 ] )
     if np.dot( faceNormXYZ, outDirXYZ ) < 0: # reversed face
         faceNormXYZ = np.multiply( -1., faceNormXYZ )
     #   mesh face normal
-    e1 = np.subtract( mesh.GetNodeXYZ( nodes[0] ), mesh.GetNodeXYZ( nodes[1] ))
-    e2 = np.subtract( mesh.GetNodeXYZ( nodes[0] ), mesh.GetNodeXYZ( nodesInside[0] ))
+    e1 = np.subtract( smesh_builder.GetNodeXYZ( nodes[0] ), smesh_builder.GetNodeXYZ( nodes[1] ))
+    e2 = np.subtract( smesh_builder.GetNodeXYZ( nodes[0] ), smesh_builder.GetNodeXYZ( nodesInside[0] ))
     meshNorm = np.cross( e1, e2 )
     #   faces orientation
     reverse = ( np.dot( faceNormXYZ, meshNorm ) < 0 )
@@ -81,16 +80,16 @@ def my2DMeshing( geomFace ):
         n1, n2, n3, n4 = nodes[iN-1], nodes[iN-2], nodesInside[iN-2], nodesInside[iN-1]
         iN -= 1
         if reverse:
-            f = mesh.AddFace( [n1, n2, n3, n4] )
+            f = smesh_builder.AddFace( [n1, n2, n3, n4] )
         else:
-            f = mesh.AddFace( [n4, n3, n2, n1] )
+            f = smesh_builder.AddFace( [n4, n3, n2, n1] )
         # new faces must be assigned to geometry to allow 3D algorithm finding them
-        mesh.SetMeshElementOnShape( f, geomFace )
+        smesh_builder.SetMeshElementOnShape( f, geomFace )
 
     if reverse:
         nodesInside.reverse()
-    polygon = mesh.AddPolygonalFace( nodesInside )
-    mesh.SetMeshElementOnShape( polygon, geomFace )
+    polygon = smesh_builder.AddPolygonalFace( nodesInside )
+    smesh_builder.SetMeshElementOnShape( polygon, geomFace )
 
     return
 
@@ -111,8 +110,8 @@ mesh.Compute()
 mesh.Quadrangle()
 mesh.UseExistingFaces(f1) # UseExistingFaces() allows using my2DMeshing();
 mesh.UseExistingFaces(f2) # assign UseExistingFaces() BEFORE calling my2DMeshing()!
-my2DMeshing( f1 )
-my2DMeshing( f2 )
+my2DMeshing(f1, geom_builder=geompy, smesh_builder=mesh)
+my2DMeshing(f2, geom_builder=geompy, smesh_builder=mesh)
 assert mesh.Compute()
 
 # compute 3D mesh