multipers 1.1.3__cp311-cp311-macosx_11_0_universal2.whl

multipers/multiparameter_module_approximation.pyx

@@ -0,0 +1,311 @@
+"""!
+@package mma
+@brief Files containing the C++ cythonized functions.
+@author David Loiseaux
+@copyright Copyright (c) 2022 Inria.
+"""
+
+# distutils: language = c++
+
+###########################################################################
+## PYTHON LIBRARIES
+import gudhi as gd
+import numpy as np
+from typing import List
+import pickle as pk
+
+###########################################################################
+## CPP CLASSES
+from libc.stdint cimport intptr_t
+from libc.stdint cimport uintptr_t
+
+###########################################################################
+## CYTHON TYPES
+from libcpp.vector cimport vector
+from libcpp.utility cimport pair
+#from libcpp.list cimport list as clist
+from libcpp cimport bool
+from libcpp cimport int
+from typing import Iterable
+from cython.operator import dereference
+#########################################################################
+## Multipersistence Module Approximation Classes
+from multipers.mma_structures cimport Module, Box, pair, boundary_matrix
+from multipers.slicer cimport *
+
+
+#########################################################################
+## Small hack for typing
+from gudhi import SimplexTree
+from multipers.simplex_tree_multi import SimplexTreeMulti
+from multipers.slicer import Slicer, SlicerClement,SlicerVineGraph,SlicerVineSimplcial
+from multipers.mma_structures import PyModule
+# cimport numpy as cnp
+# cnp.import_array()
+
+###################################### MMA
+cdef extern from "multiparameter_module_approximation/approximation.h" namespace "Gudhi::multiparameter::mma":
+	Module compute_vineyard_barcode_approximation(boundary_matrix, vector[Finitely_critical_multi_filtration] , value_type precision, Box[value_type] &, bool threshold, bool complete, bool multithread, bool verbose) nogil
+	# TODO : tempita
+	Module multiparameter_module_approximation(SimplicialVineGraphTruc&, value_type, Box[value_type]&, bool, bool, bool) nogil
+
+	Module multiparameter_module_approximation(SimplicialVineMatrixTruc&, value_type, Box[value_type]&, bool, bool, bool) nogil
+	Module multiparameter_module_approximation(GeneralVineTruc&, value_type, Box[value_type]&, bool, bool, bool) nogil
+	Module multiparameter_module_approximation(GeneralVineClementTruc&, value_type, Box[value_type]&, bool, bool, bool) nogil
+
+# TODO : remove when old is deprecated
+cdef extern from "multiparameter_module_approximation/format_python-cpp.h" namespace "Gudhi::multiparameter::mma":
+	pair[boundary_matrix, vector[Finitely_critical_multi_filtration]] simplextree_to_boundary_filtration(uintptr_t)
+
+def module_approximation_old(
+		st:SimplexTreeMulti|None=None,
+		max_error:float|None = None,
+		box:list|np.ndarray|None = None,
+		threshold:bool = False,
+		complete:bool = True,
+		multithread:bool = False, 
+		verbose:bool = False,
+		ignore_warning:bool = False,
+		nlines:int = 500,
+		max_dimension=np.inf,
+		boundary = None,
+		filtration = None,
+		return_timings:bool = False,
+		**kwargs
+		):
+	"""Computes an interval module approximation of a multiparameter filtration.
+
+	Parameters
+	----------
+	st : n-filtered Simplextree, or None if boundary and filtration are provided.
+		Defines the n-filtration on which to compute the homology.
+	max_error: positive float
+		Trade-off between approximation and computational complexity.
+		Upper bound of the module approximation, in bottleneck distance, 
+		for interval-decomposable modules.
+	nlines: int
+		Alternative to precision.
+	box : pair of list of floats
+		Defines a rectangle on which to compute the approximation.
+		Format : [x,y], where x,y defines the rectangle {z : x ≤ z ≤ y}
+	threshold: bool
+		When true, intersects the module support with the box.
+	verbose: bool
+		Prints C++ infos.
+	ignore_warning : bool
+		Unless set to true, prevents computing on more than 10k lines. Useful to prevent a segmentation fault due to "infinite" recursion.
+	return_timings : bool
+		If true, will return the time to compute instead (computed in python, using perf_counter_ns).
+	Returns
+	-------
+	PyModule
+		An interval decomposable module approximation of the module defined by the
+		homology of this multi-filtration.
+	"""
+
+	if boundary is None or filtration is None:
+		from multipers.io import simplex_tree2boundary_filtrations
+		boundary,filtration = simplex_tree2boundary_filtrations(st) # TODO : recomputed each time... maybe store this somewhere ?
+	if max_dimension < np.inf: # TODO : make it more efficient
+		nsplx = len(boundary)
+		for i in range(nsplx-1,-1,-1):
+			b = boundary[i]
+			dim=len(b) -1
+			if dim>max_dimension:
+				boundary.pop(i)
+				for f in filtration:
+					f.pop(i)
+	nfiltration = len(filtration)
+	if nfiltration <= 0:
+		return PyModule()
+	if nfiltration == 1 and not(st is None):
+		st = st.project_on_line(0)
+		return st.persistence()
+
+	if box is None and not(st is None):
+		m,M = st.filtration_bounds()
+	elif box is not None:
+		m,M = np.asarray(box)
+	else:
+		m, M = np.min(filtration, axis=0), np.max(filtration, axis=0)
+	prod = 1
+	h = M[-1] - m[-1]
+	for i, [a,b] in enumerate(zip(m,M)):
+		if i == len(M)-1:	continue
+		prod *= (b-a + h)
+
+	if max_error is None:
+		max_error:float = (prod/nlines)**(1/(nfiltration-1))
+
+	if box is None:
+		M = [np.max(f)+2*max_error for f in filtration]
+		m = [np.min(f)-2*max_error for f in filtration]
+		box = [m,M]
+
+	if ignore_warning and prod >= 20_000:
+		from warnings import warn
+		warn(f"Warning : the number of lines (around {np.round(prod)}) may be too high. Try to increase the precision parameter, or set `ignore_warning=True` to compute this module. Returning the trivial module.")
+		return PyModule()
+
+	approx_mod = PyModule()
+	cdef vector[Finitely_critical_multi_filtration] c_filtration = Finitely_critical_multi_filtration.from_python(filtration)
+	cdef boundary_matrix c_boundary = boundary
+	cdef value_type c_max_error = max_error
+	cdef bool c_threshold = threshold
+	cdef bool c_complete = complete
+	cdef bool c_multithread = multithread
+	cdef bool c_verbose = verbose
+	cdef Box[value_type] c_box = Box[value_type](box)
+	if return_timings:
+		from time import perf_counter_ns
+		t = perf_counter_ns()
+	with nogil:
+		c_mod = compute_vineyard_barcode_approximation(c_boundary,c_filtration,c_max_error, c_box, c_threshold, c_complete, c_multithread,c_verbose)
+	if return_timings:
+		t = perf_counter_ns() -t 
+		t /= 10**9
+		return t
+	approx_mod._set_from_ptr(<intptr_t>(&c_mod))
+	return approx_mod
+
+
+
+def module_approximation(
+		st:SimplexTreeMulti,
+		value_type max_error = -1,
+		box:list|np.ndarray|None = None,
+		bool threshold:bool = False,
+		bool complete:bool = True,
+		bool verbose:bool = False,
+		bool ignore_warning:bool = False,
+		int nlines = 500,
+		backend:str="matrix",
+		# max_dimension=np.inf,
+		# return_timings:bool = False,
+		**kwargs
+		):
+	"""Computes an interval module approximation of a multiparameter filtration.
+
+	Parameters
+	----------
+	st : n-filtered Simplextree, or None if boundary and filtration are provided.
+		Defines the n-filtration on which to compute the homology.
+	max_error: positive float
+		Trade-off between approximation and computational complexity.
+		Upper bound of the module approximation, in bottleneck distance, 
+		for interval-decomposable modules.
+	nlines: int
+		Alternative to precision.
+	box : pair of list of floats
+		Defines a rectangle on which to compute the approximation.
+		Format : [x,y], where x,y defines the rectangle {z : x ≤ z ≤ y}
+	threshold: bool
+		When true, intersects the module support with the box.
+	verbose: bool
+		Prints C++ infos.
+	ignore_warning : bool
+		Unless set to true, prevents computing on more than 10k lines. Useful to prevent a segmentation fault due to "infinite" recursion.
+	return_timings : bool
+		If true, will return the time to compute instead (computed in python, using perf_counter_ns).
+	Returns
+	-------
+	PyModule
+		An interval decomposable module approximation of the module defined by the
+		homology of this multi-filtration.
+	"""
+	if backend == "old":
+		if max_error == -1:
+			max_error_=None
+		else:
+			max_error_=max_error
+		return module_approximation_old(st, max_error=max_error_, box=box,threshold=threshold,complete=complete,verbose=verbose,ignore_warning=ignore_warning,nlines=nlines)
+
+
+
+	cdef intptr_t ptr = st.thisptr
+	cdef Simplex_tree_multi_interface* st_ptr = <Simplex_tree_multi_interface*>(ptr)
+	cdef SimplicialVineGraphTruc graphtruc# copy ?
+	cdef SimplicialVineMatrixTruc matrixtruc# copy ?
+	cdef GeneralVineTruc generaltruc
+
+	cdef int num_parameters = st.num_parameters
+
+	if num_parameters <= 0:
+		return PyModule()
+	if num_parameters == 1 and not(st is None):
+		st = st.project_on_line(0)
+		return st.persistence()
+
+	if box is not None:
+		m,M = np.asarray(box)
+	else:
+		m,M = st.filtration_bounds()
+	box =np.asarray([m,M])
+	prod = 1
+	h = M[-1] - m[-1]
+	for i, [a,b] in enumerate(zip(m,M)):
+		if i == len(M)-1:	continue
+		prod *= (b-a + h)
+
+	if max_error <= 0:
+		max_error = (prod/nlines)**(1/(num_parameters-1))
+
+	if not ignore_warning and prod >= 20_000:
+		from warnings import warn
+		warn(f"Warning : the number of lines (around {np.round(prod)}) may be too high. Try to increase the precision parameter, or set `ignore_warning=True` to compute this module. Returning the trivial module.")
+		return PyModule()
+
+	cdef Module mod
+	cdef Box[value_type] c_box = Box[value_type](box)
+	# Module multiparameter_module_approximation(Slicer &slicer, const value_type precision,
+                                    # Box<value_type> &box, const bool threshold,
+                                    # const bool complete, const bool verbose) 
+	if backend == "matrix":
+		matrixtruc = SimplicialVineMatrixTruc(st_ptr)
+		with nogil:
+			mod = multiparameter_module_approximation(matrixtruc, max_error,c_box,threshold, complete, verbose)
+	elif backend == "graph":
+		graphtruc = SimplicialVineGraphTruc(st_ptr)
+		with nogil:
+			mod = multiparameter_module_approximation(graphtruc, max_error,c_box,threshold, complete, verbose)
+	else:
+		raise ValueError("Invalid backend.")
+	
+	approx_mod = PyModule()
+	approx_mod._set_from_ptr(<intptr_t>(&mod))
+	return approx_mod
+
+
+
+
+def multiparameter_module_approximation_from_slicer(slicer, box, int num_parameters, value_type max_error, bool complete, bool threshold, bool verbose):
+	cdef intptr_t slicer_ptr = <intptr_t>(slicer.get_ptr())
+	cdef GeneralVineTruc cslicer
+	cdef GeneralVineClementTruc generalclementtruc
+	cdef SimplicialVineGraphTruc graphtruc
+	cdef SimplicialVineMatrixTruc matrixtruc
+	cdef Module mod
+	cdef Box[value_type] c_box = Box[value_type](box)
+	if isinstance(slicer,Slicer):
+		cslicer = dereference(<GeneralVineTruc*>(slicer_ptr))
+		with nogil:
+			mod = multiparameter_module_approximation(cslicer, max_error,c_box,threshold, complete, verbose)
+	elif isinstance(slicer,SlicerClement):
+		generalclementtruc = dereference(<GeneralVineClementTruc*>(slicer_ptr))
+		with nogil:
+			mod = multiparameter_module_approximation(generalclementtruc, max_error,c_box,threshold, complete, verbose)
+	elif isinstance(slicer,SlicerVineGraph):
+		graphtruc = dereference(<SimplicialVineGraphTruc*>(slicer_ptr))
+		with nogil:
+			mod = multiparameter_module_approximation(graphtruc, max_error,c_box,threshold, complete, verbose)
+	elif isinstance(slicer,SlicerVineSimplcial):
+		matrixtruc = dereference(<SimplicialVineMatrixTruc*>(slicer_ptr))
+		with nogil:
+			mod = multiparameter_module_approximation(matrixtruc, max_error,c_box,threshold, complete, verbose)
+	else:
+		raise ValueError("Unimplemeted slicer / Invalid slicer.")
+
+
+	approx_mod = PyModule()
+	approx_mod._set_from_ptr(<intptr_t>(&mod))
+	return approx_mod

