def test_adj():
mb = core.Core()
coords = np.array((0, 0, 0, 1, 0, 0, 1, 1, 1), dtype='float64')
verts = mb.create_vertices(coords)
#create elements
verts = np.array(((verts[0], verts[1], verts[2]), ), dtype='uint64')
tris = mb.create_elements(types.MBTRI, verts)
#get the adjacencies of the triangle of dim 1 (should return the vertices)
adjs = mb.get_adjacencies(tris, 0, False)
CHECK_EQ(len(adjs), 3)
#check that the entities are of the correct type
for adj in adjs:
type = mb.type_from_handle(adj)
assert type is types.MBVERTEX
#now get the edges and ask MOAB to create them for us
adjs = mb.get_adjacencies(tris, 1, True)
CHECK_EQ(len(adjs), 3)
for adj in adjs:
ent_type = mb.type_from_handle(adj)
CHECK_EQ(ent_type, types.MBEDGE)
adjs = mb.get_adjacencies(tris[0], 0, False)
CHECK_EQ(len(adjs), 3)
def test_get_conn():
mb = core.Core()
coords = np.array((0, 0, 0, 1, 0, 0, 1, 1, 1), dtype='float64')
verts = mb.create_vertices(coords)
#create elements
verts = np.array(((verts[0], verts[1], verts[2]), ), dtype='uint64')
tris = mb.create_elements(types.MBTRI, verts)
#get the adjacencies of the triangle of dim 1 (should return the vertices)
conn = mb.get_connectivity(tris, 0, False)
CHECK_EQ(len(conn), 3)
#check that the entities are of the correct type
for c in conn:
type = mb.type_from_handle(c)
assert type is types.MBVERTEX
conn = mb.get_connectivity(tris[0])
CHECK_EQ(len(conn), 3)
CHECK_EQ(conn, verts)
conn = mb.get_connectivity(Range(tris))
CHECK_EQ(len(conn), 3)
CHECK_EQ(conn, verts)
msh = mb.create_meshset()
try:
mb.get_connectivity(msh)
except IndexError:
pass
else:
print("Shouldn't be here. Test fails.")
raise (IndexErrorx)
def test_unordered_tagging():
mb = core.Core()
# 1-D iterable
coords = [0., 0., 0., 1., 0., 0., 1., 1., 1.]
verts = mb.create_vertices(coords)
CHECK_EQ(len(verts), 3)
# 2-D iterable w/ len 3 entries
coords = [[0., 0., 0.], [1., 0., 0.], [1., 1., 1.]]
verts = mb.create_vertices(coords)
CHECK_EQ(len(verts), 3)
#create a tag
int_tag = mb.tag_get_handle("IntTag", 1, types.MB_TYPE_INTEGER,
types.MB_TAG_DENSE, True)
#try to set data with bad array (contains int)
int_data = [1, 2, 3]
# tag ordered vertices with value
mb.tag_set_data(int_tag, verts, int_data)
reordered_verts = [verts[1], verts[2], verts[0]]
reordered_data = [int_data[1], int_data[2], int_data[0]]
# check that data array is correct for reordered vertex handles
data = mb.tag_get_data(int_tag, reordered_verts)
CHECK_EQ(data, reordered_data)
def test_entity_handle_tags():
# make sure that the root set can be tagged with data
mb = core.Core()
eh_tag = mb.tag_get_handle("Test", 1, types.MB_TYPE_HANDLE,
types.MB_TAG_SPARSE, True)
dbl_tag = mb.tag_get_handle("Dbl", 1, types.MB_TYPE_DOUBLE,
types.MB_TAG_DENSE, True)
meshset_a = mb.create_meshset()
meshset_b = mb.create_meshset()
# tag meshset a with meshset b
mb.tag_set_data(eh_tag, meshset_a, meshset_b)
# tag meshset b with a double value
val = 16.0
mb.tag_set_data(dbl_tag, meshset_b, val)
eh = mb.tag_get_data(eh_tag, meshset_a)
CHECK_EQ(eh, meshset_b)
dbl_val = mb.tag_get_data(dbl_tag, eh)
CHECK_EQ(dbl_val, val)
eh = mb.tag_get_data(eh_tag, meshset_a, flat=True)[0]
CHECK_EQ(eh, meshset_b)
dbl_val = mb.tag_get_data(dbl_tag, eh, flat=True)[0]
CHECK_EQ(dbl_val, val)
def test_get_skin():
mb = core.Core()
rs = mb.get_root_set()
coords = np.array([[0,0,0], [1,0,0], [2,0,0],
[0,1,0], [1,1,0], [2,1,0],
[0,2,0], [1,2,0], [2,2,0]],dtype='float64')
verts = mb.create_vertices(coords)
verts = np.array((verts[0:8]),dtype='uint64')
connect = np.array([[1, 2, 5, 4],
[2, 3, 6, 5],
[4, 5, 8, 7],
[5, 6, 9, 8]],dtype='uint64')
quads = mb.create_elements(types.MBQUAD,connect)
nelems = mb.get_entities_by_dimension(rs, 2)
CHECK_EQ(len(nelems), 4)
mb.write_file('quads_test.vtk')
mskn = skinner.Skinner(mb)
skin_verts = mskn.find_skin(rs, quads, True, False)
CHECK_EQ(len(skin_verts), 8)
skin_edges = mskn.find_skin(rs, quads, False, False)
CHECK_EQ(len(skin_edges), 8)
def test_tag_delete():
mb = core.Core()
vh = vertex_handle(mb)
test_tag = mb.tag_get_handle("Test", 1, types.MB_TYPE_INTEGER, True,
types.MB_TAG_SPARSE)
test_val = 4
test_tag_data = np.array((test_val, ))
mb.tag_set_data(test_tag, vh, test_tag_data)
mb.tag_delete_data(test_tag, vh)
try:
mb.tag_get_data(test_tag, vh)
raised = False
except RuntimeError as e:
er_val = e.args[0].error_value
raised = True
CHECK_EQ(raised, True)
CHECK_EQ(er_val, types.MB_TAG_NOT_FOUND)
mb.tag_delete(test_tag)
try:
mb.tag_get_data(test_tag, vh)
raised = False
except RuntimeError as e:
er_val = e.args[0].error_value
raised = True
CHECK_EQ(raised, True)
CHECK_EQ(er_val, types.MB_TAG_NOT_FOUND)
def test_iterables():
mb = core.Core()
# 1-D iterable
coords = [0., 0., 0., 1., 0., 0., 1., 1., 1.]
verts = mb.create_vertices(coords)
CHECK_EQ(len(verts), 3)
# 2-D iterable w/ len 3 entries
coords = [[0., 0., 0.], [1., 0., 0.], [1., 1., 1.]]
verts = mb.create_vertices(coords)
CHECK_EQ(len(verts), 3)
int_tag = mb.tag_get_handle("IntTag", 1, types.MB_TYPE_INTEGER,
types.MB_TAG_DENSE, True)
#try to set data with bad array (contains int)
int_data = [1, 2, 3.0]
try:
mb.tag_set_data(int_tag, verts, int_data)
except:
pass
else:
print("Shouldn't be here. Test fails.")
raise (AssertionError)
#now set with valid data and check
int_data = [1, 2, 3]
mb.tag_set_data(int_tag, verts, int_data)
return_data = mb.tag_get_data(int_tag, verts)
CHECK_EQ(return_data[0], int_data[0])
CHECK_EQ(return_data[1], int_data[1])
CHECK_EQ(return_data[2], int_data[2])
#insert false vertex handle (not even correct type
verts = [verts[0], 23, verts[1]]
try:
mb.tag_set_data(int_tag, verts, [1, 2, 3])
except:
pass
else:
print("Shouldn't be here. Test fails.")
raise (AssertionError)
#insert correct type, but non-existant handle
verts = [verts[0], int(23), verts[1]]
try:
mb.tag_set_data(int_tag, verts, [1, 2, 3])
except:
pass
else:
print("Shouldn't be here. Test fails.")
raise (AssertionError)
def test_delete_mesh():
mb = core.Core()
mb.create_vertices(np.ones(9))
rs = mb.get_root_set()
ents = mb.get_entities_by_handle(rs)
CHECK_EQ(len(ents), 3)
# now delete all mesh entities
mb.delete_mesh()
ents = mb.get_entities_by_handle(rs)
CHECK_EQ(len(ents), 0)
def test_get_coords():
mb = core.Core()
coords = np.array((0, 0, 0, 1, 0, 0, 1, 1, 1), dtype='float64')
verts = mb.create_vertices(coords)
ret_coords = mb.get_coords(verts)
for i in range(len(coords)):
CHECK_EQ(ret_coords[i], coords[i])
# test for passing entity handle (non-iterable)
ret_coords = mb.get_coords(verts[0])
CHECK_EQ(ret_coords[0], coords[0])
CHECK_EQ(ret_coords[1], coords[1])
CHECK_EQ(ret_coords[2], coords[2])
def test_opaque_tag():
mb = core.Core()
vh = vertex_handle(mb)
tag_length = 6
test_tag = mb.tag_get_handle("Test", tag_length, types.MB_TYPE_OPAQUE,
types.MB_TAG_DENSE, True)
test_val = 'four'
test_tag_data = np.array((test_val, ))
mb.tag_set_data(test_tag, vh, test_tag_data)
data = mb.tag_get_data(test_tag, vh)
CHECK_EQ(len(data), 1)
CHECK_EQ(data.nbytes, tag_length * bytes_per_char_)
CHECK_EQ(data[0], test_val)
def test_create_element_iterable():
mb = core.Core()
coords = np.array((0, 0, 0, 1, 0, 0, 1, 1, 1), dtype='float64')
verts = mb.create_vertices(coords)
CHECK_EQ(3, len(verts))
#create tri using verts as a Range
tris = mb.create_element(types.MBTRI, verts)
#create another with the same vertices but in a list
tri_verts = [verts[0], verts[1], verts[2]]
tris = mb.create_element(types.MBTRI, verts)
#make sure the right number of triangles is in the instance
rs = mb.get_root_set()
all_tris = mb.get_entities_by_type(rs, types.MBTRI)
CHECK_EQ(len(all_tris), 2)
def test_create_elements():
mb = core.Core()
coords = np.array((0, 0, 0, 1, 0, 0, 1, 1, 1), dtype='float64')
verts = mb.create_vertices(coords)
CHECK_EQ(len(verts), 3)
#create elements
verts = np.array(((verts[0], verts[1], verts[2]), ), dtype='uint64')
tris = mb.create_elements(types.MBTRI, verts)
CHECK_EQ(len(tris), 1)
#check that the element is there via GLOBAL_ID tag
global_id_tag = mb.tag_get_handle("GLOBAL_ID", 1, types.MB_TYPE_INTEGER,
types.MB_TAG_DENSE, True)
tri_id = mb.tag_get_data(global_id_tag, tris)
CHECK_EQ(len(tri_id), 1)
CHECK_EQ(tri_id[0], 0)
def test_get_coords():
mb = core.Core()
coords = np.array((0, 0, 0, 1, 0, 0, 1, 1, 1), dtype='float64')
verts = mb.create_vertices(coords)
ret_coords = mb.get_coords(verts)
for i in range(len(coords)):
CHECK_EQ(ret_coords[i], coords[i])
def test_tag_list():
mb = core.Core()
vh = vertex_handle(mb)
tag_length = 6
test_tag = mb.tag_get_handle("Test", tag_length, types.MB_TYPE_OPAQUE,
types.MB_TAG_DENSE, True)
test_val = 'four'
test_tag_data = np.array((test_val, ))
# convert vertex handle Range to a list
vh = list(vh)
mb.tag_set_data(test_tag, vh, test_tag_data)
data = mb.tag_get_data(test_tag, vh)
CHECK_EQ(len(data), 1)
CHECK_EQ(data.nbytes, tag_length)
CHECK_EQ(data[0], test_val)
CHECK_EQ(data.dtype, '|S' + str(tag_length))
def test_tag_root_set():
# make sure that the root set can be tagged with data
mb = core.Core()
test_tag = mb.tag_get_handle("Test", 1, types.MB_TYPE_DOUBLE,
types.MB_TAG_DENSE, True)
root_set = mb.get_root_set()
test_tag_data = np.array((4., ))
mb.tag_set_data(test_tag, root_set, test_tag_data)
data = mb.tag_get_data(test_tag, root_set, flat=True)
CHECK_EQ(len(data), 1)
CHECK_EQ(data[0], test_tag_data[0])
mb.tag_delete_data(test_tag, root_set)
def test_tag_properties():
mb = core.Core()
tag_size = 16
test_tag = mb.tag_get_handle("Test", tag_size, types.MB_TYPE_INTEGER,
types.MB_TAG_DENSE, True)
CHECK_EQ(test_tag.get_length(), tag_size)
def test_get_bridge_adjacencies():
mb = core.Core()
coords = np.array((0,0,0,1,0,0,1,1,1),dtype='float64')
verts = mb.create_vertices(coords)
CHECK_EQ(len(verts), 3)
conn = np.array(((verts[0],verts[1],verts[2]),),dtype='uint64')
tris = mb.create_elements(types.MBTRI, conn)
mtu = topo_util.MeshTopoUtil(mb)
rs = mb.get_root_set()
tris = mb.get_entities_by_dimension(rs, 2)
CHECK_EQ(len(tris), 1)
adj_verts = mtu.get_bridge_adjacencies(tris, 0, 0, 1)
CHECK_ITER_EQ(adj_verts,verts)
def test_get_entities_by_dimension():
mb = core.Core()
coords = np.array((0, 0, 0, 1, 0, 0, 1, 1, 1), dtype='float64')
verts = mb.create_vertices(coords)
rs = mb.get_root_set()
ret_verts = mb.get_entities_by_dimension(rs, 0)
for i in range(len(verts)):
CHECK_EQ(ret_verts[i], verts[i])
def test_meshsets():
mb = core.Core()
parent_set = mb.create_meshset()
for i in range(5):
a = mb.create_meshset()
mb.add_child_meshset(parent_set, a)
children = mb.get_child_meshsets(parent_set)
CHECK_EQ(len(children), 5)
def test_get_entities_by_handle():
mb = core.Core()
coords = np.array((0, 0, 0, 1, 0, 0, 1, 1, 1), dtype='float64')
verts = mb.create_vertices(coords)
ms = mb.create_meshset()
mb.add_entities(ms, verts)
ret_verts = mb.get_entities_by_handle(ms, False)
for i in range(len(verts)):
CHECK_EQ(ret_verts[i], verts[i])
def test_set_coords():
mb = core.Core()
coords = np.array((0, 0, 0, 1, 0, 0, 1, 1, 1), dtype='float64')
verts = mb.create_vertices(coords)
ret_coords = mb.get_coords(verts)
coords += 1.0 # Shift x/y/z coordinates by 1.0
mb.set_coords(verts, coords)
ret_coords2 = mb.get_coords(verts)
for i in range(len(coords)):
CHECK_EQ(ret_coords[i], ret_coords2[i] - 1.0)
def test_get_geometric_skin():
mb = core.Core()
coords = np.array([[0,0,0], [1,0,0], [2,0,0],
[0,1,0], [1,1,0], [2,1,0],
[0,2,0], [1,2,0], [2,2,0]],dtype='float64')
verts = mb.create_vertices(coords)
verts = np.array((verts[0:8]),dtype='uint64')
connect = np.array([[1, 2, 5, 4],
[2, 3, 6, 5],
[4, 5, 8, 7],
[5, 6, 9, 8]],dtype='uint64')
quads = mb.create_elements(types.MBQUAD,connect)
# create a geometric set for the quads
surf_set = mb.create_meshset()
geom_tag = mb.tag_get_handle(types.GEOM_DIMENSION_TAG_NAME,
1,
types.MB_TYPE_INTEGER,
types.MB_TAG_SPARSE,
create_if_missing = True)
mb.tag_set_data(geom_tag, surf_set, 2)
# place 2-D entities in this set
mb.add_entities(surf_set, verts)
mb.add_entities(surf_set, quads)
# create a dummy volume set
vol_set = mb.create_meshset()
mb.tag_set_data(geom_tag, vol_set, 3)
# set surface to volume parent-child relationship
mb.add_parent_meshset(surf_set, vol_set)
mskn = skinner.Skinner(mb)
rs = mb.get_root_set()
skin = mskn.find_geometric_skin(rs)
CHECK_EQ(skin.num_of_type(types.MBVERTEX), 8)
CHECK_EQ(skin.num_of_type(types.MBQUAD), 4)
def test_create_elements_iterable():
mb = core.Core()
#create some vertices for triangle 1
coords1 = np.array((0, 0, 0, 1, 0, 0, 1, 1, 1), dtype='float64')
verts1 = mb.create_vertices(coords1)
CHECK_EQ(len(verts1), 3)
#create some more vertices for triangle 2
coords2 = np.array((1, 2, 3, 4, 5, 6, 1, 1, 1), dtype='float64')
verts2 = mb.create_vertices(coords2)
CHECK_EQ(len(verts2), 3)
tri_verts = [[verts1[0], verts1[1], verts1[2]],
[verts2[0], verts2[1], verts2[2]]]
tris = mb.create_elements(types.MBTRI, tri_verts)
CHECK_EQ(len(tris), 2)
tri_verts = [verts1, verts2]
tris = mb.create_elements(types.MBTRI, tri_verts)
CHECK_EQ(len(tris), 2)
#make sure the right number of triangles is in the instance
rs = mb.get_root_set()
all_tris = mb.get_entities_by_type(rs, types.MBTRI)
CHECK_EQ(len(all_tris), 4)
def test_integer_tag():
mb = core.Core()
vh = vertex_handle(mb)
test_tag = mb.tag_get_handle("Test", 1, types.MB_TYPE_INTEGER,
types.MB_TAG_DENSE, True)
test_val = 4
test_tag_data = np.array((test_val, ))
mb.tag_set_data(test_tag, vh, test_tag_data)
data = mb.tag_get_data(test_tag, vh)
CHECK_EQ(len(data), 1)
CHECK_EQ(data[0], test_val)
CHECK_EQ(data.dtype, 'int32')
#set tag data for single handle (non-iterable)
new_test_value = 36
mb.tag_set_data(test_tag, vh[0], new_test_value)
data = mb.tag_get_data(test_tag, vh[0])
CHECK_EQ(len(data), 1)
CHECK_EQ(new_test_value, data[0])
CHECK_EQ(data.dtype, 'int32')
tags = mb.tag_get_tags_on_entity(vh[0])
assert len(tags) > 0
def evaluate_sequence(box):
bmin = box.box_min()
bmax = box.box_max()
start_vert = box.start_vertex()
CHECK_TYPE(start_vert, _eh_py_type)
for i in range(bmin[0], bmax[0]):
for j in range(bmin[1], bmax[1]):
for k in range(bmin[2], bmax[2]):
#compute value of start vert
this_vert = start_vert + (i - bmin[0]) + (j - bmin[1]) * (
bmax[0] - bmin[0] + 1) + (k - bmin[2]) * (
bmax[1] - bmin[1] + 1) * (bmax[0] - bmin[0] + 1)
temp_vert = box.get_vertex([i, j, k])
CHECK_TYPE(temp_vert, _eh_py_type)
CHECK_EQ(temp_vert, this_vert)
temp_vert2 = box.get_vertex(HomCoord([i, j, k]))
CHECK_TYPE(temp_vert2, _eh_py_type)
CHECK_EQ(temp_vert, this_vert)
CHECK_EQ(box.get_params(this_vert), [i, j, k])
CHECK_EQ(box.contains(i, j, k), True)
start_elem = box.start_element()
CHECK_TYPE(start_elem, _eh_py_type)
for i in range(bmin[0], bmax[0] - 1):
for j in range(bmin[1], bmax[1] - 1):
for k in range(bmin[2], bmax[2] - 1):
#compute value of start elem
this_elem = start_elem + (i - bmin[0]) + (j - bmin[1]) * (
bmax[0] - bmin[0]) + (k - bmin[2]) * (
bmax[1] - bmin[1]) * (bmax[0] - bmin[0])
temp_elem = box.get_element([i, j, k])
CHECK_TYPE(temp_elem, _eh_py_type)
CHECK_EQ(temp_elem, this_elem)
temp_elem2 = box.get_element(HomCoord([i, j, k]))
CHECK_TYPE(temp_elem2, _eh_py_type)
CHECK_EQ(temp_elem, this_elem)
CHECK_EQ(box.get_params(temp_elem), [i, j, k])
CHECK_EQ(box.contains(i, j, k), True)
def test_adj():
mb = core.Core()
coords = np.array((0, 0, 0, 1, 0, 0, 1, 1, 1), dtype='float64')
verts = mb.create_vertices(coords)
#create elements
conn = np.array(((verts[0], verts[1], verts[2]), ), dtype='uint64')
tris = mb.create_elements(types.MBTRI, conn)
#get the adjacencies of the triangle of dim 1 (should return the vertices)
adjs = mb.get_adjacencies(tris, 0, False)
CHECK_EQ(len(adjs), 3)
CHECK(adjs.all_of_type(types.MBVERTEX))
#check that the entities are of the correct type
for adj in adjs:
type = mb.type_from_handle(adj)
assert type is types.MBVERTEX
#now get the edges and ask MOAB to create them for us
adjs = mb.get_adjacencies(tris, 1, True)
CHECK_EQ(len(adjs), 3)
CHECK(adjs.all_of_type(types.MBEDGE))
adjs = mb.get_adjacencies(tris[0], 0, False)
CHECK_EQ(len(adjs), 3)
# create another triangle (with reverse normal)
new_coords = np.array((2, 2, 2, 3, 5, 3), dtype='float64')
new_verts = mb.create_vertices(new_coords)
# create a new triangle that shares a vertex with the first
new_tri_conn = np.array(((verts[2], new_verts[0], new_verts[1]), ),
dtype='uint64')
tris.merge(mb.create_elements(types.MBTRI, new_tri_conn))
# confirm that we can get the adjacency intersection of the two triangles
adjs = mb.get_adjacencies(tris, 0, False)
CHECK_EQ(len(adjs), 1)
CHECK(adjs.all_of_type(types.MBVERTEX))
adjs = mb.get_adjacencies(tris, 1, False)
CHECK_EQ(len(adjs), 0)
CHECK(adjs.all_of_type(types.MBEDGE))
# now check that we can get the union of the two triangle adjacencies
adjs = mb.get_adjacencies(tris, 0, False, types.UNION)
CHECK_EQ(len(adjs), 5)
CHECK(adjs.all_of_type(types.MBVERTEX))
# sanity check for number of edges
adjs = mb.get_adjacencies(tris[1], 1, False, types.UNION)
CHECK_EQ(len(adjs), 0)
def test_set_conn():
mb = core.Core()
coords = np.array((0, 0, 0, 1, 0, 0, 1, 1, 1), dtype='float64')
verts = mb.create_vertices(coords)
#create element
verts = np.array(((verts[0], verts[1], verts[2]), ), dtype='uint64')
tri = mb.create_elements(types.MBTRI, verts)
# make new verts to set new connectivity
verts_new = mb.create_vertices(coords)
mb.set_connectivity(tri[0], verts_new)
# get the adjacencies of the triangle (vertices)
conn = mb.get_connectivity(tri)
# check the returned EHs match the new vertices entity handles
CHECK_EQ(list(conn), list(verts_new))
def test_set_coords():
mb = core.Core()
coords = np.array((0, 0, 0, 1, 0, 0, 1, 1, 1), dtype='float64')
verts = mb.create_vertices(coords)
ret_coords = mb.get_coords(verts)
coords += 1.0 # Shift x/y/z coordinates by 1.0
mb.set_coords(verts, coords)
ret_coords2 = mb.get_coords(verts)
for i in range(len(coords)):
CHECK_EQ(ret_coords[i], ret_coords2[i] - 1.0)
# check that setting with a single eh is ok
coord = np.array((5, 5, 5), dtype='float64')
mb.set_coords(verts[0], coord)
ret_coords3 = mb.get_coords(verts[0])
CHECK_ITER_EQ(ret_coords3, coord)
def test_vec_tags():
mb = core.Core()
coords = np.array((0, 0, 0, 1, 0, 0, 1, 1, 1), dtype='float64')
verts = mb.create_vertices(coords)
int_vec_test_tag = mb.tag_get_handle("IntegerVecTestTag", 3,
types.MB_TYPE_INTEGER,
types.MB_TAG_DENSE, True)
dbl_vec_test_tag = mb.tag_get_handle("DoubleVecTestTag", 3,
types.MB_TYPE_DOUBLE,
types.MB_TAG_DENSE, True)
opaque_vec_test_tag = mb.tag_get_handle("OPTag", 10, types.MB_TYPE_OPAQUE,
types.MB_TAG_DENSE, True)
#should be able to successfully tag using a 2-D array
int_vec_test_tag_values = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
dbl_vec_test_tag_values = np.array([[9.0, 10.0, 11.0], [12.0, 13.0, 14.0],
[15.0, 16.0, 17.0]])
opaque_vec_test_tag_values = np.array([["One"], ["Two"], ["Three"]])
mb.tag_set_data(int_vec_test_tag, verts, int_vec_test_tag_values)
mb.tag_set_data(dbl_vec_test_tag, verts, dbl_vec_test_tag_values)
mb.tag_set_data(opaque_vec_test_tag, verts, opaque_vec_test_tag_values)
#or a 1-D array
int_vec_test_tag_values_flat = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8])
dbl_vec_test_tag_values_flat = np.array(
[9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0])
opaque_vec_test_tag_values_flat = np.array(["One", "Two", "Three"])
mb.tag_set_data(int_vec_test_tag, verts, int_vec_test_tag_values)
mb.tag_set_data(dbl_vec_test_tag, verts, dbl_vec_test_tag_values)
mb.tag_set_data(opaque_vec_test_tag, verts,
opaque_vec_test_tag_values_flat)
#these values should then be able to be retrieved as a 2-D array
returned_int_test_tag_values = mb.tag_get_data(int_vec_test_tag, verts)
CHECK_EQ(returned_int_test_tag_values, int_vec_test_tag_values)
returned_dbl_test_tag_values = mb.tag_get_data(dbl_vec_test_tag, verts)
CHECK_EQ(returned_dbl_test_tag_values, dbl_vec_test_tag_values)
returned_opaque_test_tag_values = mb.tag_get_data(opaque_vec_test_tag,
verts)
CHECK_EQ(returned_opaque_test_tag_values, opaque_vec_test_tag_values)
#or as a 1-D array
returned_int_test_tag_values = mb.tag_get_data(int_vec_test_tag,
verts,
flat=True)
CHECK_EQ(returned_int_test_tag_values, int_vec_test_tag_values_flat)
returned_dbl_test_tag_values = mb.tag_get_data(dbl_vec_test_tag,
verts,
flat=True)
CHECK_EQ(returned_dbl_test_tag_values, dbl_vec_test_tag_values_flat)
returned_opaque_test_tag_values = mb.tag_get_data(opaque_vec_test_tag,
verts,
flat=True)
CHECK_EQ(returned_opaque_test_tag_values, opaque_vec_test_tag_values_flat)
def check_sequence(box, imin, jmin, kmin, imax, jmax, kmax):
bmin = box.box_min()
CHECK_EQ(bmin.i(), imin)
CHECK_EQ(bmin.j(), jmin)
CHECK_EQ(bmin.k(), kmin)
bmax = box.box_max()
CHECK_EQ(bmax.i(), imax)
CHECK_EQ(bmax.j(), jmax)
CHECK_EQ(bmax.k(), kmax)
bsize = box.box_size()
CHECK_EQ((bmax - bmin + HomCoord([1, 1, 1, 0])), bsize)