def test_face_polygons_exception():
datasets = {}
tri_verts = [[0, 0], [1, 0], [-0.5, 3**0.5 / 2], [-0.5, -3**0.5 / 2]]
tri_edges_valid = [[0, 1, 0], [1, 2, 0], [2, 0, 0], [0, 3, 1], [3, 1, 1],
[1, 0, 1], [0, 2, 2], [2, 3, 2], [3, 0, 2]]
tri_edges_invalid = [[0, 1, 0], [1, 2, 0], [2, 0, 0], [0, 3, 1], [3, 1, 1],
[1, 0, 1], [0, 2, 2], [2, 3, 2],
[3, 1, 2]] # changed 0 to 1 to create an invalid face
datasets['edge'] = pd.DataFrame(data=np.array(tri_edges_valid),
columns=['srce', 'trgt', 'face'])
datasets['edge'].index.name = 'edge'
datasets['face'] = pd.DataFrame(data=np.zeros((3, 2)), columns=['x', 'y'])
datasets['face'].index.name = 'face'
datasets['vert'] = pd.DataFrame(data=np.array(tri_verts),
columns=['x', 'y'])
datasets['vert'].index.name = 'vert'
specs = config.geometry.planar_spec()
eptm = Epithelium('valid', datasets, specs, coords=['x', 'y'])
PlanarGeometry.update_all(eptm)
eptm.face_polygons(['x', 'y'])
def test_vertex_mesh():
datasets = {}
tri_verts = [[0, 0, 0], [1, 0, 0], [-0.5, 0.86, 1.0], [-0.5, -0.86, 1.0]]
tri_edges = [
[0, 1, 0, 0],
[1, 2, 0, 0],
[2, 0, 0, 0],
[0, 3, 1, 0],
[3, 1, 1, 0],
[1, 0, 1, 0],
[0, 2, 2, 0],
[2, 3, 2, 0],
[3, 0, 2, 0],
]
datasets["edge"] = pd.DataFrame(data=np.array(tri_edges),
columns=["srce", "trgt", "face", "cell"])
datasets["edge"].index.name = "edge"
datasets["face"] = pd.DataFrame(data=np.zeros((3, 3)),
columns=["x", "y", "z"])
datasets["face"].index.name = "face"
datasets["vert"] = pd.DataFrame(data=np.array(tri_verts),
columns=["x", "y", "z"])
datasets["vert"].index.name = "vert"
specs = config.geometry.flat_sheet()
eptm = Epithelium("vertex_mesh", datasets, specs, coords=["x", "y", "z"])
SheetGeometry.update_all(eptm)
# tested method
res_verts, res_faces, res_normals = eptm.vertex_mesh(["x", "y", "z"])
res_xy_verts, res_xy_faces = eptm.vertex_mesh(["x", "y", "z"],
vertex_normals=False)
res_faces = list(res_faces)
expected_faces = [[0, 1, 2], [0, 3, 1], [0, 2, 3]]
# floating point precision might causes issues here
# when comparing arrays ... there seems to be
# a built-in 1e-10 tolerance in
# the assert_array_equal function.
expected_normals = np.array([
[1.911111111e-01, 9.25185854e-18, 2.866666667e-01],
[-4.16333634e-17, 0.0, 2.866666667e-01],
[2.866666667e-01, -1.666666667e-01, 2.866666667e-01],
[2.866666667e-01, 1.666666667e-01, 2.866666667e-01],
])
assert_array_equal(res_verts, np.array(tri_verts))
assert all([
res_faces[i] == expected_faces[i] for i in range(len(expected_faces))
])
assert_array_equal(np.round(res_normals, decimals=6),
np.round(expected_normals, decimals=6))
def test_eptm_copy():
datasets, specs = three_faces_sheet()
eptm = Epithelium("3faces_2D", datasets)
eptm_copy = eptm.copy()
assert eptm_copy.identifier == eptm.identifier + "_copy"
assert set(eptm_copy.datasets.keys()).issuperset(eptm.datasets.keys())
eptm_deepcopy = eptm.copy(deep_copy=True)
assert eptm_deepcopy is not None
def test_3d_eptm_cell_getter_setter():
datasets_2d, specs = three_faces_sheet()
datasets = extrude(datasets_2d)
eptm = Epithelium("3faces_3D", datasets)
assert eptm.cell_df is not None
datasets_3d = extrude(datasets_2d, method="translation")
eptm.cell_df = datasets_3d["cell"]
for key in eptm.cell_df:
assert key in datasets_3d["cell"]
def test_upcast():
datasets_2d, specs = three_faces_sheet(zaxis=True)
datasets = extrude(datasets_2d)
eptm = Epithelium('3faces_3D', datasets, specs)
eptm_2d = Epithelium('3faces_2D', datasets_2d, specs)
expected_res = datasets['vert'].loc[eptm.e_cell_idx]
expected_res.index = eptm.edge_df.index
assert_array_equal(expected_res, eptm.upcast_cell(datasets['vert']))
def test_number_getters():
datasets_2d, specs = three_faces_sheet(zaxis=True)
datasets = extrude(datasets_2d)
eptm = Epithelium('3faces_3D', datasets, specs)
eptm_2d = Epithelium('3faces_2D', datasets_2d, specs)
assert eptm.Nc == datasets['cell'].shape[0]
assert eptm.Nv == datasets['vert'].shape[0]
assert eptm.Nf == datasets['face'].shape[0]
assert eptm.Ne == datasets['edge'].shape[0]
def test_get_simple_index():
tri_face = Epithelium("3", *three_faces_sheet())
idx = get_simple_index(tri_face.edge_df)
assert idx.shape == (15, )
datasets_2d, specs = three_faces_sheet(zaxis=True)
datasets = extrude(datasets_2d, scale=1 / 3.0)
eptm = Epithelium("3faces_3D", datasets, specs)
idx = get_simple_index(eptm.edge_df)
assert idx.shape == (43, )
def test_summation():
datasets_2d, specs = three_faces_sheet(zaxis=True)
datasets = extrude(datasets_2d)
eptm = Epithelium('3faces_3D', datasets, specs)
eptm_2d = Epithelium('3faces_2D', datasets_2d, specs)
edge_copy = datasets['edge'].copy()
edge_copy.index = eptm.edge_mindex
assert_array_equal(edge_copy.sum(level='cell'),
eptm.sum_cell(eptm.edge_df))
eptm_2d.edge_df['test_sum'] = np.linspace(1, eptm_2d.Ne, eptm_2d.Ne)
res_sum_srce = eptm_2d.sum_srce(eptm_2d.edge_df['test_sum'])
expected_sum_srce = pd.Series([
21.0, 20.0, 3.0, 4.0, 5.0, 14.0, 9.0, 10.0, 11.0, 26.0, 15.0, 16.0,
17.0
])
res_sum_trgt = eptm_2d.sum_trgt(eptm_2d.edge_df['test_sum'])
expected_sum_trgt = pd.Series([
36.0, 18.0, 2.0, 3.0, 4.0, 12.0, 8.0, 9.0, 10.0, 24.0, 14.0, 15.0, 16.0
])
res_sum_face = eptm_2d.sum_face(eptm_2d.edge_df['test_sum'])
expected_sum_face = pd.Series([21.0, 57.0, 93.0])
assert (expected_sum_srce == res_sum_srce).all()
assert (expected_sum_trgt == res_sum_trgt).all()
assert (expected_sum_face == res_sum_face).all()
def test_orbits():
datasets_2d, specs = three_faces_sheet(zaxis=True)
datasets = extrude(datasets_2d)
eptm = Epithelium("3faces_3D", datasets, specs)
expected_res_cell = datasets["edge"].groupby("srce").apply(
lambda df: df["cell"])
expected_res_face = datasets["edge"].groupby("face").apply(
lambda df: df["trgt"])
assert_array_equal(expected_res_cell, eptm.get_orbits("srce", "cell"))
assert_array_equal(expected_res_face, eptm.get_orbits("face", "trgt"))
def test_settings_getter_setter():
datasets, specs = three_faces_sheet()
eptm = Epithelium("3faces_2D", datasets)
eptm.settings["settings1"] = 154
# not validated in coverage
# (Actually the 'settings' getter is called
# and then the dictionary class setter
# instead of directly the 'settings' setter.)
# See http://stackoverflow.com/a/3137768
assert "settings1" in eptm.settings
assert eptm.specs["settings"]["settings1"] == 154
assert eptm.settings["settings1"] == 154
def test_orbits():
datasets_2d, specs = three_faces_sheet(zaxis=True)
datasets = extrude(datasets_2d)
eptm = Epithelium('3faces_3D', datasets, specs)
eptm_2d = Epithelium('3faces_2D', datasets_2d, specs)
expected_res_cell = datasets['edge'].groupby('srce').apply(
lambda df: df['cell'])
expected_res_face = datasets['edge'].groupby('face').apply(
lambda df: df['trgt'])
assert_array_equal(expected_res_cell, eptm.get_orbits('srce', 'cell'))
assert_array_equal(expected_res_face, eptm.get_orbits('face', 'trgt'))
def test_get_next_edges():
tri_face = Epithelium("3", *three_faces_sheet())
prev = get_next_edges(tri_face).values
expected = np.array(
[1, 2, 3, 4, 5, 0, 7, 8, 9, 10, 11, 6, 13, 14, 15, 16, 17, 12])
assert_array_equal(prev, expected)
def test_ordered_edges():
# test _ordered_edges
# also test ordered_vert_idxs
datasets, specs = three_faces_sheet(zaxis=True)
eptm = Epithelium("ordered_index", datasets, specs)
res_edges_2d = _ordered_edges(eptm.edge_df.loc[eptm.edge_df["face"] == 0])
expected_edges_2d = [
[0, 1, 0],
[1, 2, 0],
[2, 3, 0],
[3, 4, 0],
[4, 5, 0],
[5, 0, 0],
]
expected_vert_idxs = [idxs[0] for idxs in expected_edges_2d]
assert res_edges_2d == expected_edges_2d
assert expected_vert_idxs == _ordered_vert_idxs(
eptm.edge_df.loc[eptm.edge_df["face"] == 0])
res_invalid_face = _ordered_vert_idxs(
eptm.edge_df.loc[eptm.edge_df["face"] == 98765])
# testing the exception case in ordered_vert_idxs :
res_invalid_face = _ordered_vert_idxs(
eptm.edge_df.loc[eptm.edge_df["face"] == 98765])
assert np.isnan(res_invalid_face)
def test_wrong_datasets_keys():
datasets, specs = three_faces_sheet()
datasets['edges'] = datasets['edge']
del datasets['edge']
with raises(ValueError,
message='Expecting a ValueError since edge not in datasets'):
eptm = Epithelium('3faces_2D', datasets, specs)
def test_optional_args_eptm():
datasets, specs = three_faces_sheet()
data_names = set(datasets.keys())
eptm = Epithelium("3faces_2D", datasets)
specs_names = set(eptm.specs.keys())
assert specs_names.issuperset(data_names)
assert "settings" in specs_names
def test_scale():
datasets_2d, specs = three_faces_sheet(zaxis=True)
datasets = extrude(datasets_2d, method='translation')
initial_cell_df = pd.DataFrame.from_dict({'cell':[0,1,2],\
'x':[0.5, -1.0, 0.5],\
'y':[8.660000e-01,-6.167906e-18,-8.6600000e-01],\
'z':[-0.5, -0.5, -0.5],\
'is_alive':[True, True, True],
'num_faces':[8,8,8],
'vol':[2.598,2.598,2.598]}).set_index('cell')
x10_cell_df = pd.DataFrame.from_dict({'cell':[0,1,2],\
'x':[5., -10.0, 5.],\
'y':[8.660000e+00,-6.167906e-17,-8.6600000e+00],\
'z':[-5., -5., -5.],\
'is_alive':[True, True, True],
'num_faces':[8,8,8],
'vol':[2.598,2.598,2.598]}).set_index('cell')
eptm = Epithelium('test_volume',datasets, specs, coords=['x','y','z'])
BulkGeometry.update_all(eptm)
scale(eptm, delta = 10.0, coords= ['x','y','z'])
tolerance = 1e-16
assert all( (x10_cell_df[['x','y','z']] - eptm.cell_df[['x', 'y', 'z']])**2 < 1e-16)
def test_wrong_datasets_keys():
datasets, specs = three_faces_sheet()
datasets["edges"] = datasets["edge"]
del datasets["edge"]
with raises(ValueError,
message="Expecting a ValueError since edge not in datasets"):
eptm = Epithelium("3faces_2D", datasets, specs)
def test_number_getters():
datasets_2d, specs = three_faces_sheet(zaxis=True)
datasets = extrude(datasets_2d)
eptm = Epithelium("3faces_3D", datasets, specs)
assert eptm.Nc == datasets["cell"].shape[0]
assert eptm.Nv == datasets["vert"].shape[0]
assert eptm.Nf == datasets["face"].shape[0]
assert eptm.Ne == datasets["edge"].shape[0]
def test_face_polygons_exception():
datasets = {}
tri_verts = [[0, 0], [1, 0], [-0.5, 3**0.5 / 2], [-0.5, -3**0.5 / 2]]
tri_edges_valid = [
[0, 1, 0],
[1, 2, 0],
[2, 0, 0],
[0, 3, 1],
[3, 1, 1],
[1, 0, 1],
[0, 2, 2],
[2, 3, 2],
[3, 0, 2],
]
tri_edges_invalid = [
[0, 1, 0],
[1, 2, 0],
[2, 0, 0],
[0, 3, 1],
[3, 1, 1],
[1, 0, 1],
[0, 2, 2],
[2, 3, 2],
[3, 1, 2],
] # changed 0 to 1 to create an invalid face
datasets["edge"] = pd.DataFrame(data=np.array(tri_edges_valid),
columns=["srce", "trgt", "face"])
datasets["edge"].index.name = "edge"
datasets["face"] = pd.DataFrame(data=np.zeros((3, 2)), columns=["x", "y"])
datasets["face"].index.name = "face"
datasets["vert"] = pd.DataFrame(data=np.array(tri_verts),
columns=["x", "y"])
datasets["vert"].index.name = "vert"
specs = config.geometry.planar_spec()
eptm = Epithelium("valid", datasets, specs, coords=["x", "y"])
PlanarGeometry.update_all(eptm)
eptm.face_polygons(["x", "y"])
def test_extra_indices():
datasets = {}
tri_verts = [[0, 0], [1, 0], [-0.5, 3**0.5 / 2], [-0.5, -3**0.5 / 2]]
tri_edges = [[0, 1, 0], [1, 2, 0], [2, 0, 0], [0, 3, 1], [3, 1, 1],
[1, 0, 1], [0, 2, 2], [2, 3, 2], [3, 0, 2]]
datasets['edge'] = pd.DataFrame(data=np.array(tri_edges),
columns=['srce', 'trgt', 'face'])
datasets['edge'].index.name = 'edge'
datasets['face'] = pd.DataFrame(data=np.zeros((3, 2)), columns=['x', 'y'])
datasets['face'].index.name = 'face'
datasets['vert'] = pd.DataFrame(data=np.array(tri_verts),
columns=['x', 'y'])
datasets['vert'].index.name = 'vert'
specs = config.geometry.planar_spec()
eptm = Epithelium('extra', datasets, specs, coords=['x', 'y'])
PlanarGeometry.update_all(eptm)
eptm.edge_df['opposite'] = get_opposite(eptm.edge_df)
eptm.get_extra_indices()
assert (2 * eptm.Ni + eptm.No) == eptm.Ne
assert eptm.west_edges.size == eptm.Ni
assert eptm.Nd == 2 * eptm.Ni
for edge in eptm.free_edges:
opps = eptm.edge_df[eptm.edge_df['srce'] == eptm.edge_df.loc[
edge, 'trgt']]['trgt']
assert eptm.edge_df.loc[edge, 'srce'] not in opps
for edge in eptm.east_edges:
srce, trgt = eptm.edge_df.loc[edge, ['srce', 'trgt']]
opp = eptm.edge_df[(eptm.edge_df['srce'] == trgt)
& (eptm.edge_df['trgt'] == srce)].index
assert opp[0] in eptm.west_edges
for edge in eptm.west_edges:
srce, trgt = eptm.edge_df.loc[edge, ['srce', 'trgt']]
opp = eptm.edge_df[(eptm.edge_df['srce'] == trgt)
& (eptm.edge_df['trgt'] == srce)].index
assert opp[0] in eptm.east_edges
def test_update_rank():
sheet = Sheet("3", *three_faces_sheet())
sheet.update_rank()
np.testing.assert_array_equal(
np.array([3, 3, 2, 2, 2, 3, 2, 2, 2, 3, 2, 2, 2]),
sheet.vert_df["rank"])
mono = Epithelium("3", extrude(sheet.datasets))
mono.update_rank()
mono.vert_df["rank"].values
np.testing.assert_array_equal(
np.array([
4,
4,
3,
3,
3,
4,
3,
3,
3,
4,
3,
3,
3,
4,
4,
3,
3,
3,
4,
3,
3,
3,
4,
3,
3,
3,
]),
mono.vert_df["rank"].values,
)
def test_face_projected_pos():
datasets = {}
tri_verts = [[0, 0], [1, 0], [-0.5, 0.75], [-0.5, -0.75]]
tri_edges = [
[0, 1, 0],
[1, 2, 0],
[2, 0, 0],
[0, 3, 1],
[3, 1, 1],
[1, 0, 1],
[0, 2, 2],
[2, 3, 2],
[3, 0, 2],
]
datasets["edge"] = pd.DataFrame(
data=np.array(tri_edges), columns=["srce", "trgt", "face"]
)
datasets["edge"].index.name = "edge"
datasets["face"] = pd.DataFrame(data=np.zeros((3, 2)), columns=["x", "y"])
datasets["face"].index.name = "face"
datasets["vert"] = pd.DataFrame(data=np.array(tri_verts), columns=["x", "y"])
datasets["vert"].index.name = "vert"
specs = config.geometry.planar_spec()
eptm = Epithelium("extra", datasets, specs, coords=["x", "y"])
PlanarGeometry.update_all(eptm)
res_rot_pos_pi2 = PlanarGeometry.face_projected_pos(eptm, 0, pi / 2.0)
res_rot_pos_face1_2pi = PlanarGeometry.face_projected_pos(eptm, 1, 2.0 * pi)
expected_rot_pos_pi2 = pd.DataFrame.from_dict(
{
"vert": [0, 1, 2, 3],
"x": [0.25, 0.25, -0.5, 1.0],
"y": [-0.166667, 0.8333333, -0.666667, -0.666667],
}
).set_index("vert")
expected_rot_pos_face1_2pi = pd.DataFrame.from_dict(
{
"vert": [0, 1, 2, 3],
"x": [-0.166667, 0.833333, -0.666667, -0.666667],
"y": [0.25, 0.25, 1.00, -0.5],
}
).set_index("vert")
tolerance = 1e-16
assert all((expected_rot_pos_pi2 - res_rot_pos_pi2) ** 2 < tolerance)
assert all((expected_rot_pos_face1_2pi - res_rot_pos_face1_2pi) ** 2 < tolerance)
def test_bulk_update_vol():
datasets_2d, specs = three_faces_sheet(zaxis=True)
datasets = extrude(datasets_2d, method='translation')
eptm = Epithelium('test_volume',datasets, specs, coords=['x','y','z'])
BulkGeometry.update_all(eptm)
expected_cell_df = pd.DataFrame.from_dict({'cell':[0,1,2],\
'x':[0.5, -1.0, 0.5],\
'y':[8.660000e-01,-6.167906e-18,-8.6600000e-01],\
'z':[-0.5, -0.5, -0.5],\
'is_alive':[True, True, True],
'num_faces':[8,8,8],
'vol':[2.598,2.598,2.598]}).set_index('cell')
expected_face_centroids = pd.DataFrame.from_dict({'face':list(range(24)),\
'x':[0.5, -1.0, 0.5, 0.5, -1.0, 0.5, 0.5,\
1.25, 1.25, 0.5, -0.25, -0.25, \
-0.25, -1.0, -1.75, -1.75, -1.0, \
-0.25, -0.25, -0.25, 0.5, 1.25, \
1.25, 0.5],\
'y':[0.86599999999999999, 0.0,\
-0.86599999999999999, \
0.86599999999999999, 0.0,\
-0.86599999999999999, 0.0, 0.433,\
1.2989999999999999, 1.732,\
1.2989999999999999, 0.433, 0.433,\
0.86599999999999999, 0.433, -0.433,\
-0.86599999999999999, -0.433, -0.433,\
-1.2989999999999999, -1.732, \
-1.2989999999999999, -0.433, 0.0],\
'z':[0.0, 0.0, 0.0, -1.0, -1.0, -1.0, \
-0.5, -0.5, -0.5, -0.5, -0.5, \
-0.5, -0.5, -0.5, -0.5, -0.5, \
-0.5, -0.5, -0.5, -0.5, -0.5, \
-0.5, -0.5, -0.5]}).set_index('face')
## only update class methods in BulkGeometry : update_vol, update_centroids
tolerance = 1e-16
## check volumes
assert all( (expected_cell_df['vol'] - eptm.cell_df['vol'])**2 < tolerance)
## check centroids
assert all( (expected_face_centroids - eptm.face_df.loc[:, ['x','y','z']])**2 < tolerance )
def test_sort_eastwest():
datasets = {}
tri_verts = [[0, 0], [1, 0], [-0.5, 3**0.5 / 2], [-0.5, -3**0.5 / 2]]
tri_edges = [[0, 1, 0], [1, 2, 0], [2, 0, 0], [0, 3, 1], [3, 1, 1],
[1, 0, 1], [0, 2, 2], [2, 3, 2], [3, 0, 2]]
datasets['edge'] = pd.DataFrame(data=np.array(tri_edges),
columns=['srce', 'trgt', 'face'])
datasets['edge'].index.name = 'edge'
datasets['face'] = pd.DataFrame(data=np.zeros((3, 2)), columns=['x', 'y'])
datasets['face'].index.name = 'face'
datasets['vert'] = pd.DataFrame(data=np.array(tri_verts),
columns=['x', 'y'])
datasets['vert'].index.name = 'vert'
specs = config.geometry.planar_spec()
eptm = Epithelium('extra', datasets, specs, coords=['x', 'y'])
PlanarGeometry.update_all(eptm)
eptm.edge_df['opposite'] = get_opposite(eptm.edge_df)
eptm.sort_edges_eastwest()
assert_array_equal(np.asarray(eptm.free_edges), [0, 1, 2])
assert_array_equal(np.asarray(eptm.east_edges), [3, 4, 5])
assert_array_equal(np.asarray(eptm.west_edges), [6, 7, 8])
def test_idx_getters():
datasets_2d, specs = three_faces_sheet()
datasets = extrude(datasets_2d)
eptm = Epithelium('3faces_3D', datasets)
#assert len(eptm.edge_idx.difference(datasets['edge'].index)) == 0
assert len(eptm.face_idx.difference(datasets['face'].index)) == 0
assert len(eptm.vert_idx.difference(datasets['vert'].index)) == 0
assert len(eptm.cell_idx.difference(datasets['cell'].index)) == 0
assert len(eptm.e_cell_idx.index.difference(
datasets['edge']['cell'].index)) == 0
edge_idx_array = np.vstack((datasets['edge']['srce'],\
datasets['edge']['trgt'],\
datasets['edge']['face'])).T
assert_array_equal(eptm.edge_idx_array, edge_idx_array)
def test_face_projected_pos():
datasets = {}
tri_verts = [[0, 0],
[1, 0],
[-0.5, 0.75],
[-0.5, -0.75]]
tri_edges = [[0, 1, 0],
[1, 2, 0],
[2, 0, 0],
[0, 3, 1],
[3, 1, 1],
[1, 0, 1],
[0, 2, 2],
[2, 3, 2],
[3, 0, 2]]
datasets['edge'] = pd.DataFrame(data=np.array(tri_edges),
columns=['srce', 'trgt', 'face'])
datasets['edge'].index.name = 'edge'
datasets['face'] = pd.DataFrame(data=np.zeros((3, 2)),
columns=['x', 'y'])
datasets['face'].index.name = 'face'
datasets['vert'] = pd.DataFrame(data=np.array(tri_verts),
columns=['x', 'y'])
datasets['vert'].index.name = 'vert'
specs = config.geometry.planar_spec()
eptm = Epithelium('extra', datasets, specs, coords=['x', 'y'])
PlanarGeometry.update_all(eptm)
res_rot_pos_pi2 = PlanarGeometry.face_projected_pos(eptm, 0, pi/2.)
res_rot_pos_face1_2pi = PlanarGeometry.face_projected_pos(eptm, 1, 2.*pi)
expected_rot_pos_pi2 = pd.DataFrame.from_dict({'vert':[0,1,2,3],\
'x':[0.25, 0.25, -0.5, 1.0],\
'y':[-0.166667, 0.8333333, -0.666667,\
-0.666667]}).set_index('vert')
expected_rot_pos_face1_2pi = pd.DataFrame.from_dict({'vert':[0,1,2,3],\
'x':[-0.166667, 0.833333, -0.666667, -0.666667],\
'y':[0.25,0.25,1.00,-0.5]}).set_index('vert')
tolerance = 1e-16
assert all( (expected_rot_pos_pi2 - res_rot_pos_pi2)**2 < tolerance )
assert all( (expected_rot_pos_face1_2pi - res_rot_pos_face1_2pi)**2 < tolerance )
def test_update():
datasets_2d, specs = three_faces_sheet(zaxis=True)
datasets = extrude(datasets_2d, method='translation')
initial_cell_df = pd.DataFrame.from_dict({'cell':[0,1,2],\
'x':[0.5, -1.0, 0.5],\
'y':[8.660000e-01,-6.167906e-18,-8.6600000e-01],\
'z':[-0.5, -0.5, -0.5],\
'is_alive':[True, True, True],
'num_faces':[8,8,8],
'vol':[2.598,2.598,2.598]}).set_index('cell')
eptm = Epithelium('test_volume',datasets, specs, coords=['x','y','z'])
BulkGeometry.update_all(eptm)
def test_polygons():
datasets_2d, specs = three_faces_sheet(zaxis=True)
datasets = extrude(datasets_2d, scale=1 / 3.0)
eptm = Epithelium("3faces_3D", datasets, specs)
RNRGeometry.update_all(eptm)
with raises(ValueError):
fp = eptm.face_polygons()
eptm.reset_index(order=True)
res = eptm.face_polygons(["x", "y", "z"])
shapes = res.apply(lambda s: s.shape in ((6, 3), (4, 3)))
assert all(shapes)
def test_cut_out():
datasets_2d, specs = three_faces_sheet()
datasets = extrude(datasets_2d, method='translation')
eptm = Epithelium('3faces_3D', datasets)
eptm_ordered = eptm.copy(deep_copy=True)
bounding_box_xy = np.array([[-1., 10.], [-1.5, 1.5]])
bounding_box_yx = np.array([[-1.5, 1.5], [-1.0, 10.]])
bounding_box_xyz = np.array([[-10., 10.], [-1.5, 10.], [-2., 1.]])
expected_index_xy = pd.Index([ 2, 3, 4, 7, 8, 9, 10, 13, 14, 15,\
20, 21, 22, 25, 26, 27, 28, 31, 32, \
33, 44, 46, 47, 48, 49, 50, 51, 52, \
53, 54, 64, 66, 67, 68, 69, 70, 71, \
72, 73, 74, 75, 76, 77, 78, 88, 90, \
91, 92, 93, 94, 95, 96, 97, 98],\
name='edge',dtype='int64')
expected_index_xyz = pd.Index([13, 14, 15, 31, 32, 33, 88, 90, 91, \
92, 93, 94, 95, 96, 97, 98],\
name='edge',dtype='int64')
# test 2-coords, ordered
res = eptm.cut_out(bbox=bounding_box_xy, coords=['x', 'y'])
assert len(res) == len(expected_index_xy)
assert (res == expected_index_xy).all()
# test 2-coords, inverse order
res = eptm.cut_out(bbox=bounding_box_yx, coords=['y', 'x'])
assert len(res) == len(expected_index_xy)
assert (res == expected_index_xy).all()
# test 3-coords
res = eptm.cut_out(bbox=bounding_box_xyz, coords=['x', 'y', 'z'])
assert len(res) == len(expected_index_xyz)
assert (res == expected_index_xyz).all()
# test default coords argument
res = eptm.cut_out(bbox=bounding_box_xy)
assert len(res) == len(expected_index_xy)
assert (res == expected_index_xy).all()
def test_cut_out():
datasets_2d, _ = three_faces_sheet()
datasets = extrude(datasets_2d, method="translation")
eptm = Epithelium("3faces_3D", datasets)
bounding_box_xy = np.array([[-1.0, 10.0], [-1.5, 1.5]])
bounding_box_yx = np.array([[-1.5, 1.5], [-1.0, 10.0]])
bounding_box_xyz = np.array([[-10.0, 10.0], [-1.5, 10.0], [-2.0, 1.0]])
expected_index_xy = pd.Index(
[
2,
3,
4,
7,
8,
9,
10,
13,
14,
15,
20,
21,
22,
25,
26,
27,
28,
31,
32,
33,
44,
46,
47,
48,
49,
50,
51,
52,
53,
54,
64,
66,
67,
68,
69,
70,
71,
72,
73,
74,
75,
76,
77,
78,
88,
90,
91,
92,
93,
94,
95,
96,
97,
98,
],
name="edge",
dtype="int64",
)
expected_index_xyz = pd.Index(
[13, 14, 15, 31, 32, 33, 88, 90, 91, 92, 93, 94, 95, 96, 97, 98],
name="edge",
dtype="int64",
)
# test 2-coords, ordered
res = eptm.cut_out(bbox=bounding_box_xy, coords=["x", "y"])
assert len(res) == len(expected_index_xy)
assert (res == expected_index_xy).all()
# test 2-coords, inverse order
res = eptm.cut_out(bbox=bounding_box_yx, coords=["y", "x"])
assert len(res) == len(expected_index_xy)
assert (res == expected_index_xy).all()
# test 3-coords
res = eptm.cut_out(bbox=bounding_box_xyz, coords=["x", "y", "z"])
assert len(res) == len(expected_index_xyz)
assert (res == expected_index_xyz).all()
# test default coords argument
res = eptm.cut_out(bbox=bounding_box_xy)
assert len(res) == len(expected_index_xy)
assert (res == expected_index_xy).all()
