multipers 2.3.2b1__cp310-cp310-win_amd64.whl → 2.3.3__cp310-cp310-win_amd64.whl

multipers/plots.py

@@ -1,13 +1,25 @@
 from typing import Optional
+from warnings import warn
 
+import matplotlib.colors as mcolors
 import matplotlib.pyplot as plt
 import numpy as np
+from matplotlib.colors import ListedColormap
+from numpy.typing import ArrayLike
+
+from multipers.array_api import to_numpy
+
+_custom_colors = [
+    "#03045e",
+    "#0077b6",
+    "#00b4d8",
+    "#90e0ef",
+]
+_cmap_ = ListedColormap(_custom_colors)
+_cmap = mcolors.LinearSegmentedColormap.from_list(
+    "continuous_cmap", _cmap_.colors, N=256
+)
 
-try:
-    import torch
-    istensor = torch.is_tensor
-except ImportError:
-    istensor = lambda x: False
 
 def _plot_rectangle(rectangle: np.ndarray, weight, **plt_kwargs):
     rectangle = np.asarray(rectangle)
@@ -69,10 +81,11 @@ def _plot_signed_measure_4(
     **plt_kwargs,  # ignored ftm
 ):
     # compute the maximal rectangle area
-    pts = np.clip(pts, a_min=-np.inf, a_max=np.array((*threshold, *threshold))[None, :])
+    pts = np.clip(pts, a_min=-np.inf,
+                  a_max=np.array((*threshold, *threshold))[None, :])
     alpha_rescaling = 0
     for rectangle, weight in zip(pts, weights):
