morphomatics 4.0__py3-none-any.whl

morphomatics/geom/surface.py

@@ -0,0 +1,208 @@
+################################################################################
+#                                                                              #
+#   This file is part of the Morphomatics library                              #
+#       see https://github.com/morphomatics/morphomatics                       #
+#                                                                              #
+#   Copyright (C) 2024 Zuse Institute Berlin                                   #
+#                                                                              #
+#   Morphomatics is distributed under the terms of the MIT License.            #
+#       see $MORPHOMATICS/LICENSE                                              #
+#                                                                              #
+################################################################################
+
+
+import numpy as np
+from scipy import sparse
+
+from .misc import memoize, gradient_matrix_ambient
+
+
+
+class Surface(object):
+    """ Triangular surface geom. """
+
+    def __init__(self, v, f):
+        """
+        :arg v: #v-by-dim array of vertex coordinate
+        :arg f: #f-by-3 array of triangles (each given as indices into \a v)
+        """
+        # cache for memoization
+        self._cache_v = dict()
+        self._cache_f = dict()
+
+        self.v = np.asarray(v).astype(np.double, copy=False)
+        self.f = np.asarray(f)
+
+    @property
+    def v(self):
+        return self.__v
+
+    @v.setter
+    def v(self, v):
+        self.__v = v
+        self._cache_v.clear()
+
+    @property
+    def f(self):
+        return self.__f
+
+    @f.setter
+    def f(self, f):
+        self.__f = f
+        self._cache_v.clear()
+        self._cache_f.clear()
+
+    @property
+    @memoize('_cache_v')
+    def grad(self):
+        """ Gradient of a scalar function defined on piecewise linear elements
+        (see: geom.misc.gradient_matrix_ambient) """
+        return gradient_matrix_ambient(self.v, self.f)
+
+    @property
+    @memoize('_cache_v')
+    def div(self):
+        """Divergence operator"""
+        mass = self.face_areas
+        d = self.grad.shape[0] / len(mass) # ambient dim.
+        return self.grad.T @ sparse.diags(np.repeat(mass, d), 0)
+
+    @property
+    @memoize('_cache_v')
+    def face_areas(self):
+        """Area of triangles."""
+        # Compute cross-product of edges
+        ppts = self.v[self.f]
+        nnfnorms = np.cross(ppts[:, 1] - ppts[:, 0],
+                            ppts[:, 2] - ppts[:, 0])
+        # Compute vector length
+        return np.sqrt((nnfnorms ** 2).sum(-1)) / 2
+
+    @property
+    @memoize('_cache_f')
+    def inner_edges(self):
+        """
+        Extract inner edges of an oriented, triangle surface.
+        :return: sparse matrix with inner edge ids as entries (indexed by resp. faces).
+        """
+        m = len(self.f)
+        n = self.f.max() + 1
+
+        e1 = sparse.coo_matrix((np.ones(m), (self.f[:, 0], self.f[:, 1])), (n, n))
+        e2 = sparse.coo_matrix((np.ones(m), (self.f[:, 1], self.f[:, 2])), (n, n))
+        e3 = sparse.coo_matrix((np.ones(m), (self.f[:, 2], self.f[:, 0])), (n, n))
+        D = (e1 + e2 + e3).tocsr()
+
+        # boundary edges as sparse matrix
+        E = (D - D.T).tocsr()
+        # inner edges as sparse matrix
+        F = 0.5*(D + D.T - np.absolute(D - D.T))
+        F.eliminate_zeros()
+
+        off = 1
+        f1 = sparse.coo_matrix((np.arange(off, m+off), (self.f[:, 0], self.f[:, 1])), (n, n)).tocsr()
+        f2 = sparse.coo_matrix((np.arange(off, m+off), (self.f[:, 1], self.f[:, 2])), (n, n)).tocsr()
+        f3 = sparse.coo_matrix((np.arange(off, m+off), (self.f[:, 2], self.f[:, 0])), (n, n)).tocsr()
+
+        ff = f1 +f2 +f3
+
+        FF = F.multiply(ff)
+        FFU = sparse.triu(FF).tocsr()
+
+        edgesI = FFU.tocoo().row
+        edgesJ = FFU.tocoo().col
+
+        edgeTriI = np.reshape(np.asarray(FF[edgesI[:], edgesJ[:]]), edgesI.shape[0]) - 1
+        edgeTriJ = np.reshape(np.asarray(FF[edgesJ[:], edgesI[:]]), edgesJ.shape[0]) - 1
+
+        # k-th (inner) edge, s.t. FFU(edgesI[k], edgesJ[k]) -> FFU(edgesJ[k], edgesI[k])
+        tris2InnerEdgeId = sparse.coo_matrix((np.arange(1, FFU.getnnz()+1), (edgeTriI[:], edgeTriJ[:])), (m, m))
+        tris2InnerEdgeId = tris2InnerEdgeId + tris2InnerEdgeId.T
+        tris2InnerEdgeId.data = tris2InnerEdgeId.data -1
+
+        return tris2InnerEdgeId.tocsr()
+
+    @property
+    @memoize('_cache_v')
+    def edge_areas(self):
+        inner_edge = sparse.triu(self.inner_edges)
+        areas=np.zeros(inner_edge.data.shape[0])
+        areas[inner_edge.data[:]] = 1.0/3.0 * ( self.face_areas[inner_edge.row[:]] + self.face_areas[inner_edge.col[:]] )
+        return areas
+
+    @property
+    @memoize('_cache_f')
+    def neighbors(self):
+        """
+         Provides information on face neighbors.
+         :return: idx_1, idx_2, idx_3, n_1, n_2, n_3,
+         where idx_1, idx_2, idx_3 are boolean index arrays for faces with at least one (idx_1), at least two (idx_2) and three (idx_3) neighbors;
+         where n_1, n_2, n_3 are n x k array storing the respective neighbors per face for all faces with at least one (n_1), at least two (n_2)
+         and three (n_3) neighbors.
+         """
+        # neighbors per face
+        neighs = np.asarray(np.split(self.inner_edges.indices, self.inner_edges.indptr[1:-1]), dtype=object)
+        nNeighs = np.asarray(list(map(np.shape, neighs))).ravel()
+
+        idx_1 = (nNeighs == 1)
+        idx_2 = (nNeighs == 2)
+        idx_3 = (nNeighs == 3)
+
+        neigh_pad = np.zeros((neighs.shape[0], 3)).astype(int)
+
+        if np.count_nonzero(idx_1):
+            neigh_pad[idx_1, 0:1] = np.asarray(list(neighs[idx_1]))
+        if np.count_nonzero(idx_2):
+            neigh_pad[idx_2, 0:2] = np.asarray(list(neighs[idx_2]))
+        if np.count_nonzero(idx_3):
+            neigh_pad[idx_3, 0:3] = np.asarray(list(neighs[idx_3]))
+
+        idx_1 = (nNeighs > 0)
+        idx_2 = (nNeighs > 1)
+        idx_3 = (nNeighs > 2)
+
+        n_1 = neigh_pad[idx_1]
+        n_2 = neigh_pad[idx_2]
+        n_3 = neigh_pad[idx_3]
+
+        return idx_1, idx_2, idx_3, n_1, n_2, n_3
+
+    def copy(self):
+        """
+        :return: copy of this surface
+        """
+        return Surface(self.v.copy(), self.f.copy())
+
+    def boundary(self):
+        """
+        Extract boundary curves of an oriented, triangle surface.
+        :return: List of boundary curves (list of vertex indices).
+        """
+        m = len(self.f)
+        n = self.f.max() + 1
+        # boundary edges as sparse matrix
+        e1 = sparse.coo_matrix((np.ones(m), (self.f[:, 0], self.f[:, 1])), (n, n))
+        e2 = sparse.coo_matrix((np.ones(m), (self.f[:, 1], self.f[:, 2])), (n, n))
+        e3 = sparse.coo_matrix((np.ones(m), (self.f[:, 2], self.f[:, 0])), (n, n))
+        E = (e1 - e1.T + e2 - e2.T + e3 - e3.T).tocsr()
+        E.sort_indices()
+
+        if E.nnz == 0:
+            return None
+
+        # extract boundary curves
+        boundaries = []
+
+        nnz = E.getnnz(1)
+        for i in range(n):
+            if nnz[i] == 0: continue
+            # new boundary curve
+            bnd = [i]
+            while True:
+                j = (E.getrow(bnd[-1]) > 0).indices[0]
+                nnz[j] = 0  # mark as part of a processed bnd. curve
+                if j == i: break
+                bnd.append(j)
+            boundaries.append(bnd)
+
+        return boundaries

