1 files changed, 149 insertions, 0 deletions
diff --git a/src/python/test/test_alpha_complex_3d.py b/src/python/test/test_alpha_complex_3d.py
new file mode 100755
index 00000000..f7bd4fda
--- /dev/null
+++ b/src/python/test/test_alpha_complex_3d.py
@@ -0,0 +1,149 @@
+""" 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):       Vincent Rouvreau
+
+    Copyright (C) 2021 Inria
+
+    Modification(s):
+      - YYYY/MM Author: Description of the modification
+"""
+
+from gudhi import AlphaComplex3D
+import pytest
+
+try:
+    # python3
+    from itertools import zip_longest
+except ImportError:
+    # python2
+    from itertools import izip_longest as zip_longest
+
+
+
+def _empty_alpha(precision):
+    alpha_complex = AlphaComplex3D(precision = precision)
+    assert alpha_complex.__is_defined() == True
+
+def _one_3d_point_alpha(precision):
+    alpha_complex = AlphaComplex3D(points=[[0, 0, 0]], precision = precision)
+    assert alpha_complex.__is_defined() == True
+
+def test_empty_alpha():
+    for precision in ['fast', 'safe', 'exact']:
+        _empty_alpha(precision)
+        _one_3d_point_alpha(precision)
+
+def _infinite_alpha(precision):
+    point_list = [[0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0], [0, 0, 1], [1, 0, 1], [0, 1, 1], [1, 1, 1]]
+    alpha_complex = AlphaComplex3D(points=point_list, precision = precision)
+    assert alpha_complex.__is_defined() == True
+
+    stree = alpha_complex.create_simplex_tree()
+    assert stree.__is_persistence_defined() == False
+
+    assert stree.num_simplices() == 51
+    assert stree.num_vertices() == len(point_list)
+
+    for filtration in stree.get_filtration():
+        if len(filtration[0]) == 1:
+            assert filtration[1] == 0.
+        if len(filtration[0]) == 4:
+            assert filtration[1] == 0.75
+
+    for idx in range(len(point_list)):
+        pt_idx = point_list.index(alpha_complex.get_point(idx))
+        assert pt_idx >= 0
+        assert pt_idx < len(point_list)
+
+    with pytest.raises(IndexError):
+        alpha_complex.get_point(len(point_list))
+
+def test_infinite_alpha():
+    for precision in ['fast', 'safe', 'exact']:
+        _infinite_alpha(precision)
+
+def _filtered_alpha(precision):
+    point_list = [[0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0], [0, 0, 1], [1, 0, 1], [0, 1, 1], [1, 1, 1]]
+    filtered_alpha = AlphaComplex3D(points=point_list, precision = precision)
+
+    stree = filtered_alpha.create_simplex_tree(max_alpha_square=0.25)
+
+    assert stree.num_simplices() == 20
+    assert stree.num_vertices() == len(point_list)
+
+    for filtration in stree.get_filtration():
+        if len(filtration[0]) == 1:
+            assert filtration[1] == 0.
+        elif len(filtration[0]) == 2:
+            assert filtration[1] == 0.25
+        else:
+            assert False
+
+    for idx in range(len(point_list)):
+        pt_idx = point_list.index(filtered_alpha.get_point(idx))
+        assert pt_idx >= 0
+        assert pt_idx < len(point_list)
+
+    with pytest.raises(IndexError):
+        filtered_alpha.get_point(len(point_list))
+
+def test_filtered_alpha():
+    for precision in ['fast', 'safe', 'exact']:
+        _filtered_alpha(precision)
+
+def _3d_points_on_a_plane(precision):
+    alpha = AlphaComplex3D(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)
+
+    with pytest.raises(ValueError):
+        stree = alpha.create_simplex_tree()
+
+def test_3d_points_on_a_plane():
+    for precision in ['fast', 'safe', 'exact']:
+        _3d_points_on_a_plane(precision)
+
+def test_inconsistency_points_and_weights():
+    points = [[1.0, 1.0 , 1.0],
+              [7.0, 0.0 , 2.0],
+              [4.0, 6.0 , 0.0],
+              [9.0, 6.0 , 1.0],
+              [0.0, 14.0, 2.0],
+              [2.0, 19.0, 0.0],
+              [9.0, 17.0, 1.0]]
+    with pytest.raises(ValueError):
+        # 7 points, 8 weights, on purpose
+        alpha = AlphaComplex3D(points = points,
+                                weights = [1., 2., 3., 4., 5., 6., 7., 8.])
+
+    with pytest.raises(ValueError):
+        # 7 points, 6 weights, on purpose
+        alpha = AlphaComplex3D(points = points,
+                                weights = [1., 2., 3., 4., 5., 6.])
+
+def _weighted_doc_example(precision):
+    pts = [[ 1., -1., -1.],
+           [-1.,  1., -1.],
+           [-1., -1.,  1.],
+           [ 1.,  1.,  1.],
+           [ 2.,  2.,  2.]]
+    wgts = [4., 4., 4., 4., 1.]
+    alpha = AlphaComplex3D(points = pts, weights = wgts, precision = precision)
+    stree = alpha.create_simplex_tree()
+
+    # Needs to retrieve points as points are shuffled
+    get_idx = lambda idx: pts.index(alpha.get_point(idx))
+    indices = [get_idx(x) for x in range(len(pts))]
+
+    assert stree.filtration([indices[x] for x in [0, 1, 2, 3]]) == pytest.approx(-1.)
+    assert stree.filtration([indices[x] for x in [0, 1, 3, 4]]) == pytest.approx(95.)
+    assert stree.filtration([indices[x] for x in [0, 2, 3, 4]]) == pytest.approx(95.)
+    assert stree.filtration([indices[x] for x in [1, 2, 3, 4]]) == pytest.approx(95.)
+
+def test_weighted_doc_example():
+    for precision in ['fast', 'safe', 'exact']:
+        _weighted_doc_example(precision)