-        if rectangle[2] > x_smoothing * rectangle[0]:
+        if rectangle[2] >= x_smoothing * rectangle[0]:
             alpha_rescaling = max(
                 alpha_rescaling,
                 (rectangle[2] / x_smoothing - rectangle[0])
@@ -81,7 +94,7 @@ def _plot_signed_measure_4(
     # draw the rectangles
     for rectangle, weight in zip(pts, weights):
         # draw only the rectangles that have not been reduced to the empty set
-        if rectangle[2] > x_smoothing * rectangle[0]:
+        if rectangle[2] >= x_smoothing * rectangle[0]:
             # make the alpha channel proportional to the rectangle's area
             if area_alpha:
                 _plot_rectangle(
@@ -121,11 +134,8 @@ def plot_signed_measure(signed_measure, threshold=None, ax=None, **plt_kwargs):
     else:
         plt.sca(ax)
     pts, weights = signed_measure
-    if istensor(pts):
-        pts = pts.detach().numpy()
-    if istensor(weights):
-        weights = weights.detach().numpy()
-    pts = np.asarray(pts)
+    pts = to_numpy(pts)
+    weights = to_numpy(weights)
     num_pts = pts.shape[0]
     num_parameters = pts.shape[1]
     if threshold is None:
@@ -137,16 +147,9 @@ def plot_signed_measure(signed_measure, threshold=None, ax=None, **plt_kwargs):
             else:
                 pts_ = pts
             threshold = np.max(np.ma.masked_invalid(pts_), axis=0)
-        threshold = np.max([threshold, [plt.gca().get_xlim()[1], plt.gca().get_ylim()[1]]], axis=0)
-    if isinstance(pts, np.ndarray):
-        pass
-    else:
-        import torch
-
-        if isinstance(pts, torch.Tensor):
-            pts = pts.detach().numpy()
-        else:
-            raise Exception("Invalid measure type.")
+        threshold = np.max(
+            [threshold, [plt.gca().get_xlim()[1], plt.gca().get_ylim()[1]]], axis=0
+        )
 
     assert num_parameters in (2, 4)
     if num_parameters == 2:
@@ -168,7 +171,8 @@ def plot_signed_measures(signed_measures, threshold=None, size=4):
             nrows=1, ncols=num_degrees, figsize=(num_degrees * size, size)
         )
     for ax, signed_measure in zip(axes, signed_measures):
-        plot_signed_measure(signed_measure=signed_measure, ax=ax, threshold=threshold)
+        plot_signed_measure(signed_measure=signed_measure,
+                            ax=ax, threshold=threshold)
     plt.tight_layout()
 
 
@@ -178,8 +182,9 @@ def plot_surface(
     fig=None,
     ax=None,
     cmap: Optional[str] = None,
-    discrete_surface=False,
-    has_negative_values=False,
+    discrete_surface: bool = False,
+    has_negative_values: bool = False,
+    contour: bool = True,
     **plt_args,
 ):
     import matplotlib
@@ -196,14 +201,18 @@ def plot_surface(
         if discrete_surface:
             cmap = matplotlib.colormaps["gray_r"]
         else:
-            cmap = matplotlib.colormaps["plasma"]
+            cmap = _cmap
+    if discrete_surface or not contour:
+        # for shading="flat"
+        grid = [np.concatenate([g, [g[-1]*1.1 - .1*g[0]]]) for g in grid]
     if discrete_surface:
         if has_negative_values:
             bounds = np.arange(-5, 6, 1, dtype=int)
         else:
             bounds = np.arange(0, 11, 1, dtype=int)
         norm = matplotlib.colors.BoundaryNorm(bounds, cmap.N, extend="max")
-        im = ax.pcolormesh(grid[0], grid[1], hf.T, cmap=cmap, norm=norm, **plt_args)
+        im = ax.pcolormesh(grid[0], grid[1], hf.T, cmap=cmap,
+                           norm=norm, shading="flat", **plt_args)
         cbar = fig.colorbar(
             matplotlib.cm.ScalarMappable(cmap=cmap, norm=norm),
             spacing="proportional",
@@ -211,7 +220,14 @@ def plot_surface(
         )
         cbar.set_ticks(ticks=bounds, labels=bounds)
         return im
-    im = ax.pcolormesh(grid[0], grid[1], hf.T, cmap=cmap, **plt_args)
+
+    if contour:
+        levels = plt_args.pop("levels", 50)
+        im = ax.contourf(grid[0], grid[1], hf.T,
+                         cmap=cmap, levels=levels, **plt_args)
+    else:
+        im = ax.pcolormesh(grid[0], grid[1], hf.T,
+                           cmap=cmap,  shading="flat", **plt_args)
     return im
 
 
@@ -255,7 +271,7 @@ def plot2d_PyModule(
     dimension=-1,
     separated=False,
     min_persistence=0,
-    alpha=.8,
+    alpha=None,
     verbose=False,
     save=False,
     dpi=200,
@@ -273,12 +289,14 @@ def plot2d_PyModule(
 
         shapely = True and shapely
     except ImportError:
-        from warnings import warn
-
         shapely = False
         warn(
             "Shapely not installed. Fallbacking to matplotlib. The plots may be inacurate."
         )
+    if alpha is None:
+        alpha = 0.8 if shapely else 1
+    if not shapely and alpha != 1:
+        warn("Opacity without shapely will lead to incorect plots.")
     cmap = (
         matplotlib.colormaps["Spectral"] if cmap is None else matplotlib.colormaps[cmap]
     )
@@ -304,25 +322,30 @@ def plot2d_PyModule(
                         trivial_summand = False
                     if shapely:
                         list_of_rect.append(
-                            _rectangle_box(birth[0], birth[1], death[0], death[1])
+                            _rectangle_box(
+                                birth[0], birth[1], death[0], death[1])
                         )
                     else:
                         list_of_rect.append(
-                            _rectangle(birth, death, cmap(i / n_summands), alpha)
+                            _rectangle(birth, death, cmap(
+                                i / n_summands), alpha)
                         )
         if not (trivial_summand):
             if separated:
                 fig, ax = plt.subplots()
-                ax.set(xlim=[box[0][0], box[1][0]], ylim=[box[0][1], box[1][1]])
+                ax.set(xlim=[box[0][0], box[1][0]],
+                       ylim=[box[0][1], box[1][1]])
             if shapely:
                 summand_shape = union_all(list_of_rect)
                 if type(summand_shape) is _Polygon:
                     xs, ys = summand_shape.exterior.xy
-                    ax.fill(xs, ys, alpha=alpha, fc=cmap(i / n_summands), ec="None")
+                    ax.fill(xs, ys, alpha=alpha, fc=cmap(
+                        i / n_summands), ec="None")
                 else:
                     for polygon in summand_shape.geoms:
                         xs, ys = polygon.exterior.xy
-                        ax.fill(xs, ys, alpha=alpha, fc=cmap(i / n_summands), ec="None")
+                        ax.fill(xs, ys, alpha=alpha, fc=cmap(
+                            i / n_summands), ec="None")
             else:
                 for rectangle in list_of_rect:
                     ax.add_patch(rectangle)
@@ -341,3 +364,107 @@ def plot2d_PyModule(
         if dimension >= 0:
             plt.title(rf"$H_{dimension}$ $2$-persistence")
     return
+
+
+def plot_simplicial_complex(
+    st, pts: ArrayLike, x: float, y: float, mma=None, degree=None
+):
+    """
+    Scatters the points, with the simplices in the filtration at coordinates (x,y).
+    if an mma module is given, plots it in a second axis
+    """
+    if mma is not None:
+        fig, (a, b) = plt.subplots(ncols=2, figsize=(15, 5))
+        plt.sca(a)
+        plot_simplicial_complex(st, pts, x, y)
+        plt.sca(b)
+        mma.plot(degree=degree)
+        box = mma.get_box()
+        a, b, c, d = box.ravel()
+        mma.plot(degree=1, min_persistence=0.01)
+        plt.vlines(x, b, d, color="k", linestyle="--")
+        plt.hlines(y, a, c, color="k", linestyle="--")
+        plt.scatter([x], [y], c="r", zorder=10)
+        plt.text(x + 0.01 * (b - a), y + 0.01 * (d - c), f"({x},{y})")
+        return
+
+    pts = np.asarray(pts)
+    values = np.array([-f[1] for s, f in st.get_skeleton(0)])
+    qs = np.quantile(values, np.linspace(0, 1, 100))
+
+    def color_idx(d):
+        return np.searchsorted(qs, d) / 100
+
+    from matplotlib.pyplot import get_cmap
+
+    def color(d):
+        return get_cmap("viridis")([0, color_idx(d), 1])[1]
+
+    cols_pc = np.asarray([color(v) for v in values])
+    ax = plt.gca()
+    for s, f in st:  # simplexe, filtration
+        density = -f[1]
+        if len(s) <= 1 or f[0] > x or density < -y:  # simplexe  = point
+            continue
+        if len(s) == 2:  # simplexe = segment
+            xx = np.array([pts[a, 0] for a in s])
+            yy = np.array([pts[a, 1] for a in s])
+            plt.plot(xx, yy, c=color(density), alpha=1,
+                     zorder=10 * density, lw=1.5)
+        if len(s) == 3:  # simplexe = triangle
+            xx = np.array([pts[a, 0] for a in s])
+            yy = np.array([pts[a, 1] for a in s])
+            _c = color(density)
+            ax.fill(xx, yy, c=_c, alpha=0.3, zorder=0)
+    out = plt.scatter(pts[:, 0], pts[:, 1], c=cols_pc, zorder=10, s=10)
+    ax.set_aspect(1)
+    return out
+
+
+def plot_point_cloud(
+    pts,
+    function,
+    x,
+    y,
+    mma=None,
+    degree=None,
+    ball_alpha=0.3,
+    point_cmap="viridis",
+    color_bias=1,
+    ball_color=None,
+    point_size=20,
+):
+    if mma is not None:
+        fig, (a, b) = plt.subplots(ncols=2, figsize=(15, 5))
+        plt.sca(a)
+        plot_point_cloud(pts, function, x, y)
+        plt.sca(b)
+        mma.plot(degree=degree)
+        box = mma.get_box()
+        a, b, c, d = box.ravel()
+        mma.plot(degree=1, min_persistence=0.01)
+        plt.vlines(x, b, d, color="k", linestyle="--")
+        plt.hlines(y, a, c, color="k", linestyle="--")
+        plt.scatter([x], [y], c="r", zorder=10)
+        plt.text(x + 0.01 * (b - a), y + 0.01 * (d - c), f"({x},{y})")
+        return
+    values = -function
+    qs = np.quantile(values, np.linspace(0, 1, 100))
+
+    def color_idx(d):
+        return np.searchsorted(qs, d * color_bias) / 100
+
+    from matplotlib.collections import PatchCollection
+    from matplotlib.pyplot import get_cmap
+
+    def color(d):
+        return get_cmap(point_cmap)([0, color_idx(d), 1])[1]
+
+    _colors = np.array([color(v) for v in values])
+    ax = plt.gca()
+    idx = function <= y
+    circles = [plt.Circle(pt, x) for pt, c in zip(pts[idx], function)]
+    pc = PatchCollection(circles, alpha=ball_alpha, color=ball_color)
+    ax.add_collection(pc)
+    plt.scatter(*pts.T, c=_colors, s=point_size)
+    ax.set_aspect(1)

multipers/point_measure.pyx

@@ -11,6 +11,7 @@ from collections import defaultdict
 cnp.import_array()
 from scipy import sparse
 
+from multipers.array_api import api_from_tensor
 
 import multipers.grids as mpg
 
@@ -31,7 +32,6 @@ import cython
 cimport cython
 
 
-
 # from scipy.sparse import coo_array
 # from scipy.ndimage import convolve1d
 
@@ -169,7 +169,7 @@ def sparsify(x):
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-def clean_signed_measure(some_float[:,:] pts, some_int[:] weights, dtype = np.float32):
+def clean_signed_measure_old(some_float[:,:] pts, some_int[:] weights, dtype = np.float32):
     """
     Sum the diracs at the same locations. i.e.,
     returns the minimal sized measure to represent the input.
@@ -190,6 +190,14 @@ def clean_signed_measure(some_float[:,:] pts, some_int[:] weights, dtype = np.fl
     new_weights = new_weights[idx]
     return (new_pts, new_weights)
 
+def clean_signed_measure(pts, w, dtype=np.int32):
+    api = api_from_tensor(pts)
+    _, idx, inv = np.unique(api.asnumpy(pts), return_index=True, return_inverse=True, axis=0)
+    new_w = np.bincount(inv, weights=w).astype(w.dtype)
+    pts, w = pts[idx], new_w
+    idx = w!=0
+    return pts[idx],w[idx]
+
 def clean_sms(sms):
     """
     Sum the diracs at the same locations. i.e.,
@@ -324,3 +332,64 @@ def estimate_rank_from_rank_sm(sm:tuple, a, b)->np.int64:
     return w[idx].sum()
 
 
+def rectangle_to_hook_minimal_signed_barcode(pts,w,):
+    if pts.shape[1] != 4:
+        raise NotImplementedError(
+            "Only works for 2-parameter persistence modules for the moment."
+        )
+    api = api_from_tensor(pts)
+    pts = api.astensor(pts)
+    w = np.asarray(w)
+    ## [a,b], [a, a0b1], [a,b0a1], proj, V,H 
+
+    projectives_idx = (pts[:,3] == np.inf) * (pts[:,2] == np.inf)
+    pts_proj = pts[projectives_idx]
+    w_proj = w[projectives_idx]
+    pts = pts[~projectives_idx]
+    w = w[~projectives_idx]
+    # print("projectives:", pts_proj)
+    
+    vert_blocks_idx = pts[:,3] == np.inf
+    pts_V = pts[vert_blocks_idx]
+    w_V = w[vert_blocks_idx]
+    pts_V[:,3] = pts_V[:,1]
+    pts = pts[~vert_blocks_idx]
+    w = w[~vert_blocks_idx]
+    # print("vertical:", pts_V)
+
+    h_idx = pts[:,2] == np.inf
+    pts_H = pts[h_idx]
+    w_H = w[h_idx]
+    pts_H[:,2] = pts_H[:,0]
+    pts = pts[~h_idx]
+    w = w[~h_idx]
+    # print("horizontal:", pts_H)
+    
+    
+    new_w = api.cat([-w, w, w,  w_proj,w_V,w_H])
+    
+    pts_b0a1 = api.tensor(pts)
+    pts_b0a1[:,3] = pts[:,1]
+    pts_a0b1 = api.tensor(pts)
+    pts_a0b1[:,2] = pts[:,0]
+    
+    new_pts = api.cat([
+        pts,
+        pts_b0a1,
+        pts_a0b1,
+        pts_proj, 
+        pts_V,
+        pts_H
+    ], axis=0)
+    # pts,w = new_pts,new_w
+    pts,w = clean_signed_measure(new_pts,new_w)
+
+    # Everything infinite is handled separately anyway
+    # inf0 = pts[:,2] == np.inf
+    # inf1 = pts[:,3] == np.inf
+    # pts[inf0,3] = pts[inf0,1]
+    # pts[inf1,2] = pts[inf1,0]
+    # pts,w = clean_signed_measure(pts,w)  
+
+    return pts,w
+

multipers/simplex_tree_multi.pxd

@@ -117,8 +117,8 @@ cdef extern from "Simplex_tree_multi_interface.h" namespace "Gudhi::multiparamet
     void to_std(intptr_t, Line[double],int ) nogil 
     void to_std_linear_projection(intptr_t, vector[double]) nogil
     void squeeze_filtration_inplace(vector[vector[double]] &, bool) nogil
-    void squeeze_filtration(intptr_t, vector[vector[double]] &) nogil
-    void unsqueeze_filtration(intptr_t, vector[vector[double]] &) nogil
+    void squeeze_filtration(intptr_t, vector[vector[double]] &) except + nogil
+    void unsqueeze_filtration(intptr_t, vector[vector[double]] &) except + nogil
     vector[vector[vector[value_type]]] get_filtration_values(const vector[int]&) nogil