morphomatics/graph/__init__.py

@@ -0,0 +1,13 @@
+################################################################################
+#                                                                              #
+#   This file is part of the Morphomatics library                              #
+#       see https://github.com/morphomatics/morphomatics                       #
+#                                                                              #
+#   Copyright (C) 2024 Zuse Institute Berlin                                   #
+#                                                                              #
+#   Morphomatics is distributed under the terms of the MIT License.            #
+#       see $MORPHOMATICS/LICENSE                                              #
+#                                                                              #
+################################################################################
+
+from .operators import mfdg_laplace, mfdg_gradient, max_pooling, mean_pooling, in_degree_centrality, out_degree_centrality

morphomatics/graph/operators.py

@@ -0,0 +1,124 @@
+################################################################################
+#                                                                              #
+#   This file is part of the Morphomatics library                              #
+#       see https://github.com/morphomatics/morphomatics                       #
+#                                                                              #
+#   Copyright (C) 2024 Zuse Institute Berlin                                   #
+#                                                                              #
+#   Morphomatics is distributed under the terms of the MIT License.            #
+#       see $MORPHOMATICS/LICENSE                                              #
+#                                                                              #
+################################################################################
+
+import jax
+from jax import tree_util as tree
+import jax.numpy as jnp
+import jraph
+
+from morphomatics.manifold import Manifold
+
+
+def mfdg_gradient(M: Manifold, graph: jraph.GraphsTuple) -> jnp.array:
+    """Given a graph with manifold-valued features returns the gradient as defined in https://arxiv.org/abs/1702.05293
+
+    :param M: feature manifold
+    :param graph: M-valued graph
+    :return: edge gradients
+    """
+
+    # gradients on directed edges are stored along first axis (orderd given by graph.senders/receivers)
+    logs = jax.vmap(M.connec.log)(graph.nodes[graph.senders], graph.nodes[graph.receivers])
+
+    return vec_times_kd(jnp.sqrt(graph.edges), logs)
+
+
+def mfdg_laplace(M: Manifold, graph: jraph.GraphsTuple) -> jnp.array:
+    """Given a graph with manifold-valued features returns the isotropic graph 2-Laplacian as defined in
+    https://arxiv.org/abs/1702.05293
+
+    :param M: feature manifold
+    :param graph: M-valued graph
+    :return: Laplace vectors at node feature
+    """
+
+    # multiply negative gradients with corresponding square root edge weights
+    weighted_gradients = vec_times_kd(jnp.sqrt(graph.edges), -mfdg_gradient(M, graph))
+
+    return jax.ops.segment_sum(weighted_gradients, graph.senders, num_segments=len(graph.nodes))  # already ordered
+
+
+def max_pooling(G: jraph.GraphsTuple, z: jnp.ndarray) -> jnp.array:
+    """Graph-wise max pooling of features z over graph G.
+
+    :param G: graph
+    :param z: scalar graph features
+    :return: max value for each graph in the batch
+    """
+    sum_n_node = tree.tree_leaves(G.nodes)[0].shape[0]
+    n_graph = G.n_node.shape[0]
+    graph_idx = jnp.arange(n_graph)
+
+    node_gr_idx = jnp.repeat(
+        graph_idx, G.n_node, axis=0, total_repeat_length=sum_n_node)
+
+    # return constant (not -inf) for graphs without edges as these can appear through batching
+    return jraph.segment_max_or_constant(z, node_gr_idx, n_graph, indices_are_sorted=True)
+
+
+def mean_pooling(G: jraph.GraphsTuple, z: jnp.ndarray) -> jnp.array:
+    """Graph-wise mean pooling of features z over graph G.
+
+    :param G: graph
+    :param z: scalar graph features
+    :return: mean value for each graph in the batch
+    """
+    sum_n_node = tree.tree_leaves(G.nodes)[0].shape[0]
+    n_graph = G.n_node.shape[0]
+    graph_idx = jnp.arange(n_graph)
+
+    node_gr_idx = jnp.repeat(
+        graph_idx, G.n_node, axis=0, total_repeat_length=sum_n_node)
+
+    return jax.ops.segment_sum(z, node_gr_idx, n_graph, indices_are_sorted=True) / jnp.clip(G.n_node, 1).reshape((n_graph,) + (1,)*(z.ndim-1))
+
+
+def in_degree_centrality(G: jraph.GraphsTuple) -> float:
+    """ Normalized in-degree centrality
+
+    """
+    def f(n: int):
+        return jnp.count_nonzero(G.receivers == n)
+
+    d = jax.vmap(f)(jnp.arange(G.n_node[0]))
+
+    return d / jnp.max(d)
+
+
+def out_degree_centrality(G: jraph.GraphsTuple) -> float:
+    """ Normalized out-degree centrality
+
+    """
+    def f(n: int):
+        return jnp.count_nonzero(G.senders == n)
+
+    d = jax.vmap(f)(jnp.arange(G.n_node[0]))
+
+    return d / jnp.max(d)
+
+
+def atleast_kd(array, k) -> jnp.array:
+    """Make array at least k-dimensional"""
+    array = jnp.asarray(array)
+    new_shape = array.shape + (1,) * (k - array.ndim)
+    return array.reshape(new_shape)
+
+
+def vec_times_kd(vec: jnp.array, tensor: jnp.array) -> jnp.array:
+    """Multiply the i-th slice (along first axis) of a tensor with the i-th element of a given vector
+
+       The vector can be 2-dimensional as long as one of the dimensions is of size one, i.e, it is a proper vector.
+
+       Attention: non-jitable with asserts
+    """
+
+    return atleast_kd(vec, len(tensor.shape)) * tensor

