def test_Box2DQuad(self):
"""
Test a quadrilateral mesh of a simple box.
"""
box = BRepPrimAPI_MakeBox(10, 10, 10).Solid()
gen = SMESH_Gen()
mesh = gen.CreateMesh(0, True)
hyp = NETGENPlugin_SimpleHypothesis_2D(0, 0, gen)
hyp.SetAllowQuadrangles(True)
hyp.SetLocalLength(1.0)
NETGENPlugin_NETGEN_2D(1, 0, gen)
mesh.ShapeToMesh(box)
mesh.AddHypothesis(box, 0)
mesh.AddHypothesis(box, 1)
success = gen.Compute(mesh, box)
self.assertTrue(success)
self.assertEqual(mesh.NbTriangles(), 0)
self.assertEqual(mesh.NbQuadrangles(), 600)
self.assertEqual(mesh.NbNodes(), 602)
def test_LocalEdgeLength(self):
"""
Test a mesh on a box with a local edge length enforced on one edge.
"""
box = BRepPrimAPI_MakeBox(10, 10, 10).Solid()
edge = TopExp_Explorer(box, TopAbs_EDGE).Current()
gen = SMESH_Gen()
mesh = gen.CreateMesh(0, True)
hyp3d = NETGENPlugin_SimpleHypothesis_3D(0, 0, gen)
hyp3d.SetLocalLength(1.0)
NETGENPlugin_NETGEN_2D3D(1, 0, gen)
hyp1d = StdMeshers_LocalLength(2, 0, gen)
hyp1d.SetLength(0.1)
StdMeshers_Regular_1D(3, 0, gen)
mesh.ShapeToMesh(box)
mesh.AddHypothesis(box, 0)
mesh.AddHypothesis(box, 1)
mesh.AddHypothesis(edge, 2)
mesh.AddHypothesis(edge, 3)
success = gen.Compute(mesh, box)
self.assertTrue(success)
self.assertEqual(mesh.NbTetras(), 31547)
self.assertEqual(mesh.NbNodes(), 6205)
def test_Box3D():
"""
Test a tetrahedral mesh of a simple solid box
"""
from OCCT.BRepPrimAPI import BRepPrimAPI_MakeBox
from OCCT.NETGENPlugin import (NETGENPlugin_SimpleHypothesis_3D,
NETGENPlugin_NETGEN_2D3D)
from OCCT.SMESH import SMESH_Gen
box = BRepPrimAPI_MakeBox(10, 10, 10).Solid()
gen = SMESH_Gen()
mesh = gen.CreateMesh(0, True)
hyp = NETGENPlugin_SimpleHypothesis_3D(0, 0, gen)
hyp.SetLocalLength(1.0)
NETGENPlugin_NETGEN_2D3D(1, 0, gen)
mesh.ShapeToMesh(box)
mesh.AddHypothesis(box, 0)
mesh.AddHypothesis(box, 1)
success = gen.Compute(mesh, box)
assert success
assert mesh.NbTetras() == 4767
assert mesh.NbNodes() == 1189
def test_Box3D(self):
"""
Test a tetrahedral mesh of a simple solid box.
"""
box = BRepPrimAPI_MakeBox(10, 10, 10).Solid()
gen = SMESH_Gen()
mesh = gen.CreateMesh(0, True)
hyp = NETGENPlugin_SimpleHypothesis_3D(0, 0, gen)
hyp.SetLocalLength(1.0)
NETGENPlugin_NETGEN_2D3D(1, 0, gen)
mesh.ShapeToMesh(box)
mesh.AddHypothesis(box, 0)
mesh.AddHypothesis(box, 1)
success = gen.Compute(mesh, box)
self.assertTrue(success)
self.assertEqual(mesh.NbTetras(), 4741)
self.assertEqual(mesh.NbNodes(), 1185)
from OCCT.Exchange import ExchangeBasic
from OCCT.Visualization.WxViewer import ViewerWx
fn = './models/shape_names.step'
shape = ExchangeBasic.read_step(fn)
v = ViewerWx()
v.add(shape)
v.start()
gen = SMESH_Gen()
mesh = gen.CreateMesh(0, True)
hyp = NETGENPlugin_SimpleHypothesis_3D(0, 0, gen)
hyp.SetLocalLength(5)
alg = NETGENPlugin_NETGEN_2D3D(1, 0, gen)
mesh.ShapeToMesh(shape)
mesh.AddHypothesis(shape, 0)
mesh.AddHypothesis(shape, 1)
print('Computing mesh...')
done = gen.Compute(mesh, mesh.GetShapeToMesh())
print('done.')
v = ViewerWx()
v.add(mesh)
v.start()
class MeshGen(object):
"""
This class is the primary meshing database for a given instance.
"""
def __init__(self):
self._gen = SMESH_Gen()
@property
def object(self):
"""
:return: The underlying mesh object.
:rtype: OCCT.SMESH.SMESH_Gen
"""
return self._gen
@classmethod
def wrap(cls, gen):
"""
Create a new instance using an existing SMESH_Gen instance.
:param OCCT.SMESH.SMESH_Gen gen: A SMESH_Gen instance.
:return: The new instance.
:rtype: afem.smesh.entities.MeshGen
"""
new_gen = cls.__new__(cls)
new_gen._gen = gen
return new_gen
def new_id(self):
"""
Generate a new unique ID within this generator.
:return: A new unique ID.
:rtype: int
"""
return self._gen.GetANewId()
def create_mesh(self, shape=None, is_embedded=False):
"""
Create a mesh.
:param afem.topology.entities.Shape shape: The shape to mesh.
:param bool is_embedded: Option for embedding mesh.
:return: The mesh.
:rtype: afem.smesh.entities.Mesh
"""
the_mesh = Mesh(self, is_embedded)
if shape is not None:
the_mesh.shape_to_mesh(shape)
return the_mesh
def check_algo_state(self, mesh, shape):
"""
Check if computation would fail because of some bad algorithm state.
:param afem.smesh.entities.Mesh mesh: A mesh.
:param afem.topology.entities.Shape shape: A shape.
:return: *True* if ok, *False* if not.
:rtype: bool
"""
return self._gen.CheckAlgoState(mesh.object, shape.object)
def compute(self, mesh, shape=None):
"""
Compute a mesh on a shape.
:param afem.smesh.entities.Mesh mesh: A mesh.
:param afem.topology.entities.Shape shape: The shape to compute mesh
on. If not provided then the shape associated to the mesh is used.
:return: *True* if computed, *False* if not.
:rtype: bool
:raise ValueError: If no shape is available to apply the hypothesis to.
"""
if shape is None:
if mesh.has_shape:
shape = mesh.shape
else:
raise ValueError('No shape could be found.')
return self._gen.Compute(mesh.object, shape.object)
a3dHypothesis = StdMeshers_Prism_3D(4, 0, aMeshGen) #OK
#Calculate mesh
aMesh.ShapeToMesh(aShape)
#Assign hyptothesis to mesh
aMesh.AddHypothesis(aShape, 0)
aMesh.AddHypothesis(aShape, 1)
aMesh.AddHypothesis(aShape, 2)
aMesh.AddHypothesis(aShape, 3)
aMesh.AddHypothesis(aShape, 4)
print('Done.')
#Compute the data
print('Computing mesh ...', end='')
aMeshGen.Compute(aMesh, aMesh.GetShapeToMesh())
print('Done.')
print(aMesh.NbNodes())
# Display the data
aDS = SMESH_MeshVSLink(aMesh)
aMeshVS = MeshVS_Mesh(True)
DMF = 1 # to wrap!
MeshVS_BP_Mesh = 5 # To wrap!
aPrsBuilder = MeshVS_MeshPrsBuilder(aMeshVS, DMF, aDS, 0, MeshVS_BP_Mesh)
aMeshVS.SetDataSource(aDS)
aMeshVS.AddBuilder(aPrsBuilder, True)
context = display.Context
context.Display(aMeshVS)
context.Deactivate(aMeshVS)
display.FitAll()
