Initial commit based of previous repositories contents

example.py

@@ -0,0 +1,188 @@
+import math
+
+import matplotlib.pyplot as plt
+import numpy as np
+# import squidpy as sq
+from graph_tool.all import *
+
+from src import centrality
+from src import plot
+from src import fitting
+
+
+def merfish():
+    """
+    Merfish dataset from `squidpy`.
+    """
+    adata = sq.datasets.merfish()
+    adata = adata[adata.obs.Bregma == -9].copy()
+    return adata
+
+
+def mibitof():
+    """
+    Mibitof dataset from `squidpy`.
+    """
+    adata = sq.datasets.mibitof()
+    return adata
+
+def random_graph(n=5000, seed=None):
+    """
+    Uniformly random point cloud generation.
+    `n` [int] Number of points to generate. Default 5000 seems like a good starting point in point density and corresponding runtime for the subsequent calculations.
+    @return [numpy.ndarray] Array of shape(n, 2) containing the coordinates for each point of the generated point cloud.
+    """
+    if seed is None:
+        import secrets
+        seed = secrets.randbits(128)
+    rng = np.random.default_rng(seed=seed)
+    return rng.random((n, 2)), seed
+
+
+def spatial_graph(adata):
+    """
+    Generate the spatial graph using delaunay for the given `adata`.
+    `adata` will contain the calculated spatial graph contents in the keys
+    `adata.obps['spatial_distances']` and `adata.obsm['spatial']` afterwards too.
+    @return [Graph] generated networkx graph from adata['spatial_distances']
+    """
+    g, pos = graph_tool.generation.triangulation(adata, type="delaunay")
+    g.vp["pos"] = pos
+    weight = g.new_edge_property("double")
+    for e in g.edges():
+        weight[e] = math.sqrt(sum(map(abs, pos[e.source()].a - pos[e.target()].a)))**2
+    return g, weight
+
+# generate spatial graph from a given dataset
+# g, weight = spatial_graph(merfish().obsm['spatial'])
+for i in range(1, 10):
+    points, seed = random_graph()
+    g, weight = spatial_graph(points)
+    g = GraphView(g)
+
+    # calculate centrality values
+    vp = closeness(g, weight=weight)
+    vp.a = np.nan_to_num(vp.a) # correct floating point values
+    # ep.a = np.nan_to_num(ep.a) # correct floating point values
+
+    # calculate convex hull
+    convex_hull = centrality.convex_hull(g)
+
+    # plot graph with convex_hull
+    fig = plt.figure(figsize=(15, 5))
+    ax0, ax1 = fig.subplots(1, 2)
+    plot.graph_plot(fig, ax0, g, vp, convex_hull, f"Random Graph (seed: {seed})\nCloseness")
+
+    # generate model based on convex hull and associated centrality values
+    quantification = plot.quantification_data(g, vp, convex_hull)
+
+    # optimize model's piece-wise linear function
+    d = quantification[:, 0]
+    C = quantification[:, 1]
+    m_opt, c0_opt, b_opt = fitting.fit_piece_wise_linear(d, C)
+
+    # TODO
+    # should this be part of the plotting function itself, it should not be necessary for me to do this
+    d_curve = np.linspace(min(d), max(d), 500)
+    C_curve = np.piecewise(
+        d_curve,
+        [d_curve <= b_opt, d_curve > b_opt],
+        [lambda x: m_opt * x + c0_opt, lambda x: m_opt * b_opt + c0_opt]
+    )
+    # plot model containing modeled piece-wise linear function
+    plot.quantification_plot(ax1, quantification, d_curve, C_curve, 'Models')
+
+    # linear regression model
+    m_reg, c_reg = fitting.fit_linear_regression(d, C)
+    x = np.linspace(min(d), max(d), 500)
+    y = m_reg * x + c_reg
+    ax1.plot(x, y, color='k', linewidth=1, label="Simple Linear Regression")
+    ax1.legend()
+
+    fig.savefig(f"random_point_clouds/{i}_closeness.svg", format='svg')
+
+    # ---------------------------------------------------------------------------------------------
+
+    # calculate centrality values
+    vp, ep = betweenness(g, weight=weight)
+    vp.a = np.nan_to_num(vp.a) # correct floating point values
+    # ep.a = np.nan_to_num(ep.a) # correct floating point values
+
+    # calculate convex hull
+    convex_hull = centrality.convex_hull(g)
+
+    # plot graph with convex_hull
+    fig = plt.figure(figsize=(15, 5))
+    ax0, ax1 = fig.subplots(1, 2)
+    plot.graph_plot(fig, ax0, g, vp, convex_hull, f"Random Graph (seed: {seed})\nBetweenness")
+
+    # generate model based on convex hull and associated centrality values
+    quantification = plot.quantification_data(g, vp, convex_hull)
+
+    # optimize model's piece-wise linear function
+    d = quantification[:, 0]
+    C = quantification[:, 1]
+    m_opt, c0_opt, b_opt = fitting.fit_piece_wise_linear(d, C)
+
+    # TODO
+    # should this be part of the plotting function itself, it should not be necessary for me to do this
+    d_curve = np.linspace(min(d), max(d), 500)
+    C_curve = np.piecewise(
+        d_curve,
+        [d_curve <= b_opt, d_curve > b_opt],
+        [lambda x: m_opt * x + c0_opt, lambda x: m_opt * b_opt + c0_opt]
+    )
+    # plot model containing modeled piece-wise linear function
+    plot.quantification_plot(ax1, quantification, d_curve, C_curve, 'Models')
+
+    # linear regression model
+    m_reg, c_reg = fitting.fit_linear_regression(d, C)
+    x = np.linspace(min(d), max(d), 500)
+    y = m_reg * x + c_reg
+    ax1.plot(x, y, color='k', linewidth=1, label="Simple Linear Regression")
+    ax1.legend()
+
+    fig.savefig(f"random_point_clouds/{i}_betweenness.svg", format='svg')
+
+    # ---------------------------------------------------------------------------------------------
+    
+    # calculate centrality values
+    vp = pagerank(g, weight=weight)
+    vp.a = np.nan_to_num(vp.a) # correct floating point values
+    # ep.a = np.nan_to_num(ep.a) # correct floating point values
+
+    # calculate convex hull
+    convex_hull = centrality.convex_hull(g)
+
+    # plot graph with convex_hull
+    fig = plt.figure(figsize=(15, 5))
+    ax0, ax1 = fig.subplots(1, 2)
+    plot.graph_plot(fig, ax0, g, vp, convex_hull, f"Random Graph (seed: {seed})\nPageRank")
+
+    # generate model based on convex hull and associated centrality values
+    quantification = plot.quantification_data(g, vp, convex_hull)
+
+    # optimize model's piece-wise linear function
+    d = quantification[:, 0]
+    C = quantification[:, 1]
+    m_opt, c0_opt, b_opt = fitting.fit_piece_wise_linear(d, C)
+
+    # TODO
+    # should this be part of the plotting function itself, it should not be necessary for me to do this
+    d_curve = np.linspace(min(d), max(d), 500)
+    C_curve = np.piecewise(
+        d_curve,
+        [d_curve <= b_opt, d_curve > b_opt],
+        [lambda x: m_opt * x + c0_opt, lambda x: m_opt * b_opt + c0_opt]
+    )
+    # plot model containing modeled piece-wise linear function
+    plot.quantification_plot(ax1, quantification, d_curve, C_curve, 'Models')
+
+    # linear regression model
+    m_reg, c_reg = fitting.fit_linear_regression(d, C)
+    x = np.linspace(min(d), max(d), 500)
+    y = m_reg * x + c_reg
+    ax1.plot(x, y, color='k', linewidth=1, label="Simple Linear Regression")
+    ax1.legend()
+
+    fig.savefig(f"random_point_clouds/{i}_pagerank.svg", format='svg')