How to use the gudhi.AlphaComplex function in gudhi

To help you get started, we’ve selected a few gudhi examples, based on popular ways it is used in public projects.

Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.

MathieuCarriere / perslay / perslay / experiments.py View on Github
``````X = np.zeros([num_pts_per_orbit, 2])
xcur, ycur = np.random.rand(), np.random.rand()
for idx in range(num_pts_per_orbit):
xcur = (xcur + param * ycur * (1. - ycur)) % 1
ycur = (ycur + param * xcur * (1. - xcur)) % 1
X[idx, :] = [xcur, ycur]
return X

labs = []
count = 0
num_diag_per_param = 1000 if "5K" in dataset else 20000
for lab, r in enumerate([2.5, 3.5, 4.0, 4.1, 4.3]):
print("Generating", num_diag_per_param, "orbits and diagrams for r = ", r, "...")
for dg in range(num_diag_per_param):
X = _gen_orbit(num_pts_per_orbit=1000, param=r)
alpha_complex = gd.AlphaComplex(points=X)
simplex_tree = alpha_complex.create_simplex_tree(max_alpha_square=1e50)
simplex_tree.persistence()
diag_file["Alpha0"].create_dataset(name=str(count),
data=np.array(simplex_tree.persistence_intervals_in_dimension(0)))
diag_file["Alpha1"].create_dataset(name=str(count),
data=np.array(simplex_tree.persistence_intervals_in_dimension(1)))
orbit_label = {"label": lab, "pcid": count}
labs.append(orbit_label)
count += 1
labels = pd.DataFrame(labs)
labels.set_index("pcid")
features = labels[["label"]]

features.to_csv(path_dataset + dataset + ".csv")
return diag_file.close()``````
GUDHI / gudhi-devel / src / cython / example / alpha_rips_persistence_bottleneck_distance.py View on Github
``````max_edge_length=args.threshold)

rips_stree = rips_complex.create_simplex_tree(max_dimension=args.max_dimension)

message = "Number of simplices=" + repr(rips_stree.num_simplices())
print(message)

rips_diag = rips_stree.persistence()

print("#####################################################################")
print("AlphaComplex creation from points read in a OFF file")

message = "AlphaComplex with max_edge_length=" + repr(args.threshold)
print(message)

alpha_complex = gudhi.AlphaComplex(points=point_cloud)
alpha_stree = alpha_complex.create_simplex_tree(max_alpha_square=(args.threshold * args.threshold))

message = "Number of simplices=" + repr(alpha_stree.num_simplices())
print(message)

alpha_diag = alpha_stree.persistence()

max_b_distance = 0.0
for dim in range(args.max_dimension):
# Alpha persistence values needs to be transform because filtration
# values are alpha square values
funcs = [math.sqrt, math.sqrt]
alpha_intervals = []
for interval in alpha_stree.persistence_intervals_in_dimension(dim):
alpha_intervals.append(map(lambda func,value: func(value), funcs, interval))``````
MathieuCarriere / perslay / expe / utils.py View on Github
``````num_pts_per_orbit = 1000
for lab, r in enumerate([2.5, 3.5, 4.0, 4.1, 4.3]):
print("Generating", num_diag_per_param, "orbits and diagrams for r = ", r, "...")
for dg in range(num_diag_per_param):
x0, y0 = np.random.rand(), np.random.rand()
xcur, ycur = x0, y0
X = np.zeros([num_pts_per_orbit, 2])
X[0, :] = [x0, y0]
for idx in range(num_pts_per_orbit - 1):
xcur += r * ycur * (1. - ycur)
xcur -= int(xcur)
ycur += r * xcur * (1. - xcur)
ycur -= int(ycur)
X[idx, :] = [xcur, ycur]

alpha_complex = gd.AlphaComplex(points=X)
simplex_tree = alpha_complex.create_simplex_tree(max_alpha_square=1e50)
simplex_tree.persistence()
diag_file["Alpha0"].create_dataset(name=str(count),
data=np.array(simplex_tree.persistence_intervals_in_dimension(0)))
diag_file["Alpha1"].create_dataset(name=str(count),
data=np.array(simplex_tree.persistence_intervals_in_dimension(1)))
orbit_label = {"label": lab, "pcid": count}
labs.append(orbit_label)
count += 1
labels = pd.DataFrame(labs)
labels.set_index("pcid")
features = labels[["label"]]
features.to_csv(path_dataset + dataset + ".csv")
return diag_file.close()``````
GUDHI / gudhi-devel / src / python / example / alpha_complex_diagram_persistence_from_off_file_example.py View on Github
``````action="store_true",
help="Flag for not to display the diagrams",
)