multipers/pickle.py

@@ -0,0 +1,53 @@
+import numpy as np
+
+def save_with_axis(path:str, signed_measures):
+	np.savez(path, 
+		**{f"{i}_{axis}_{degree}":np.c_[sm_of_degree[0],sm_of_degree[1][:,np.newaxis]] for i,sm in enumerate(signed_measures) for axis,sm_of_axis in enumerate(sm) for degree,sm_of_degree in enumerate(sm_of_axis)},
+	)
+
+def save_without_axis(path:str, signed_measures):
+    np.savez(path, 
+        **{f"{i}_{degree}":np.c_[sm_of_degree[0],sm_of_degree[1][:,np.newaxis]] for i,sm in enumerate(signed_measures) for degree,sm_of_degree in enumerate(sm)},
+    )
+
+def get_sm_with_axis(sms,idx,axis,degree):
+    sm = sms[f"{idx}_{axis}_{degree}"]
+    return (sm[:,:-1],sm[:,-1])
+def get_sm_without_axis(sms,idx,degree):
+    sm = sms[f"{idx}_{degree}"]
+    return (sm[:,:-1],sm[:,-1])
+
+
+def load_without_axis(sms):
+	indices = np.array([[int(i) for i in key.split('_')] for key in sms.keys()], dtype=int)
+	num_data,num_degrees = indices.max(axis=0)+1
+	signed_measures_reconstructed = [[get_sm_without_axis(sms,idx,degree) for degree in range(num_degrees)] for idx in range(num_data)]
+	return signed_measures_reconstructed
+# test : np.all([np.array_equal(a[0],b[0]) and np.array_equal(a[1],b[1]) and len(a) == len(b) == 2 for x,y in zip(signed_measures_reconstructed,signed_measures_reconstructed) for a,b in zip(x,y)])
+
+def load_with_axis(sms):
+	indices = np.array([[int(i) for i in key.split('_')] for key in sms.keys()], dtype=int)
+	num_data,num_axis,num_degrees = indices.max(axis=0)+1
+	signed_measures_reconstructed = [[[get_sm_with_axis(sms,idx,axis,degree) for degree in range(num_degrees)] for axis in range(num_axis)] for idx in range(num_data)]
+	return signed_measures_reconstructed
+
+def save(path:str, signed_measures):
+	if isinstance(signed_measures[0][0], tuple):
+		save_without_axis(path=path,signed_measures=signed_measures)
+	else:
+		save_with_axis(path=path,signed_measures=signed_measures)
+
+def load(path:str):
+	sms = np.load(path)
+	item=None
+	for i in sms.keys():
+		item=i
+		break
+	n = len(item.split('_'))
+	match n:
+		case 2:
+			return load_without_axis(sms)
+		case 3:
+			return load_with_axis(sms)
+		case _:
+			raise Exception("Invalid Signed Measure !")

