Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Dev #281

Merged
merged 77 commits into from
Feb 13, 2024
Merged

Dev #281

Changes from 1 commit
Commits
Show all changes
77 commits
Select commit Hold shift + click to select a range
9db3ed7
Fix for Issues #261 - cell division failed at the border
sophietheis Nov 8, 2022
524696f
Fix Mesh creation
sophietheis Nov 9, 2022
4d7b918
Add 2D collision solver
sophietheis Nov 10, 2022
c08f4f2
Update README.md
sophietheis Nov 11, 2022
934610d
Generalised wich vertex penetrate face
sophietheis Nov 11, 2022
fa64a25
Attempt to set out particular cases
sophietheis Nov 11, 2022
85eb93d
Detect and fix self-crossing face
sophietheis Nov 14, 2022
a041e9b
Use `.apply()`
sophietheis Nov 14, 2022
febed0f
ENH: write `mean_XX` method in `Epithelium` class (Issue #224)
sophietheis Nov 15, 2022
2be7b6d
Fix according to comments
sophietheis Nov 15, 2022
3ce763b
Fix Issue #258 ax argument not considered in `plt_draw.sheet_view`
sophietheis Nov 15, 2022
a23f656
ENH: pass column name to `data_at_opposite` issue (#245)
sophietheis Nov 15, 2022
ad7a335
Add publication and remove bibtex reference
sophietheis Nov 16, 2022
d23e9f5
Add check face convexity
sophietheis Nov 16, 2022
ce67fa4
Use reset_index and code simplification
sophietheis Nov 16, 2022
48c6859
yAdd to_mesh function (issue #221) and some test
sophietheis Nov 17, 2022
f25763e
Remove the use of reset_index in face_self_intersect
sophietheis Nov 17, 2022
47d36fc
use ipv_draw with 2D data
sophietheis Nov 18, 2022
6840f29
Fix solution after detection point inside polygon
sophietheis Nov 18, 2022
c41b940
Remove solving collision for 2 same face...
sophietheis Nov 18, 2022
aca8e18
Abord vertex displacement if it creates twisted face
sophietheis Nov 23, 2022
430dd38
New way to calculate the position of "penetrate" vertices
sophietheis Nov 24, 2022
c1757b7
WIP - use force field to fix collision
sophietheis Nov 28, 2022
aa21e9e
Small fix
sophietheis Nov 29, 2022
a7772b6
Remove function duplication due to circular import
sophietheis Dec 9, 2022
73aae18
Calculate "repulsion" gradient in the effector method. Remove loop
sophietheis Dec 12, 2022
bf53966
Fix tests
sophietheis Jan 3, 2023
dec83f0
Add lateralsheet shapes + test
sophietheis Feb 21, 2023
b168d59
Update publication + add collapse texte
sophietheis Feb 22, 2023
902fb72
Add test for Repulsion effector
sophietheis Feb 28, 2023
b0d3723
Add test update repulsion
sophietheis Feb 28, 2023
b226c31
Remove unused import
sophietheis Feb 28, 2023
5047751
Add `drop_face` to allow hole (issues #220 and #141) (associate #221)
sophietheis Feb 28, 2023
98b6e18
Update readme.md
sophietheis Mar 1, 2023
ebc1805
Update publications in README.md
sophietheis Mar 6, 2023
181edcd
Add `lineage` attribute to `Epithelium`
sophietheis Mar 7, 2023
455f1ca
Remove memory oscillation
sophietheis Jun 27, 2023
dc8521c
merge with main
glyg Dec 27, 2023
a408ac5
builds with pip
glyg Dec 28, 2023
4584914
debugging, still no build apparently
glyg Dec 28, 2023
a8d12c4
build and tests
glyg Dec 28, 2023
1f9975f
update nb submodule
glyg Dec 28, 2023
5419af3
fix pyproject
glyg Dec 28, 2023
1e6c17d
install with pip in CI
glyg Dec 28, 2023
eaf2819
install with pip in CI
glyg Dec 28, 2023
eb1bbb7
install with pip in CI
glyg Dec 28, 2023
0e85676
adds scikit-build dep
glyg Dec 28, 2023
1dfbe12
python version
glyg Dec 28, 2023
dbdf911
python version specifier
glyg Dec 28, 2023
cbfd1f8
remove strang flags
glyg Dec 28, 2023
ebbbb27
adds _version.py
glyg Dec 28, 2023
76daa2a
setuptools_scm dep
glyg Dec 28, 2023
63aea94
simplified I guess
glyg Dec 28, 2023
ce58472
zdds setuptools-scm to env, MakeFilelist shenanigans
glyg Jan 7, 2024
684c2c7
restricting to 3.10
glyg Jan 7, 2024
1c53508
install dev
glyg Jan 7, 2024
3de8d6a
pyhon version coherence
glyg Jan 7, 2024
a5412bf
install cmd
glyg Jan 7, 2024
ebbdeb7
trying to move to modern sckit-build (it's painful)
glyg Jan 7, 2024
e62491c
WIP change build
glyg Jan 7, 2024
367edd6
getting closer I hope
glyg Jan 8, 2024
b96792f
make_spherical test pasess \o/
glyg Jan 9, 2024
347f950
tests passing, warnings still to be treated
glyg Jan 9, 2024
84dff99
don't install editable version in gh action
glyg Jan 9, 2024
ef71914
remove diff chars
glyg Jan 9, 2024
2b3a572
tagging again to avoid metadata mismatch
glyg Jan 24, 2024
7bef6c4
Uncomment 2D repulsion + tests
sophietheis Jan 25, 2024
f1a8839
Add comments in effectors.py
sophietheis Jan 25, 2024
09174f5
rmeove _version.py and ignore in git
glyg Feb 12, 2024
4227a48
Update history.py (#274)
sniffo Dec 27, 2023
d61bce5
skip 2 tests
glyg Feb 12, 2024
9683613
Merge branch 'main' into dev
glyg Feb 12, 2024
02f2c1c
fix non existing hdf5
glyg Feb 12, 2024
bfd8065
submodules
glyg Feb 12, 2024
be279bf
adds notebooks submodule
glyg Feb 12, 2024
a1228ce
should fix history bug
glyg Feb 13, 2024
ba9abce
adds submodules again
glyg Feb 13, 2024
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Prev Previous commit
Next Next commit
build and tests
glyg committed Dec 28, 2023
commit a8d12c43b89ba3a17572f427913850ce6dd709d4
11 changes: 7 additions & 4 deletions CMakeLists.txt
Original file line number Diff line number Diff line change
@@ -1,9 +1,8 @@
project(tyssue)

cmake_minimum_required(VERSION 3.5.0)
set(CMAKE_VERBOSE_MAKEFILE ON)

cmake_minimum_required(VERSION 3.5...3.26)

project(tyssue)
find_package(Python COMPONENTS Interpreter Development.Module REQUIRED)



@@ -28,6 +27,7 @@ if (NOT CGAL_FOUND)
endif()



# include helper file
include( ${CGAL_USE_FILE})

@@ -40,6 +40,9 @@ include_directories (${COLLISION_SRCE} ${GENERATION_SRCE})
# Assumes pybind11 is a subdirectory at the project root
# Make sure you git cloned tyssue recursively
add_subdirectory(pybind11)



pybind11_add_module(c_collisions ${SOURCES} "${COLLISION_SRCE}/c_collisions.cpp" )
pybind11_add_module(mesh_generation ${SOURCES} "${GENERATION_SRCE}/mesh_generation.cpp" )
# pybind11_add_module(tyssue.collisions.cpp.c_collisions src/tyssue/collisions/cpp/c_collisions)
2 changes: 1 addition & 1 deletion doc/notebooks
8 changes: 8 additions & 0 deletions pyproject.toml
Original file line number Diff line number Diff line change
@@ -65,11 +65,19 @@ cmake.minimum-version = "3.26.1"
ninja.minimum-version = "1.11"
wheel.expand-macos-universal-tags = true
sdist.include = [
"CMakeLists.txt",
"pybind11/tools",
"pybind11/include",
"pybind11/CMakeLists.txt",
]
build-dir = "build"
cmake.args = [
"-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=${SOURCES}",
"-DCMAKE_BUILD_TYPE=Debug",
]

cmake.verbose = true


[tool.setuptools]
include_package_data = true
2 changes: 1 addition & 1 deletion setup.py
Original file line number Diff line number Diff line change
@@ -163,7 +163,7 @@ def build_extension(self, ext):
]


write_version_py()
# write_version_py()
setup(
name=DISTNAME,
description=DESCRIPTION,
231 changes: 158 additions & 73 deletions src/tyssue/collisions/solvers.py
Original file line number Diff line number Diff line change
@@ -48,21 +48,27 @@ def solve_self_intersect_face(eptm):
face_self_intersect = eptm.edge_df.groupby("face").apply(_do_face_self_intersect)

for f in face_self_intersect[face_self_intersect].index:
sorted_edge = np.array(_ordered_edges(
eptm.edge_df[eptm.edge_df["face"] == f][["srce", "trgt", "face"]])).flatten()[3::4]
sorted_edge = np.array(
_ordered_edges(
eptm.edge_df[eptm.edge_df["face"] == f][["srce", "trgt", "face"]]
)
).flatten()[3::4]
angle_list = np.arctan2(
eptm.edge_df.loc[sorted_edge]["sy"].to_numpy() - eptm.edge_df.loc[sorted_edge]["fy"].to_numpy(),
eptm.edge_df.loc[sorted_edge]["sx"].to_numpy() - eptm.edge_df.loc[sorted_edge][
"fx"].to_numpy())
eptm.edge_df.loc[sorted_edge]["sy"].to_numpy()
- eptm.edge_df.loc[sorted_edge]["fy"].to_numpy(),
eptm.edge_df.loc[sorted_edge]["sx"].to_numpy()
- eptm.edge_df.loc[sorted_edge]["fx"].to_numpy(),
)

angle_e = pd.DataFrame(angle_list, index=sorted_edge, columns=['angle'])
angle_e = pd.DataFrame(angle_list, index=sorted_edge, columns=["angle"])

if np.argmin(angle_e["angle"]) != 0:
pos_s = np.argmin(angle_e["angle"])
angle_e = pd.concat([angle_e.iloc[pos_s:], angle_e.iloc[:pos_s]])
# Fix if the swap is between the 2 lowest angle value
if ((angle_e.iloc[-1]["angle"] > angle_e.iloc[0]["angle"]) and (
angle_e.iloc[-1]["angle"] < angle_e.iloc[-2]["angle"])):
if (angle_e.iloc[-1]["angle"] > angle_e.iloc[0]["angle"]) and (
angle_e.iloc[-1]["angle"] < angle_e.iloc[-2]["angle"]
):
pos_s = angle_e.shape[0] - 1
angle_e = pd.concat([angle_e.iloc[pos_s:], angle_e.iloc[:pos_s]])

@@ -73,15 +79,15 @@ def solve_self_intersect_face(eptm):
v1 = eptm.edge_df.loc[angle_e.index[pos_s]]["srce"]
v2 = eptm.edge_df.loc[angle_e.index[pos_s - 1]]["srce"]

v1_x, v1_y = eptm.vert_df.loc[v1][['x', 'y']]
v2_x, v2_y = eptm.vert_df.loc[v2][['x', 'y']]
eptm.vert_df.loc[v1, ['x', 'y']] = v2_x, v2_y
eptm.vert_df.loc[v2, ['x', 'y']] = v1_x, v1_y
v1_x, v1_y = eptm.vert_df.loc[v1][["x", "y"]]
v2_x, v2_y = eptm.vert_df.loc[v2][["x", "y"]]
eptm.vert_df.loc[v1, ["x", "y"]] = v2_x, v2_y
eptm.vert_df.loc[v2, ["x", "y"]] = v1_x, v1_y
mask = np.repeat(False, eptm.Nf)
mask[f] = True
if self_intersections(eptm.extract(mask)).size > 0:
eptm.vert_df.loc[v1, ['x', 'y']] = v1_x, v1_y
eptm.vert_df.loc[v2, ['x', 'y']] = v2_x, v2_y
eptm.vert_df.loc[v1, ["x", "y"]] = v1_x, v1_y
eptm.vert_df.loc[v2, ["x", "y"]] = v2_x, v2_y


def _check_convexity(polygon):
@@ -96,31 +102,33 @@ def _check_convexity(polygon):
res = u[0] * v_y - u[1] * v_x + v_x * p[1] - v_y * p[0]
else:
newres = u[0] * v_y - u[1] * v_x + v_x * p[1] - v_y * p[0]
if ((newres > 0 and res < 0) or (newres < 0 and res > 0)):
if (newres > 0 and res < 0) or (newres < 0 and res > 0):
return False

return True


def _do_face_self_intersect(edge):
sorted_edge = np.array(_ordered_edges(
edge[['srce', 'trgt', 'face']])).flatten()[3::4]
sorted_edge = np.array(_ordered_edges(edge[["srce", "trgt", "face"]])).flatten()[
3::4
]
angle_list = np.arctan2(
edge.loc[sorted_edge]['sy'].to_numpy() - edge.loc[sorted_edge]['fy'].to_numpy(),
edge.loc[sorted_edge]['sx'].to_numpy() - edge.loc[sorted_edge][
'fx'].to_numpy())
edge.loc[sorted_edge]["sy"].to_numpy() - edge.loc[sorted_edge]["fy"].to_numpy(),
edge.loc[sorted_edge]["sx"].to_numpy() - edge.loc[sorted_edge]["fx"].to_numpy(),
)

angle_e = pd.DataFrame(angle_list, index=sorted_edge, columns=['angle'])
angle_e = pd.DataFrame(angle_list, index=sorted_edge, columns=["angle"])

if np.argmin(angle_e['angle']) != 0:
pos_s = np.argmin(angle_e['angle'])
if np.argmin(angle_e["angle"]) != 0:
pos_s = np.argmin(angle_e["angle"])
angle_e = pd.concat([angle_e.iloc[pos_s:], angle_e.iloc[:pos_s]])

angle_e = pd.concat([angle_e, angle_e.iloc[[0]]])
angle_e.iloc[-1]['angle'] += 2 * np.pi
angle_e.iloc[-1]["angle"] += 2 * np.pi

if (not pd.Series(angle_e['angle']).is_monotonic_increasing) and (
_check_convexity(edge.loc[sorted_edge][['sx', 'sy']].to_numpy())):
if (not pd.Series(angle_e["angle"]).is_monotonic_increasing) and (
_check_convexity(edge.loc[sorted_edge][["sx", "sy"]].to_numpy())
):
return True
return False

@@ -222,46 +230,109 @@ def __init__(self, sheet, position_buffer, intersecting_edges):
CollidingBoxes.__init__(self, sheet, position_buffer, intersecting_edges)

def _find_vert_inside(self, edge1, edge2):
triangle1 = [self.sheet.edge_df.loc[edge1][['sx', 'sy']].to_numpy(),
self.sheet.edge_df.loc[edge1][['tx', 'ty']].to_numpy(),
self.sheet.edge_df.loc[edge1][['fx', 'fy']].to_numpy()]
triangle2 = [self.sheet.edge_df.loc[edge2][['sx', 'sy']].to_numpy(),
self.sheet.edge_df.loc[edge2][['tx', 'ty']].to_numpy(),
self.sheet.edge_df.loc[edge2][['fx', 'fy']].to_numpy()]

if _point_in_triangle(self.sheet.edge_df.loc[edge1][['sx', 'sy']].to_numpy(), triangle2):
return self.sheet.edge_df.loc[edge1]['srce'], self.sheet.edge_df.loc[edge2]['face'], edge2
if _point_in_triangle(self.sheet.edge_df.loc[edge1][['tx', 'ty']].to_numpy(), triangle2):
return self.sheet.edge_df.loc[edge1]['trgt'], self.sheet.edge_df.loc[edge2]['face'], edge2
if _point_in_triangle(self.sheet.edge_df.loc[edge2][['sx', 'sy']].to_numpy(), triangle1):
return self.sheet.edge_df.loc[edge2]['srce'], self.sheet.edge_df.loc[edge1]['face'], edge1
if _point_in_triangle(self.sheet.edge_df.loc[edge2][['tx', 'ty']].to_numpy(), triangle1):
return self.sheet.edge_df.loc[edge2]['trgt'], self.sheet.edge_df.loc[edge1]['face'], edge1
triangle1 = [
self.sheet.edge_df.loc[edge1][["sx", "sy"]].to_numpy(),
self.sheet.edge_df.loc[edge1][["tx", "ty"]].to_numpy(),
self.sheet.edge_df.loc[edge1][["fx", "fy"]].to_numpy(),
]
triangle2 = [
self.sheet.edge_df.loc[edge2][["sx", "sy"]].to_numpy(),
self.sheet.edge_df.loc[edge2][["tx", "ty"]].to_numpy(),
self.sheet.edge_df.loc[edge2][["fx", "fy"]].to_numpy(),
]

if _point_in_triangle(
self.sheet.edge_df.loc[edge1][["sx", "sy"]].to_numpy(), triangle2
):
return (
self.sheet.edge_df.loc[edge1]["srce"],
self.sheet.edge_df.loc[edge2]["face"],
edge2,
)
if _point_in_triangle(
self.sheet.edge_df.loc[edge1][["tx", "ty"]].to_numpy(), triangle2
):
return (
self.sheet.edge_df.loc[edge1]["trgt"],
self.sheet.edge_df.loc[edge2]["face"],
edge2,
)
if _point_in_triangle(
self.sheet.edge_df.loc[edge2][["sx", "sy"]].to_numpy(), triangle1
):
return (
self.sheet.edge_df.loc[edge2]["srce"],
self.sheet.edge_df.loc[edge1]["face"],
edge1,
)
if _point_in_triangle(
self.sheet.edge_df.loc[edge2][["tx", "ty"]].to_numpy(), triangle1
):
return (
self.sheet.edge_df.loc[edge2]["trgt"],
self.sheet.edge_df.loc[edge1]["face"],
edge1,
)

# search inside full face
if _point_in_polygon(self.sheet, self.sheet.edge_df.loc[edge1][['sx', 'sy']].to_numpy(),
self.sheet.edge_df.loc[edge2]['face']):
return self.sheet.edge_df.loc[edge1]['srce'], self.sheet.edge_df.loc[edge2]['face'], edge2
if _point_in_polygon(self.sheet, self.sheet.edge_df.loc[edge1][['tx', 'ty']].to_numpy(),
self.sheet.edge_df.loc[edge2]['face']):
return self.sheet.edge_df.loc[edge1]['trgt'], self.sheet.edge_df.loc[edge2]['face'], edge2
if _point_in_polygon(self.sheet, self.sheet.edge_df.loc[edge2][['sx', 'sy']].to_numpy(),
self.sheet.edge_df.loc[edge1]['face']):
return self.sheet.edge_df.loc[edge2]['srce'], self.sheet.edge_df.loc[edge1]['face'], edge1
if _point_in_polygon(self.sheet, self.sheet.edge_df.loc[edge2][['tx', 'ty']].to_numpy(),
self.sheet.edge_df.loc[edge1]['face']):
return self.sheet.edge_df.loc[edge2]['trgt'], self.sheet.edge_df.loc[edge1]['face'], edge1
if _point_in_polygon(
self.sheet,
self.sheet.edge_df.loc[edge1][["sx", "sy"]].to_numpy(),
self.sheet.edge_df.loc[edge2]["face"],
):
return (
self.sheet.edge_df.loc[edge1]["srce"],
self.sheet.edge_df.loc[edge2]["face"],
edge2,
)
if _point_in_polygon(
self.sheet,
self.sheet.edge_df.loc[edge1][["tx", "ty"]].to_numpy(),
self.sheet.edge_df.loc[edge2]["face"],
):
return (
self.sheet.edge_df.loc[edge1]["trgt"],
self.sheet.edge_df.loc[edge2]["face"],
edge2,
)
if _point_in_polygon(
self.sheet,
self.sheet.edge_df.loc[edge2][["sx", "sy"]].to_numpy(),
self.sheet.edge_df.loc[edge1]["face"],
):
return (
self.sheet.edge_df.loc[edge2]["srce"],
self.sheet.edge_df.loc[edge1]["face"],
edge1,
)
if _point_in_polygon(
self.sheet,
self.sheet.edge_df.loc[edge2][["tx", "ty"]].to_numpy(),
self.sheet.edge_df.loc[edge1]["face"],
):
return (
self.sheet.edge_df.loc[edge2]["trgt"],
self.sheet.edge_df.loc[edge1]["face"],
edge1,
)

return np.NaN, np.NaN, np.NaN

def solve_collisions(self, shyness=1e-10):
id_vert_change = []
for e1, e2 in self.edge_pairs:
# Dont fix if crossing occur between two neighboring cells or between "2 same" cell.
if (self.sheet.edge_df.loc[e1]['face'] != self.sheet.edge_df.loc[e2]['face']) and (
self.sheet.edge_df.loc[e1]['face'] not in self.sheet.get_neighbors(
self.sheet.edge_df.loc[e2]['face'])):
vertices = self.sheet.edge_df.loc[[e1, e2]][['srce', 'trgt']].to_numpy().flatten()
if (
self.sheet.edge_df.loc[e1]["face"] != self.sheet.edge_df.loc[e2]["face"]
) and (
self.sheet.edge_df.loc[e1]["face"]
not in self.sheet.get_neighbors(self.sheet.edge_df.loc[e2]["face"])
):
vertices = (
self.sheet.edge_df.loc[[e1, e2]][["srce", "trgt"]]
.to_numpy()
.flatten()
)
if vertices.all() not in id_vert_change:
vert_inside, face, edge = self._find_vert_inside(e1, e2)
if not np.isnan(vert_inside):
@@ -274,7 +345,9 @@ def solve_collisions(self, shyness=1e-10):
# self.sheet.edge_df.loc[edge][['sx', 'sy']],
# self.sheet.edge_df.loc[edge][['tx', 'ty']]))
if not np.isnan(new_pos[0]):
self.sheet.vert_df.loc[vert_inside, self.sheet.coords] = new_pos
self.sheet.vert_df.loc[
vert_inside, self.sheet.coords
] = new_pos
id_vert_change.append(vert_inside)
return True

@@ -389,10 +462,10 @@ def _collision_plane(self, face_pair, shyness):
fe0p = self.edge_buffer[self.sheet.edge_df["face"] == f0].copy()
fe1p = self.edge_buffer[self.sheet.edge_df["face"] == f1].copy()

bb0c = _face_bbox(fe0c)
bb1c = _face_bbox(fe1c)
bb0p = _face_bbox(fe0p)
bb1p = _face_bbox(fe1p)
bb0c = self._face_bbox(fe0c)
bb1c = self._face_bbox(fe1c)
bb0p = self._face_bbox(fe0p)
bb1p = self._face_bbox(fe1p)

dr0 = bb0c - bb0p
dr1 = bb1c - bb1p
@@ -456,7 +529,10 @@ def _face_bbox(self, face_edges):
lower = points.min(axis=0)
upper = points.max(axis=0)
return pd.DataFrame(
[lower, upper], index=list("lh"), columns=self.coord[:len(lower)], dtype=float
[lower, upper],
index=list("lh"),
columns=self.coord[: len(lower)],
dtype=float,
).T


@@ -491,28 +567,37 @@ def _point_in_triangle(point, triangle):


def _point_in_polygon(sheet, point, face):
edge_index = sheet.edge_df[sheet.edge_df['face'] == face].index
ordered_vert_index = np.array(_ordered_edges(sheet.edge_df.loc[edge_index][['srce', 'trgt', 'face']])).flatten()[
0::4]
poly_path = mplPath.Path(np.array(sheet.vert_df.loc[ordered_vert_index][['x', 'y']]))
edge_index = sheet.edge_df[sheet.edge_df["face"] == face].index
ordered_vert_index = np.array(
_ordered_edges(sheet.edge_df.loc[edge_index][["srce", "trgt", "face"]])
).flatten()[0::4]
poly_path = mplPath.Path(
np.array(sheet.vert_df.loc[ordered_vert_index][["x", "y"]])
)
# point = np.array(sheet.edge_df.loc[8][['tx', 'ty']])
return poly_path.contains_point(point)


def vertex_repulse(eptm, vertex):
try:
face1, face2 = eptm.edge_df[eptm.edge_df['srce'] == vertex]["face"].to_numpy()
face1, face2 = eptm.edge_df[eptm.edge_df["srce"] == vertex]["face"].to_numpy()
except:
# print("vertex at border")
return np.nan, np.nan

vec1 = [eptm.vert_df.loc[vertex]['x'] - eptm.face_df.loc[face1]['x'],
eptm.vert_df.loc[vertex]['y'] - eptm.face_df.loc[face1]['y'], ]
vec1 = [
eptm.vert_df.loc[vertex]["x"] - eptm.face_df.loc[face1]["x"],
eptm.vert_df.loc[vertex]["y"] - eptm.face_df.loc[face1]["y"],
]

vec2 = [eptm.vert_df.loc[vertex]['x'] - eptm.face_df.loc[face2]['x'],
eptm.vert_df.loc[vertex]['y'] - eptm.face_df.loc[face2]['y'], ]
vec2 = [
eptm.vert_df.loc[vertex]["x"] - eptm.face_df.loc[face2]["x"],
eptm.vert_df.loc[vertex]["y"] - eptm.face_df.loc[face2]["y"],
]

new_pos = eptm.vert_df.loc[vertex][list('xy')].to_numpy() - np.add(vec1, vec2) / 2 * 0.5
new_pos = (
eptm.vert_df.loc[vertex][list("xy")].to_numpy() - np.add(vec1, vec2) / 2 * 0.5
)
return new_pos


Loading