morphomatics/manifold/__init__.py

@@ -0,0 +1,46 @@
+################################################################################
+#                                                                              #
+#   This file is part of the Morphomatics library                              #
+#       see https://github.com/morphomatics/morphomatics                       #
+#                                                                              #
+#   Copyright (C) 2024 Zuse Institute Berlin                                   #
+#                                                                              #
+#   Morphomatics is distributed under the terms of the MIT License.            #
+#       see $MORPHOMATICS/LICENSE                                              #
+#                                                                              #
+################################################################################
+
+# Abstract classes for manifolds
+from .lie_group import LieGroup
+from .connection import Connection
+from .metric import Metric
+from .manifold import Manifold
+
+from. power_manifold import PowerManifold
+from. product_manifold import ProductManifold
+
+# Standard manifolds
+from .euclidean import Euclidean
+from .gl_p_n import GLpn
+from .so_3 import SO3
+from .se_3 import SE3
+from .spd import SPD
+from .sphere import Sphere
+from .hyperbolic_space import HyperbolicSpace
+from .grassmann import Grassmann
+from .tangent_bundle import TangentBundle
+
+# PyManopt Wrapper for manifolds
+from .manopt_wrapper import ManoptWrap
+
+# Shape spaces
+from .shape_space import ShapeSpace
+from .fundamental_coords import FundamentalCoords
+from .differential_coords import DifferentialCoords
+from .point_distribution_model import PointDistributionModel
+from .gl_p_coords import GLpCoords
+from .kendall import Kendall
+
+# Space of shape trajectories
+from .bezierfold import Bezierfold
+from .cubic_bezierfold import CubicBezierfold