args = parser.parse_args()

with open(args.file, "r") as f:
if (first_line == "OFF\n") or (first_line == "nOFF\n"):
print("#####################################################################")
print("AlphaComplex creation from points read in a OFF file")

message = "AlphaComplex with max_edge_length=" + repr(args.max_alpha_square)
print(message)

alpha_complex = gudhi.AlphaComplex(off_file=args.file)
simplex_tree = alpha_complex.create_simplex_tree(
max_alpha_square=args.max_alpha_square
)

message = "Number of simplices=" + repr(simplex_tree.num_simplices())
print(message)

diag = simplex_tree.persistence()

print("betti_numbers()=")
print(simplex_tree.betti_numbers())

if args.no_diagram == False:
gudhi.plot_persistence_diagram(diag, band=args.band)
plot.show()
else:``````
GUDHI / gudhi-devel / src / python / example / plot_alpha_complex.py View on Github
``````#!/usr/bin/env python

import numpy as np
import gudhi
ac = gudhi.AlphaComplex(off_file='../../data/points/tore3D_1307.off')
st = ac.create_simplex_tree()
points = np.array([ac.get_point(i) for i in range(st.num_vertices())])
# We want to plot the alpha-complex with alpha=0.1.
# We are only going to plot the triangles
triangles = np.array([s[0] for s in st.get_skeleton(2) if len(s[0])==3 and s[1] &lt;= .1])

# First possibility: plotly
import plotly.graph_objects as go
fig = go.Figure(data=[
go.Mesh3d(
x=points[:,0],
y=points[:,1],
z=points[:,2],
i = triangles[:,0],
j = triangles[:,1],
k = triangles[:,2],``````
scikit-tda / cechmate / cechmate / interfaces.py View on Github
``````def compareAlpha():
import gudhi

np.random.seed(2)
# Make a 4-sphere in 5 dimensions
X = np.random.randn(100, 5)

tic = time.time()
Is1 = alpha_filtration(X)
phattime = time.time() - tic
print("Phat Time: %.3g" % phattime)

tic = time.time()
alpha_complex = gudhi.AlphaComplex(points=X.tolist())
simplex_tree = alpha_complex.create_simplex_tree(max_alpha_square=np.inf)
pers = simplex_tree.persistence()
gudhitime = time.time() - tic
Is2 = convertGUDHIPD(pers, len(Is1))

print("GUDHI Time: %.3g" % gudhitime)

I1 = Is1[len(Is1) - 1]
I2 = Is2[len(Is2) - 1]
plt.scatter(I1[:, 0], I1[:, 1])
plt.scatter(I2[:, 0], I2[:, 1], 40, marker="x")
plt.show()``````
scikit-tda / cechmate / PhatCech.py View on Github
``````def compareAlpha():
import gudhi
np.random.seed(2)
# Make a 4-sphere in 5 dimensions
X = np.random.randn(100, 5)

tic = time.time()
Is1 = alpha_filtration(X)
phattime = time.time() - tic
print("Phat Time: %.3g"%phattime)

tic = time.time()
alpha_complex = gudhi.AlphaComplex(points = X.tolist())
simplex_tree = alpha_complex.create_simplex_tree(max_alpha_square = np.inf)
pers = simplex_tree.persistence()
gudhitime = time.time()-tic
Is2 = convertGUDHIPD(pers, len(Is1))

print("GUDHI Time: %.3g"%gudhitime)

I1 = Is1[len(Is1)-1]
I2 = Is2[len(Is2)-1]
plt.scatter(I1[:, 0], I1[:, 1])
plt.scatter(I2[:, 0], I2[:, 1], 40, marker='x')
plt.show()``````

gudhi

The Gudhi library is an open source library for Computational Topology and Topological Data Analysis (TDA).

MIT