multipers 2.0.0__cp311-cp311-macosx_13_0_x86_64.whl

multipers/point_measure_integration.pyx

@@ -0,0 +1,139 @@
+# cimport multipers.tensor as mt
+from libc.stdint cimport intptr_t, uint16_t, uint32_t, int32_t, int64_t
+from libcpp.vector cimport vector
+from libcpp cimport bool, int, float
+import numpy as np
+cimport numpy as cnp
+
+from collections import defaultdict
+cnp.import_array()
+from scipy import sparse
+
+
+import multipers.grids as mpg
+
+ctypedef fused some_int:
+    int32_t
+    int64_t
+    int
+
+ctypedef fused some_float:
+    float
+    double
+
+
+import cython
+cimport cython
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def integrate_measure(
+        some_float[:,:] pts, 
+        some_int[:] weights, 
+        filtration_grid:Optional[list[np.ndarray]]=None,
+        grid_strategy:str="regular",
+        resolution:int|list[int]=100,
+        bool return_grid=False,
+        **get_fitration_kwargs,
+        ):
+    """
+    Integrate a point measure on a grid.
+    Measure is a sum of diracs, based on points `pts` and weights `weights`.
+    For instance, if the signed measure comes from the hilbert signed measure,
+    this integration will return the hilbert function on this grid.
+     - pts : array of points (num_pts, D)
+     - weights : array of weights (num_pts,)
+     - filtration_grid (optional) : list of 1d arrays
+     - resolution : int or list of int
+     - return_grid : return the grid of the measure
+     - **get_fitration_kwargs : arguments to compute the grid,
+        if the grid is not given.
+    """
+    if filtration_grid is None:
+        import multipers.simplex_tree_multi
+        filtration_grid = mpg.compute_grid(
+                np.asarray(pts).T,
+                strategy=grid_strategy,
+                resolution=resolution,
+                **get_fitration_kwargs
+                )
+    resolution = np.asarray([len(f) for f in filtration_grid])
+    cdef int num_pts = pts.shape[0]
+    cdef int num_parameters = pts.shape[1]
+    assert weights.shape[0] == num_pts
+    out = np.zeros(shape=resolution, dtype=np.int32) ## dim cannot be known at compiletime
+    # cdef some_float[:] filtration_of_parameter
+    # cdef cnp.ndarray indices = np.zeros(shape=num_parameters, dtype=int)
+    #
+    pts_coords = np.empty((num_parameters, num_pts), dtype=np.int64)
+    for parameter in range(num_parameters):
+        pts_coords[parameter] = np.searchsorted(filtration_grid[parameter], pts[:,parameter]) 
+    for i in range(num_pts): 
+        cone = tuple(slice(c,r) for r,c in zip(resolution,pts_coords[:,i]))
+        out[cone] += weights[i] 
+    if return_grid:
+        return out,filtration_grid
+    return out
+
+## for benchmark purposes
+def integrate_measure_python(pts, weights, filtrations):
+    resolution = tuple([len(f) for f in filtrations])
+    out = np.zeros(shape=resolution, dtype=pts.dtype)
+    num_pts = pts.shape[0]
+    num_parameters = pts.shape[1]
+    for i in range(num_pts): #this is slow.
+        indices = (filtrations[parameter]>=pts[i][parameter] for parameter in range(num_parameters))
+        out[np.ix_(*indices)] += weights[i]
+    return out
+
+
+def sparsify(x):
+    """
+    Given an arbitrary dimensional numpy array, returns (coordinates,data).
+    --
+    cost : scipy sparse + num_points*num_parameters^2 divisions
+    """
+    num_parameters = x.ndim
+    sx = sparse.coo_array(x.ravel())
+    idx = sx.col
+    data = sx.data
+    coords = np.empty((data.shape[0], num_parameters), dtype=np.int64)
+    for parameter in range(num_parameters-1,-1,-1):
+        idx,coord_of_parameter = np.divmod(idx, x.shape[parameter])
+        coords[:, parameter] = coord_of_parameter
+    return coords,data
+
+
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def clean_signed_measure(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.
+    Mostly useful for, e.g., euler_characteristic from simplical complexes.
+    """
+    cdef dict[tuple, int] out = {}
+    cdef int num_diracs
+    cdef int num_parameters
+    num_diracs, num_parameters = pts.shape[:2]
+    for i in range(num_diracs):
+        key = tuple(pts[i]) # size cannot be known at compiletime
+        out[tuple(pts[i])] = out.get(key,0)+ weights[i]
+    num_keys = len(out)
+    new_pts = np.fromiter(out.keys(), dtype=np.dtype((dtype,num_parameters)), count=num_keys) 
+    new_weights = np.fromiter(out.values(), dtype=np.int32, count=num_keys)
+    idx = np.nonzero(new_weights)
+    new_pts = new_pts[idx]
+    new_weights = new_weights[idx]
+    return (new_pts, new_weights)
+
+def clean_sms(sms):
+    """
+    Sum the diracs at the same locations. i.e.,
+    returns the minimal sized measure to represent the input.
+    Mostly useful for, e.g., euler_characteristic from simplical complexes.
+    """
+    return tuple(clean_signed_measure(pts,weights) for pts,weights in sms)
+
+

multipers/rank_invariant.pyx

@@ -0,0 +1,229 @@
+# cimport multipers.tensor as mt
+from libc.stdint cimport intptr_t, uint16_t, uint32_t, int32_t, int16_t, int8_t
+from libcpp.vector cimport vector
+from libcpp cimport bool, int, float
+from libcpp.utility cimport pair
+from typing import Optional,Iterable,Callable
+from cython.operator import dereference
+
+import numpy as np
+cimport numpy as cnp
+cnp.import_array()
+
+ctypedef float value_type 
+python_value_type=np.float32
+
+ctypedef int32_t indices_type # uint fails for some reason
+python_indices_type=np.int32
+
+ctypedef int32_t tensor_dtype # sizes should be less than 32k (int16), but int32 to be safe
+python_tensor_dtype = np.int32
+import multipers.grids as mpg
+import multipers.slicer as mps
+from multipers.slicer cimport *
+
+# ctypedef pair[vector[vector[indices_type]], vector[tensor_dtype]] signed_measure_type
+
+# cdef extern from "multi_parameter_rank_invariant/rank_invariant.h" namespace "Gudhi::multiparameter::rank_invariant":
+    # void compute_rank_invariant_python(const intptr_t, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool) except + nogil
+
+    # void compute_rank_invariant_python(GeneralNoVineTruc, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type) except + nogil
+    # void compute_rank_invariant_python(GeneralVineTruc, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type) except + nogil
+    # void compute_rank_invariant_python(SimplicialVineMatrixTruc, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type) except + nogil
+    # void compute_rank_invariant_python(SimplicialVineGraphTruc, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type) except + nogil
+    # void compute_rank_invariant_python(GeneralVineClementTruc, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type) except + nogil
+
+from multipers.ml.signed_betti import rank_decomposition_by_rectangles
+from multipers.point_measure_integration import sparsify
+
+# def rank_invariant(simplextree, vector[indices_type] degrees, mass_default=None, plot=False, indices_type n_jobs=0, bool verbose=False, bool expand_collapse=False):
+#     """
+#     Computes the signed measures given by the decomposition of the hilbert function.
+#
+#     Input
+#     -----
+#      - simplextree:SimplexTreeMulti, the multifiltered simplicial complex
+#      - degrees:array-like of ints, the degrees to compute
+#      - mass_default: Either None, or 'auto' or 'inf', or array-like of floats. Where to put the default mass to get a zero-mass measure.
+#      - plot:bool, plots the computed measures if true.
+#      - n_jobs:int, number of jobs. Defaults to #cpu, but when doing parallel computations of signed measures, we recommend setting this to 1.
+#      - verbose:bool, prints c++ logs.
+#
+#     Output
+#     ------
+#     `[signed_measure_of_degree for degree in degrees]`
+#     with `signed_measure_of_degree` of the form `(dirac location, dirac weights)`.
+#     """
+#     assert simplextree._is_squeezed, "Squeeze grid first."
+#     assert simplextree.dtype == np.int32
+#     cdef bool zero_pad = mass_default is not None
+#     grid_conversion = [np.asarray(f) for f in simplextree.filtration_grid]
+#     # assert simplextree.num_parameters == 2
+#     grid_shape = np.array([len(f) for f in grid_conversion])
+#
+#     if mass_default is None:
+#         mass_default = mass_default
+#     else:
+#         mass_default = np.asarray(mass_default)
+#         assert mass_default.ndim == 1 and mass_default.shape[0] == simplextree.num_parameters
+#     if zero_pad:
+#         for i, _ in enumerate(grid_shape):
+#             grid_shape[i] += 1 # adds a 0
+#         for i,f in enumerate(grid_conversion):
+#             grid_conversion[i] = np.concatenate([f, [mass_default[i]]])
+#
+#     assert len(grid_shape) == simplextree.num_parameters, "Grid shape size has to be the number of parameters."
+#     grid_shape_with_degree = np.asarray(np.concatenate([[len(degrees)], grid_shape, grid_shape]), dtype=python_indices_type)
+#     container_array = np.ascontiguousarray(np.zeros(grid_shape_with_degree, dtype=python_tensor_dtype).flatten())
+#     assert len(container_array) < np.iinfo(python_indices_type).max, "Too large container. Raise an issue on github if you encounter this issue. (Due to tensor's operator[])"
+#     cdef intptr_t simplextree_ptr = simplextree.thisptr
+#     cdef vector[indices_type] c_grid_shape = grid_shape_with_degree
+#     cdef tensor_dtype[::1] container = container_array
+#     cdef tensor_dtype* container_ptr = &container[0]
+#     with nogil:
+#         compute_rank_invariant_python(simplextree_ptr, container_ptr,c_grid_shape,degrees, n_jobs, expand_collapse)
+#     container_array = container_array.reshape(grid_shape_with_degree)
+#     if plot:
+#         from multipers.plots import plot_surfaces
+#         plot_surfaces((grid_conversion, container_array))
+#     return (grid_conversion, container_array)
+#
+#
+# def signed_measure(simplextree, vector[indices_type] degrees, mass_default=None, plot=False, indices_type n_jobs=0, bool verbose=False, bool expand_collapse=False):
+#     """
+#     Computes the signed measures given by the decomposition of the hilbert function.
+#
+#     Input
+#     -----
+#      - simplextree:SimplexTreeMulti, the multifiltered simplicial complex
+#      - degrees:array-like of ints, the degrees to compute
+#      - mass_default: Either None, or 'auto' or 'inf', or array-like of floats. Where to put the default mass to get a zero-mass measure.
+#      - plot:bool, plots the computed measures if true.
+#      - n_jobs:int, number of jobs. Defaults to #cpu, but when doing parallel computations of signed measures, we recommend setting this to 1.
+#      - verbose:bool, prints c++ logs.
+#
+#     Output
+#     ------
+#     `[signed_measure_of_degree for degree in degrees]`
+#     with `signed_measure_of_degree` of the form `(dirac location, dirac weights)`.
+#     """
+#     assert simplextree._is_squeezed, "Squeeze grid first."
+#     cdef bool zero_pad = mass_default is not None
+#     grid_conversion = [np.asarray(f) for f in simplextree.filtration_grid]
+#     # assert simplextree.num_parameters == 2
+#     grid_shape = np.array([len(f) for f in grid_conversion])
+#
+#     if mass_default is None:
+#         mass_default = mass_default
+#     else:
+#         mass_default = np.asarray(mass_default)
+#         assert mass_default.ndim == 1 and mass_default.shape[0] == simplextree.num_parameters, "Mass default has to be an array like of shape (num_parameters,)"
+#     if zero_pad:
+#         for i, _ in enumerate(grid_shape):
+#             grid_shape[i] += 1 # adds a 0
+#         for i,f in enumerate(grid_conversion):
+#             grid_conversion[i] = np.concatenate([f, [mass_default[i]]])
+#
+#     assert len(grid_shape) == simplextree.num_parameters, "Grid shape size has to be the number of parameters."
+#     grid_shape_with_degree = np.asarray(np.concatenate([[len(degrees)], grid_shape, grid_shape]), dtype=python_indices_type)
+#     container_array = np.ascontiguousarray(np.zeros(grid_shape_with_degree, dtype=python_tensor_dtype).flatten())
+#     assert len(container_array) < np.iinfo(python_indices_type).max, "Too large container. Raise an issue on github if you encounter this issue. (Due to tensor's operator[])"
+#     cdef intptr_t simplextree_ptr = simplextree.thisptr
+#     cdef vector[indices_type] c_grid_shape = grid_shape_with_degree
+#     cdef tensor_dtype[::1] container = container_array
+#     cdef tensor_dtype* container_ptr = &container[0]
+#     with nogil:
+#         compute_rank_invariant_python(simplextree_ptr, container_ptr,c_grid_shape,degrees, n_jobs, expand_collapse)
+#     rank = container_array.reshape(grid_shape_with_degree)
+#     rank = tuple(rank_decomposition_by_rectangles(rank_of_degree) for rank_of_degree in rank)
+#     out = []
+#     cdef int num_parameters = simplextree.num_parameters
+#     for rank_decomposition in rank:
+#         (coords, weights) = sparsify(np.ascontiguousarray(rank_decomposition))
+#         births = coords[:,:num_parameters]
+#         deaths = coords[:,num_parameters:]
+#         correct_indices = np.all(births<=deaths, axis=1) # TODO : correct this
+#         coords = coords[correct_indices]
+#         weights = weights[correct_indices]
+#         if len(correct_indices) == 0:
+#             pts, weights = np.empty((0, 2*num_parameters)), np.empty((0))
+#         else:
+#             pts = np.empty(shape=coords.shape, dtype=grid_conversion[0].dtype)
+#             for i in range(pts.shape[1]):
+#                 pts[:,i] = grid_conversion[i % num_parameters][coords[:,i]]
+#         rank_decomposition = (pts,weights)
+#         out.append(rank_decomposition)
+#
+#     if plot:
+#         from multipers.plots import plot_signed_measures
+#         plot_signed_measures(out)
+#     return out
+
+
+
+## TODO : It is not necessary to do the Möbius inversion in python.
+## fill rank in flipped death, then differentiate in cpp, then reflip with numpy.
+def rank_from_slicer(
+        slicer, 
+        vector[indices_type] degrees,
+        bool verbose=False,
+        indices_type n_jobs=1,
+        mass_default = None,
+        grid_shape=None,
+        grid_conversion=None,
+        bool plot=False,
+        bool return_raw=False,
+        ):
+    # cdef intptr_t slicer_ptr = <intptr_t>(slicer.get_ptr())
+    if grid_shape is None:
+        grid_shape = (slicer.compute_box()[1]).astype(python_indices_type)
+    cdef int num_parameters = len(grid_shape)
+    cdef bool zero_pad = mass_default is not None
+
+    if mass_default is None:
+        mass_default = mass_default
+    else:
+        mass_default = np.asarray(mass_default)
+        assert mass_default.ndim == 1 and mass_default.shape[0] == num_parameters, "Mass default has to be an array like of shape (num_parameters,)"
+    if zero_pad:
+        for i, _ in enumerate(grid_shape):
+            grid_shape[i] += 1 # adds a 0
+        for i,f in enumerate(grid_conversion):
+            grid_conversion[i] = np.concatenate([f, [mass_default[i]]])
+
+    grid_shape_with_degree = np.asarray(np.concatenate([[len(degrees)], grid_shape, grid_shape]), dtype=python_indices_type)
+    container_array = np.ascontiguousarray(np.zeros(grid_shape_with_degree, dtype=python_tensor_dtype).flatten())
+    assert len(container_array) < np.iinfo(python_indices_type).max, "Too large container. Raise an issue on github if you encounter this issue. (Due to tensor's operator[])"
+    cdef vector[indices_type] c_grid_shape = grid_shape_with_degree
+    cdef tensor_dtype[::1] container = container_array
+    cdef tensor_dtype* container_ptr = &container[0]
+
+    ## SLICERS
+    _compute_rank_invariant(slicer, container_ptr, c_grid_shape, degrees, n_jobs)
+
+    rank = container_array.reshape(grid_shape_with_degree)
+    rank = tuple(rank_decomposition_by_rectangles(rank_of_degree) for rank_of_degree in rank)
+    if return_raw:
+        return rank
+    out = []
+    def clean_rank(rank_decomposition):
+        (coords, weights) = sparsify(np.ascontiguousarray(rank_decomposition))
+        births = coords[:,:num_parameters]
+        deaths = coords[:,num_parameters:]
+        correct_indices = np.all(births<=deaths, axis=1)
+        coords = coords[correct_indices]
+        weights = weights[correct_indices]
+        return coords, weights
+
+    out = mpg.sms_in_grid(tuple(clean_rank(rank_decomposition) for rank_decomposition in rank), grid_conversion, num_parameters=num_parameters)
+
+    if plot:
+        from multipers.plots import plot_signed_measures
+        plot_signed_measures(out)
+    return out
+
+
+
+
+
+

multipers/simplex_tree_multi.pxd

@@ -0,0 +1,129 @@
+# This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+# See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+# Author(s):       Vincent Rouvreau
+#
+# Copyright (C) 2016 Inria
+#
+# Modification(s):
+#  - 2022 David Loiseaux, Hannah Schreiber: adapt for multipersistence. 
+#   - YYYY/MM Author: Description of the modification
+
+from cython cimport numeric
+from libcpp.vector cimport vector
+from libcpp.utility cimport pair
+from libcpp cimport bool
+from libcpp.string cimport string
+from libcpp.map cimport map
+
+from libc.stdint cimport intptr_t, int32_t
+
+__author__ = "Vincent Rouvreau"
+__copyright__ = "Copyright (C) 2016 Inria"
+__license__ = "MIT"
+
+
+from multipers.filtrations cimport *
+
+
+ctypedef int dimension_type
+ctypedef vector[int] simplex_type
+ctypedef vector[simplex_type] simplex_list
+ctypedef vector[pair[pair[int,int], pair[double, double]]] edge_list
+ctypedef vector[int] euler_char_list
+
+ctypedef vector[unsigned int] boundary_type
+ctypedef vector[boundary_type] boundary_matrix
+
+cdef extern from "Simplex_tree_multi_interface.h" namespace "Gudhi::multiparameter::python_interface":
+
+  cdef cppclass Simplex_tree_multi_simplex_handle[F=*]:
+    pass
+
+  cdef cppclass Simplex_tree_multi_simplices_iterator[F=*]:
+    Simplex_tree_multi_simplices_iterator() nogil
+    Simplex_tree_multi_simplex_handle& operator*() nogil
+    Simplex_tree_multi_simplices_iterator operator++() nogil
+    bint operator!=(Simplex_tree_multi_simplices_iterator) nogil
+
+  cdef cppclass Simplex_tree_multi_skeleton_iterator[F=*]:
+    Simplex_tree_multi_skeleton_iterator() nogil
+    Simplex_tree_multi_simplex_handle& operator*() nogil
+    Simplex_tree_multi_skeleton_iterator operator++() nogil
+    bint operator!=(Simplex_tree_multi_skeleton_iterator) nogil
+
+  cdef cppclass Simplex_tree_multi_boundary_iterator[F=*]:
+    Simplex_tree_multi_boundary_iterator() nogil
+    Simplex_tree_multi_simplex_handle& operator*() nogil
+    Simplex_tree_multi_boundary_iterator operator++() nogil
+    bint operator!=(Simplex_tree_multi_boundary_iterator) nogil
+
+
+  cdef cppclass Simplex_tree_multi_interface[F=*, value_type=*]:
+    ctypedef pair[simplex_type, F*] simplex_filtration_type
+    Simplex_tree_multi_interface() nogil
+    Simplex_tree_multi_interface(Simplex_tree_multi_interface&) nogil
+    F* simplex_filtration(const vector[int]& simplex) nogil
+    void assign_simplex_filtration(vector[int]& simplex, const F& filtration) noexcept nogil
+    void initialize_filtration() nogil
+    int num_vertices() nogil
+    int num_simplices() nogil
+    void set_dimension(int dimension) nogil
+    dimension_type dimension() nogil
+    dimension_type upper_bound_dimension() nogil
+    bool find_simplex(vector[int]& simplex) nogil
+    bool insert(vector[int]& simplex, F& filtration) noexcept nogil
+    # vector[simplex_filtration_type] get_star(const vector[int]& simplex) nogil
+    # vector[simplex_filtration_type] get_cofaces(const vector[int]& simplex, int dimension) nogil
+    void expansion(int max_dim)  except + nogil
+    void remove_maximal_simplex(simplex_type simplex) nogil
+    # bool prune_above_filtration(filtration_type filtration) nogil
+    bool prune_above_dimension(int dimension) nogil
+    bool make_filtration_non_decreasing()  except + nogil
+    # void compute_extended_filtration() nogil
+    # Simplex_tree_multi_interface* collapse_edges(int nb_collapse_iteration)  except + nogil
+    void reset_filtration(const F& filtration, int dimension) nogil
+    bint operator==(Simplex_tree_multi_interface) nogil
+    # Iterators over Simplex tree
+    pair[simplex_type,F*] get_simplex_and_filtration(Simplex_tree_multi_simplex_handle f_simplex) nogil
+    Simplex_tree_multi_simplices_iterator[F] get_simplices_iterator_begin() nogil
+    Simplex_tree_multi_simplices_iterator[F] get_simplices_iterator_end() nogil
+    vector[Simplex_tree_multi_simplex_handle[F]].const_iterator get_filtration_iterator_begin() nogil
+    vector[Simplex_tree_multi_simplex_handle[F]].const_iterator get_filtration_iterator_end() nogil
+    Simplex_tree_multi_skeleton_iterator get_skeleton_iterator_begin(int dimension) nogil
+    Simplex_tree_multi_skeleton_iterator get_skeleton_iterator_end(int dimension) nogil
+    pair[Simplex_tree_multi_boundary_iterator, Simplex_tree_multi_boundary_iterator] get_boundary_iterators(vector[int] simplex)  except + nogil
+    # Expansion with blockers
+    ctypedef bool (*blocker_func_t)(vector[int], void *user_data)
+    void expansion_with_blockers_callback(int dimension, blocker_func_t user_func, void *user_data)
+
+    ## MULTIPERS STUFF
+    void set_keys_to_enumerate() nogil const
+    int get_key(const simplex_type) nogil
+    void set_key(simplex_type, int) nogil
+    void fill_lowerstar(const F&, int) nogil
+    simplex_list get_simplices_of_dimension(int) nogil
+    edge_list get_edge_list() nogil
+    # euler_char_list euler_char(const vector[filtration_type]&) nogil
+    void resize_all_filtrations(int) nogil
+    void set_number_of_parameters(int) nogil
+    int get_number_of_parameters() nogil
+  
+    
+    void from_std(intptr_t,int, F&) nogil
+    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
+    vector[vector[vector[value_type]]] get_filtration_values(const vector[int]&) nogil
+
+
+    pair[boundary_matrix, vector[Finitely_critical_multi_filtration[value_type]]] simplextree_to_boundary_filtration()
+    vector[pair[ vector[vector[value_type]],boundary_matrix]] simplextree_to_scc()
+    vector[pair[ vector[vector[vector[value_type]]],boundary_matrix]] kcritical_simplextree_to_scc()
+
+    vector[pair[ vector[vector[vector[value_type]]],boundary_matrix]] function_simplextree_to_scc()
+    pair[vector[vector[value_type]],boundary_matrix ] simplextree_to_ordered_bf()
+    # vector[map[value_type,int32_t]] build_idx_map(const vector[int]&) nogil
+    # pair[vector[vector[int32_t]],vector[vector[int32_t]]] get_pts_indices(const vector[map[value_type,int32_t]]&, const vector[vector[value_type]]&) nogil
+    pair[vector[vector[int32_t]],vector[vector[int32_t]]] pts_to_indices(vector[vector[value_type]]&, vector[int]&) nogil
+