def _3d_tetrahedrons(precision):
points = 10*np.random.rand(10, 3)
alpha = AlphaComplex(points = points, precision = precision)
st_alpha = alpha.create_simplex_tree(default_filtration_value = False)
# New AlphaComplex for get_point to work
delaunay = AlphaComplex(points = points, precision = precision)
st_delaunay = delaunay.create_simplex_tree(default_filtration_value = True)
delaunay_tetra = []
for sk in st_delaunay.get_skeleton(4):
if len(sk[0]) == 4:
tetra = [delaunay.get_point(sk[0][0]),
delaunay.get_point(sk[0][1]),
delaunay.get_point(sk[0][2]),
delaunay.get_point(sk[0][3]) ]
delaunay_tetra.append(sorted(tetra, key=lambda tup: tup[0]))
alpha_tetra = []
for sk in st_alpha.get_skeleton(4):
if len(sk[0]) == 4:
tetra = [alpha.get_point(sk[0][0]),
alpha.get_point(sk[0][1]),
alpha.get_point(sk[0][2]),
alpha.get_point(sk[0][3]) ]
alpha_tetra.append(sorted(tetra, key=lambda tup: tup[0]))
# Check the tetrahedrons from one list are in the second one
assert len(alpha_tetra) == len(delaunay_tetra)
for tetra_from_del in delaunay_tetra:
assert tetra_from_del in alpha_tetra
def _delaunay_complex(precision):
point_list = [[0, 0], [1, 0], [0, 1], [1, 1]]
filtered_alpha = AlphaComplex(points=point_list, precision=precision)
simplex_tree = filtered_alpha.create_simplex_tree(
default_filtration_value=True)
assert simplex_tree.num_simplices() == 11
assert simplex_tree.num_vertices() == 4
assert point_list[0] == filtered_alpha.get_point(0)
assert point_list[1] == filtered_alpha.get_point(1)
assert point_list[2] == filtered_alpha.get_point(2)
assert point_list[3] == filtered_alpha.get_point(3)
try:
filtered_alpha.get_point(4) == []
except IndexError:
pass
else:
assert False
try:
filtered_alpha.get_point(125) == []
except IndexError:
pass
else:
assert False
for filtered_value in simplex_tree.get_filtration():
assert math.isnan(filtered_value[1])
for filtered_value in simplex_tree.get_star([0]):
assert math.isnan(filtered_value[1])
for filtered_value in simplex_tree.get_cofaces([0], 1):
assert math.isnan(filtered_value[1])
def _3d_points_on_a_plane(precision, default_filtration_value):
alpha = AlphaComplex(points = [[1.0, 1.0 , 0.0],
[7.0, 0.0 , 0.0],
[4.0, 6.0 , 0.0],
[9.0, 6.0 , 0.0],
[0.0, 14.0, 0.0],
[2.0, 19.0, 0.0],
[9.0, 17.0, 0.0]], precision = precision)
simplex_tree = alpha.create_simplex_tree(default_filtration_value = default_filtration_value)
assert simplex_tree.dimension() == 2
assert simplex_tree.num_vertices() == 7
assert simplex_tree.num_simplices() == 25
def _weighted_doc_example(precision):
stree = AlphaComplex(points=[[ 1., -1., -1.],
[-1., 1., -1.],
[-1., -1., 1.],
[ 1., 1., 1.],
[ 2., 2., 2.]],
weights = [4., 4., 4., 4., 1.],
precision = precision).create_simplex_tree()
assert stree.filtration([0, 1, 2, 3]) == pytest.approx(-1.)
assert stree.filtration([0, 1, 3, 4]) == pytest.approx(95.)
assert stree.filtration([0, 2, 3, 4]) == pytest.approx(95.)
assert stree.filtration([1, 2, 3, 4]) == pytest.approx(95.)
def get_graph(sim):
""" This function is to access the combinatorial map externally primarily
this function is meant to help with plotting and not to be used internally"""
from gudhi import AlphaComplex
alpha_complex = AlphaComplex(sim.points)
simplex_tree = alpha_complex.create_simplex_tree(max_alpha_square=sim.sensing_radius ** 2)
simplices1 = [tuple(simplex) for simplex, _ in simplex_tree.get_skeleton(1) if len(simplex) == 2]
graph = nx.Graph()
graph.add_nodes_from(range(len(sim.points)))
graph.add_edges_from(simplices1)
return graph
def test_infinite_alpha():
point_list = [[0, 0], [1, 0], [0, 1], [1, 1]]
alpha_complex = AlphaComplex(points=point_list)
assert alpha_complex.__is_defined() == True
simplex_tree = alpha_complex.create_simplex_tree()
assert simplex_tree.__is_persistence_defined() == False
assert simplex_tree.num_simplices() == 11
assert simplex_tree.num_vertices() == 4
assert list(simplex_tree.get_filtration()) == [
([0], 0.0),
([1], 0.0),
([2], 0.0),
([3], 0.0),
([0, 1], 0.25),
([0, 2], 0.25),
([1, 3], 0.25),
([2, 3], 0.25),
([1, 2], 0.5),
([0, 1, 2], 0.5),
([1, 2, 3], 0.5),
]
assert simplex_tree.get_star([0]) == [
([0], 0.0),
([0, 1], 0.25),
([0, 1, 2], 0.5),
([0, 2], 0.25),
]
assert simplex_tree.get_cofaces([0], 1) == [([0, 1], 0.25), ([0, 2], 0.25)]
assert point_list[0] == alpha_complex.get_point(0)
assert point_list[1] == alpha_complex.get_point(1)
assert point_list[2] == alpha_complex.get_point(2)
assert point_list[3] == alpha_complex.get_point(3)
try:
alpha_complex.get_point(4) == []
except IndexError:
pass
else:
assert False
try:
alpha_complex.get_point(125) == []
except IndexError:
pass
else:
assert False
def test_inconsistency_points_and_weights():
points = [[1.0, 1.0 , 0.0],
[7.0, 0.0 , 0.0],
[4.0, 6.0 , 0.0],
[9.0, 6.0 , 0.0],
[0.0, 14.0, 0.0],
[2.0, 19.0, 0.0],
[9.0, 17.0, 0.0]]
with pytest.raises(ValueError):
# 7 points, 8 weights, on purpose
alpha = AlphaComplex(points = points,
weights = [1., 2., 3., 4., 5., 6., 7., 8.])
with pytest.raises(ValueError):
# 7 points, 6 weights, on purpose
alpha = AlphaComplex(points = points,
weights = [1., 2., 3., 4., 5., 6.])
def _filtered_alpha(precision):
point_list = [[0, 0], [1, 0], [0, 1], [1, 1]]
filtered_alpha = AlphaComplex(points=point_list, precision = precision)
simplex_tree = filtered_alpha.create_simplex_tree(max_alpha_square=0.25)
assert simplex_tree.num_simplices() == 8
assert simplex_tree.num_vertices() == 4
assert point_list[0] == filtered_alpha.get_point(0)
assert point_list[1] == filtered_alpha.get_point(1)
assert point_list[2] == filtered_alpha.get_point(2)
assert point_list[3] == filtered_alpha.get_point(3)
with pytest.raises(IndexError):
filtered_alpha.get_point(len(point_list))
assert list(simplex_tree.get_filtration()) == [
([0], 0.0),
([1], 0.0),
([2], 0.0),
([3], 0.0),
([0, 1], 0.25),
([0, 2], 0.25),
([1, 3], 0.25),
([2, 3], 0.25),
]
assert simplex_tree.get_star([0]) == [([0], 0.0), ([0, 1], 0.25), ([0, 2], 0.25)]
assert simplex_tree.get_cofaces([0], 1) == [([0, 1], 0.25), ([0, 2], 0.25)]
def test_filtered_alpha():
point_list = [[0, 0], [1, 0], [0, 1], [1, 1]]
filtered_alpha = AlphaComplex(points=point_list)
simplex_tree = filtered_alpha.create_simplex_tree(max_alpha_square=0.25)
assert simplex_tree.num_simplices() == 8
assert simplex_tree.num_vertices() == 4
assert point_list[0] == filtered_alpha.get_point(0)
assert point_list[1] == filtered_alpha.get_point(1)
assert point_list[2] == filtered_alpha.get_point(2)
assert point_list[3] == filtered_alpha.get_point(3)
assert filtered_alpha.get_point(4) == []
assert filtered_alpha.get_point(125) == []
assert simplex_tree.get_filtration() == [
([0], 0.0),
([1], 0.0),
([2], 0.0),
([3], 0.0),
([0, 1], 0.25),
([0, 2], 0.25),
([1, 3], 0.25),
([2, 3], 0.25),
]
assert simplex_tree.get_star([0]) == [([0], 0.0), ([0, 1], 0.25),
([0, 2], 0.25)]
assert simplex_tree.get_cofaces([0], 1) == [([0, 1], 0.25), ([0, 2], 0.25)]
def test_off_file_deprecation_warning():
off_file = open("alphacomplexdoc.off", "w")
off_file.write("OFF \n" \
"7 0 0 \n" \
"1.0 1.0 0.0\n" \
"7.0 0.0 0.0\n" \
"4.0 6.0 0.0\n" \
"9.0 6.0 0.0\n" \
"0.0 14.0 0.0\n" \
"2.0 19.0 0.0\n" \
"9.0 17.0 0.0\n" )
off_file.close()
with pytest.warns(DeprecationWarning):
alpha = AlphaComplex(off_file="alphacomplexdoc.off")
def _filtered_alpha(precision):
point_list = [[0, 0], [1, 0], [0, 1], [1, 1]]
filtered_alpha = AlphaComplex(points=point_list, precision=precision)
simplex_tree = filtered_alpha.create_simplex_tree(max_alpha_square=0.25)
assert simplex_tree.num_simplices() == 8
assert simplex_tree.num_vertices() == 4
assert point_list[0] == filtered_alpha.get_point(0)
assert point_list[1] == filtered_alpha.get_point(1)
assert point_list[2] == filtered_alpha.get_point(2)
assert point_list[3] == filtered_alpha.get_point(3)
try:
filtered_alpha.get_point(4) == []
except IndexError:
pass
else:
assert False
try:
filtered_alpha.get_point(125) == []
except IndexError:
pass
else:
assert False
assert list(simplex_tree.get_filtration()) == [
([0], 0.0),
([1], 0.0),
([2], 0.0),
([3], 0.0),
([0, 1], 0.25),
([0, 2], 0.25),
([1, 3], 0.25),
([2, 3], 0.25),
]
assert simplex_tree.get_star([0]) == [([0], 0.0), ([0, 1], 0.25),
([0, 2], 0.25)]
assert simplex_tree.get_cofaces([0], 1) == [([0, 1], 0.25), ([0, 2], 0.25)]
def _infinite_alpha(precision):
point_list = [[0, 0], [1, 0], [0, 1], [1, 1]]
alpha_complex = AlphaComplex(points=point_list, precision = precision)
assert alpha_complex.__is_defined() == True
simplex_tree = alpha_complex.create_simplex_tree()
assert simplex_tree.__is_persistence_defined() == False
assert simplex_tree.num_simplices() == 11
assert simplex_tree.num_vertices() == 4
assert list(simplex_tree.get_filtration()) == [
([0], 0.0),
([1], 0.0),
([2], 0.0),
([3], 0.0),
([0, 1], 0.25),
([0, 2], 0.25),
([1, 3], 0.25),
([2, 3], 0.25),
([1, 2], 0.5),
([0, 1, 2], 0.5),
([1, 2, 3], 0.5),
]
assert simplex_tree.get_star([0]) == [
([0], 0.0),
([0, 1], 0.25),
([0, 1, 2], 0.5),
([0, 2], 0.25),
]
assert simplex_tree.get_cofaces([0], 1) == [([0, 1], 0.25), ([0, 2], 0.25)]
assert point_list[0] == alpha_complex.get_point(0)
assert point_list[1] == alpha_complex.get_point(1)
assert point_list[2] == alpha_complex.get_point(2)
assert point_list[3] == alpha_complex.get_point(3)
with pytest.raises(IndexError):
alpha_complex.get_point(len(point_list))
def test_safe_alpha_persistence_comparison():
#generate periodic signal
time = np.arange(0, 10, 1)
signal = [math.sin(x) for x in time]
delta = math.pi
delayed = [math.sin(x + delta) for x in time]
#construct embedding
embedding1 = [[signal[i], -signal[i]] for i in range(len(time))]
embedding2 = [[signal[i], delayed[i]] for i in range(len(time))]
#build alpha complex and simplex tree
alpha_complex1 = AlphaComplex(points=embedding1)
simplex_tree1 = alpha_complex1.create_simplex_tree()
alpha_complex2 = AlphaComplex(points=embedding2)
simplex_tree2 = alpha_complex2.create_simplex_tree()
diag1 = simplex_tree1.persistence()
diag2 = simplex_tree2.persistence()
for (first_p, second_p) in zip_longest(diag1, diag2):
assert first_p[0] == pytest.approx(second_p[0])
assert first_p[1] == pytest.approx(second_p[1])
See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
Author(s): Vincent Rouvreau
Copyright (C) 2016 Inria
Modification(s):
- YYYY/MM Author: Description of the modification
"""
__author__ = "Vincent Rouvreau"
__copyright__ = "Copyright (C) 2016 Inria"
__license__ = "MIT"
print("#####################################################################")
print("AlphaComplex creation from points")
alpha_complex = AlphaComplex(points=[[0, 0], [1, 0], [0, 1], [1, 1]])
simplex_tree = alpha_complex.create_simplex_tree(max_alpha_square=60.0)
if simplex_tree.find([0, 1]):
print("[0, 1] Found !!")
else:
print("[0, 1] Not found...")
if simplex_tree.find([4]):
print("[4] Found !!")
else:
print("[4] Not found...")
if simplex_tree.insert([0, 1, 2], filtration=4.0):
print("[0, 1, 2] Inserted !!")
else:
def _empty_alpha(precision):
alpha_complex = AlphaComplex(points=[[0, 0]], precision=precision)
assert alpha_complex.__is_defined() == True
""" This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
Author(s): Hind Montassif
Copyright (C) 2021 Inria
Modification(s):
- YYYY/MM Author: Description of the modification
"""
__author__ = "Hind Montassif"
__copyright__ = "Copyright (C) 2021 Inria"
__license__ = "MIT"
print("#####################################################################")
print("AlphaComplex creation from generated points on sphere")
gen_points = points.sphere(n_samples = 50, ambient_dim = 2, radius = 1, sample = "random")
# Create an alpha complex
alpha_complex = AlphaComplex(points = gen_points)
simplex_tree = alpha_complex.create_simplex_tree()
result_str = 'Alpha complex is of dimension ' + repr(simplex_tree.dimension()) + ' - ' + \
repr(simplex_tree.num_simplices()) + ' simplices - ' + \
repr(simplex_tree.num_vertices()) + ' vertices.'
print(result_str)
def test_non_existing_off_file():
with pytest.warns(DeprecationWarning):
with pytest.raises(FileNotFoundError):
alpha = AlphaComplex(off_file="pouetpouettralala.toubiloubabdou")
def test_empty_alpha():
alpha_complex = AlphaComplex(points=[[0, 0]])
assert alpha_complex.__is_defined() == True
See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
Author(s): Vincent Rouvreau
Copyright (C) 2016 Inria
Modification(s):
- YYYY/MM Author: Description of the modification
"""
__author__ = "Vincent Rouvreau"
__copyright__ = "Copyright (C) 2016 Inria"
__license__ = "MIT"
print("#####################################################################")
print("AlphaComplex creation from points")
alpha_complex = AlphaComplex(points=[[0, 0], [1, 0], [0, 1], [1, 1]])
simplex_tree = alpha_complex.create_simplex_tree()
if simplex_tree.find([0, 1]):
print("[0, 1] Found !!")
else:
print("[0, 1] Not found...")
if simplex_tree.find([4]):
print("[4] Found !!")
else:
print("[4] Not found...")
if simplex_tree.insert([0, 1, 2], filtration=4.0):
print("[0, 1, 2] Inserted !!")
else:
from gudhi import AlphaComplex, SimplexTree
from src.datasets import mnist
from pprint import pprint
import sys
print('Making alpha complex')
if len(sys.argv) > 1:
ac = AlphaComplex(off_file=sys.argv[1])
else:
ac = AlphaComplex(points=mnist(7))
print('And simplex tree')
simplex_tree = ac.create_simplex_tree(max_alpha_square=200000.0)
print(repr(simplex_tree))
pprint(dir(simplex_tree))
simplex_tree.get_filtration()