multipers/plots.py

@@ -0,0 +1,292 @@
+import matplotlib.pyplot as plt
+from typing import Optional
+import numpy as np
+
+
+def _plot_rectangle(rectangle: np.ndarray, weight, **plt_kwargs):
+    rectangle = np.asarray(rectangle)
+    x_axis = rectangle[[0, 2]]
+    y_axis = rectangle[[1, 3]]
+    color = "blue" if weight > 0 else "red"
+    plt.plot(x_axis, y_axis, c=color, **plt_kwargs)
+
+
+def _plot_signed_measure_2(pts, weights, temp_alpha=0.7, **plt_kwargs):
+    import matplotlib.colors
+
+    weights = np.asarray(weights)
+    color_weights = np.array(weights, dtype=float)
+    neg_idx = weights < 0
+    pos_idx = weights > 0
+    if np.any(neg_idx):
+        current_weights = -weights[neg_idx]
+        min_weight = np.max(current_weights)
+        color_weights[neg_idx] /= min_weight
+        color_weights[neg_idx] -= 1
+    else:
+        min_weight = 0
+
+    if np.any(pos_idx):
+        current_weights = weights[pos_idx]
+        max_weight = np.max(current_weights)
+        color_weights[pos_idx] /= max_weight
+        color_weights[pos_idx] += 1
+    else:
+        max_weight = 1
+
+    bordeaux = np.array([0.70567316, 0.01555616, 0.15023281, 1])
+    light_bordeaux = np.array([0.70567316, 0.01555616, 0.15023281, temp_alpha])
+    bleu = np.array([0.2298057, 0.29871797, 0.75368315, 1])
+    light_bleu = np.array([0.2298057, 0.29871797, 0.75368315, temp_alpha])
+    norm = plt.Normalize(-2, 2)
+    cmap = matplotlib.colors.LinearSegmentedColormap.from_list(
+        "", [bordeaux, light_bordeaux, "white", light_bleu, bleu]
+    )
+    plt.scatter(
+        pts[:, 0], pts[:, 1], c=color_weights, cmap=cmap, norm=norm, **plt_kwargs
+    )
+    plt.scatter([], [], color=bleu, label="positive mass", **plt_kwargs)
+    plt.scatter([], [], color=bordeaux, label="negative mass", **plt_kwargs)
+    plt.legend()
+
+
+def _plot_signed_measure_4(
+    pts, weights, x_smoothing: float = 1, area_alpha: bool = True
+):
+    # compute the maximal rectangle area
+    alpha_rescaling = 0
+    for rectangle, weight in zip(pts, weights):
+        if rectangle[2] > x_smoothing * rectangle[0]:
+            alpha_rescaling = max(
+                alpha_rescaling,
+                (rectangle[2] / x_smoothing - rectangle[0])
+                * (rectangle[3] - rectangle[1]),
+            )
+    # 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]:
+            # make the alpha channel proportional to the rectangle's area
+            if area_alpha:
+                _plot_rectangle(
+                    rectangle=[
+                        rectangle[0],
+                        rectangle[1],
+                        rectangle[2] / x_smoothing,
+                        rectangle[3],
+                    ],
+                    weight=weight,
+                    alpha=(rectangle[2] / x_smoothing - rectangle[0])
+                    * (rectangle[3] - rectangle[1])
+                    / alpha_rescaling,
+                )
+            else:
+                _plot_rectangle(
+                    rectangle=[
+                        rectangle[0],
+                        rectangle[1],
+                        rectangle[2] / x_smoothing,
+                        rectangle[3],
+                    ],
+                    weight=weight,
+                    alpha=1,
+                )
+
+
+def plot_signed_measure(signed_measure, ax=None, **plt_kwargs):
+    if ax is None:
+        ax = plt.gca()
+    else:
+        plt.sca(ax)
+    pts, weights = signed_measure
+    num_parameters = pts.shape[1]
+
+    if isinstance(pts, np.ndarray):
+        pass
+    else:
+        import torch
+
+        if isinstance(pts, torch.Tensor):
+            pts = pts.detach().numpy()
+        else:
+            raise Exception("Invalid measure type.")
+
+    assert num_parameters in (2, 4)
+    if num_parameters == 2:
+        _plot_signed_measure_2(pts=pts, weights=weights, **plt_kwargs)
+    else:
+        _plot_signed_measure_4(pts=pts, weights=weights, **plt_kwargs)
+
+
+def plot_signed_measures(signed_measures, size=4):
+    num_degrees = len(signed_measures)
+    fig, axes = plt.subplots(
+        nrows=1, ncols=num_degrees, figsize=(num_degrees * size, size)
+    )
+    if num_degrees == 1:
+        axes = [axes]
+    for ax, signed_measure in zip(axes, signed_measures):
+        plot_signed_measure(signed_measure=signed_measure, ax=ax)
+    plt.tight_layout()
+
+
+def plot_surface(
+    grid,
+    hf,
+    fig=None,
+    ax=None,
+    cmap: Optional[str] = None,
+    discrete_surface=False,
+    **plt_args,
+):
+    import matplotlib
+
+    if ax is None:
+        ax = plt.gca()
+    else:
+        plt.sca(ax)
+    if hf.ndim == 3 and hf.shape[0] == 1:
+        hf = hf[0]
+    assert hf.ndim == 2, "Can only plot a 2d surface"
+    fig = plt.gcf() if fig is None else fig
+    if cmap is None:
+        if discrete_surface:
+            cmap = matplotlib.colormaps["gray_r"]
+        else:
+            cmap = matplotlib.colormaps["plasma"]
+    if discrete_surface:
+        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)
+        cbar = fig.colorbar(
+            matplotlib.cm.ScalarMappable(cmap=cmap, norm=norm),
+            spacing="proportional",
+            ax=ax,
+        )
+        cbar.set_ticks(ticks=bounds, labels=bounds)
+        return
+    im = ax.pcolormesh(grid[0], grid[1], hf.T, cmap=cmap, **plt_args)
+
+
+def plot_surfaces(HF, size=4, **plt_args):
+    grid, hf = HF
+    assert (
+        hf.ndim == 3
+    ), f"Found hf.shape = {hf.shape}, expected ndim = 3 : degree, 2-parameter surface."
+    num_degrees = hf.shape[0]
+    fig, axes = plt.subplots(
+        nrows=1, ncols=num_degrees, figsize=(num_degrees * size, size)
+    )
+    if num_degrees == 1:
+        axes = [axes]
+    for ax, hf_of_degree in zip(axes, hf):
+        plot_surface(grid=grid, hf=hf_of_degree, fig=fig, ax=ax, **plt_args)
+    plt.tight_layout()
+
+
+def _rectangle(x, y, color, alpha):
+    """
+    Defines a rectangle patch in the format {z | x  ≤ z ≤ y} with color and alpha
+    """
+    from matplotlib.patches import Rectangle as RectanglePatch
+
+    return RectanglePatch(
+        x, max(y[0] - x[0], 0), max(y[1] - x[1], 0), color=color, alpha=alpha
+    )
+
+
+def _d_inf(a, b):
+    if type(a) != np.ndarray or type(b) != np.ndarray:
+        a = np.array(a)
+        b = np.array(b)
+    return np.min(np.abs(b - a))
+
+
+def plot2d_PyModule(
+    corners,
+    box=[],
+    *,
+    dimension=-1,
+    separated=False,
+    min_persistence=0,
+    alpha=1,
+    verbose=False,
+    save=False,
+    dpi=200,
+    shapely=True,
+    xlabel=None,
+    ylabel=None,
+    cmap=None,
+):
+    import matplotlib
+
+    try:
+        from shapely.geometry import Polygon as _Polygon
+        from shapely.geometry import box as _rectangle_box
+        from shapely import union_all
+
+        shapely = True and shapely
+    except:
+        from warnings import warn
+
+        shapely = False
+        warn(
+            "Shapely not installed. Fallbacking to matplotlib. The plots may be inacurate."
+        )
+    cmap = (
+        matplotlib.colormaps["Spectral"] if cmap is None else matplotlib.colormaps[cmap]
+    )
+    if not (separated):
+        # fig, ax = plt.subplots()
+        ax = plt.gca()
+        ax.set(xlim=[box[0][0], box[1][0]], ylim=[box[0][1], box[1][1]])
+    n_summands = len(corners)
+    for i in range(n_summands):
+        trivial_summand = True
+        list_of_rect = []
+        for birth in corners[i][0]:
+            for death in corners[i][1]:
+                death[0] = min(death[0], box[1][0])
+                death[1] = min(death[1], box[1][1])
+                if death[1] > birth[1] and death[0] > birth[0]:
+                    if trivial_summand and _d_inf(birth, death) > min_persistence:
+                        trivial_summand = False
+                    if shapely:
+                        list_of_rect.append(
+                            _rectangle_box(birth[0], birth[1], death[0], death[1])
+                        )
+                    else:
+                        list_of_rect.append(
+                            _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]])
+            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")
+                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")
+            else:
+                for rectangle in list_of_rect:
+                    ax.add_patch(rectangle)
+            if separated:
+                if xlabel:
+                    plt.xlabel(xlabel)
+                if ylabel:
+                    plt.ylabel(ylabel)
+                if dimension >= 0:
+                    plt.title(rf"$H_{dimension}$ $2$-persistence")
+    if not (separated):
+        if xlabel != None:
+            plt.xlabel(xlabel)
+        if ylabel != None:
+            plt.ylabel(ylabel)
+        if dimension >= 0:
+            plt.title(rf"$H_{dimension}$ $2$-persistence")
+    return