From fcfc9de5eb7e309c0ac309f57e26672c31bbc836 Mon Sep 17 00:00:00 2001 From: vrouvrea Date: Thu, 1 Dec 2016 17:58:07 +0000 Subject: Add Subsampling cpp interface and cython Remove deref cyton import git-svn-id: svn+ssh://scm.gforge.inria.fr/svnroot/gudhi/branches/ST_cythonize@1809 636b058d-ea47-450e-bf9e-a15bfbe3eedb Former-commit-id: 2dc0469d2401e0c99e879c064a0f608c8ba78ed6 --- src/cython/include/Subsampling_interface.h | 59 ++++++++++++++++++++++++++++++ 1 file changed, 59 insertions(+) create mode 100644 src/cython/include/Subsampling_interface.h (limited to 'src/cython/include/Subsampling_interface.h') diff --git a/src/cython/include/Subsampling_interface.h b/src/cython/include/Subsampling_interface.h new file mode 100644 index 00000000..bd37a015 --- /dev/null +++ b/src/cython/include/Subsampling_interface.h @@ -0,0 +1,59 @@ +/* This file is part of the Gudhi Library. The Gudhi library + * (Geometric Understanding in Higher Dimensions) is a generic C++ + * library for computational topology. + * + * Author(s): Vincent Rouvreau + * + * Copyright (C) 2016 INRIA + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef SUBSAMPLING_INTERFACE_H +#define SUBSAMPLING_INTERFACE_H + +#include +#include +#include + +#include +#include + +namespace Gudhi { + +namespace subsampling { + +using Subsampling_dynamic_kernel = CGAL::Epick_d< CGAL::Dynamic_dimension_tag >; +using Subsampling_point_d = Subsampling_dynamic_kernel::Point_d; +using Subsampling_ft = Subsampling_dynamic_kernel::FT; + +std::vector> subsampling_n_farthest_points(std::vector>& points, unsigned nb_points) { + std::vector input, output; + for (auto point : points) + input.push_back(Subsampling_point_d(point.size(), point.begin(), point.end())); + std::vector> landmarks; + Subsampling_dynamic_kernel k; + choose_n_farthest_points(k, points, nb_points, std::back_inserter(landmarks)); + std::cout << "output " << landmarks.size() << std::endl; + + + return landmarks; +} + +} // namespace subsampling + +} // namespace Gudhi + +#endif // SUBSAMPLING_INTERFACE_H + -- cgit v1.2.3 From 9a3373a0db722c75994826d44b4cfbe1b7b5aeb0 Mon Sep 17 00:00:00 2001 From: vrouvrea Date: Fri, 2 Dec 2016 13:26:47 +0000 Subject: pick_n_random_points cythonization git-svn-id: svn+ssh://scm.gforge.inria.fr/svnroot/gudhi/branches/ST_cythonize@1814 636b058d-ea47-450e-bf9e-a15bfbe3eedb Former-commit-id: 696c9b39cb05e69e2d9c2a3ac3f5400c7e518691 --- .../include/gudhi/pick_n_random_points.h | 4 ++- src/cython/cython/subsampling.pyx | 26 ++++++++++++++++++ src/cython/include/Subsampling_interface.h | 20 ++++++++++++++ src/cython/test/test_subsampling.py | 31 +++++++++++++++++----- 4 files changed, 73 insertions(+), 8 deletions(-) (limited to 'src/cython/include/Subsampling_interface.h') diff --git a/src/Subsampling/include/gudhi/pick_n_random_points.h b/src/Subsampling/include/gudhi/pick_n_random_points.h index e89b2b2d..f0e3f1f1 100644 --- a/src/Subsampling/include/gudhi/pick_n_random_points.h +++ b/src/Subsampling/include/gudhi/pick_n_random_points.h @@ -57,7 +57,9 @@ void pick_n_random_points(Point_container const &points, #endif std::size_t nbP = boost::size(points); - assert(nbP >= final_size); + if (final_size > nbP) + final_size = nbP; + std::vector landmarks(nbP); std::iota(landmarks.begin(), landmarks.end(), 0); diff --git a/src/cython/cython/subsampling.pyx b/src/cython/cython/subsampling.pyx index 5ca38099..c71f5810 100644 --- a/src/cython/cython/subsampling.pyx +++ b/src/cython/cython/subsampling.pyx @@ -35,6 +35,8 @@ cdef extern from "Subsampling_interface.h" namespace "Gudhi::subsampling": vector[vector[double]] subsampling_n_farthest_points(vector[vector[double]] points, unsigned nb_points, unsigned starting_point) vector[vector[double]] subsampling_n_farthest_points_from_file(string off_file, unsigned nb_points) vector[vector[double]] subsampling_n_farthest_points_from_file(string off_file, unsigned nb_points, unsigned starting_point) + vector[vector[double]] subsampling_n_random_points(vector[vector[double]] points, unsigned nb_points) + vector[vector[double]] subsampling_n_random_points_from_file(string off_file, unsigned nb_points) def choose_n_farthest_points(points=[], off_file='', nb_points=0, starting_point = ''): """Subsample by a greedy strategy of iteratively adding the farthest point @@ -71,3 +73,27 @@ def choose_n_farthest_points(points=[], off_file='', nb_points=0, starting_point return subsampling_n_farthest_points(points, nb_points) else: return subsampling_n_farthest_points(points, nb_points, starting_point) + +def pick_n_random_points(points=[], off_file='', nb_points=0): + """Subsample a point set by picking random vertices. + + :param points: The input point set. + :type points: vector[vector[double]]. + + Or + + :param off_file: An OFF file style name. + :type off_file: string + + :param nb_points: Number of points of the subsample. + :type nb_points: unsigned. + :returns: The subsamplepoint set. + :rtype: vector[vector[double]] + """ + if off_file is not '': + if os.path.isfile(off_file): + return subsampling_n_random_points_from_file(off_file, nb_points) + else: + print("file " + off_file + " not found.") + else: + return subsampling_n_random_points(points, nb_points) diff --git a/src/cython/include/Subsampling_interface.h b/src/cython/include/Subsampling_interface.h index 12c48012..8ef4fea1 100644 --- a/src/cython/include/Subsampling_interface.h +++ b/src/cython/include/Subsampling_interface.h @@ -38,6 +38,7 @@ using Subsampling_dynamic_kernel = CGAL::Epick_d< CGAL::Dynamic_dimension_tag >; using Subsampling_point_d = Subsampling_dynamic_kernel::Point_d; using Subsampling_ft = Subsampling_dynamic_kernel::FT; +// ------ choose_n_farthest_points ------ std::vector> subsampling_n_farthest_points(std::vector>& points, unsigned nb_points) { std::vector input, output; for (auto point : points) @@ -71,6 +72,25 @@ std::vector> subsampling_n_farthest_points_from_file(std::st std::vector> points = off_reader.get_point_cloud(); return subsampling_n_farthest_points(points, nb_points, starting_point); } + +// ------ pick_n_random_points ------ +std::vector> subsampling_n_random_points(std::vector>& points, unsigned nb_points) { + std::vector input, output; + for (auto point : points) + input.push_back(Subsampling_point_d(point.size(), point.begin(), point.end())); + std::vector> landmarks; + pick_n_random_points(points, nb_points, std::back_inserter(landmarks)); + + return landmarks; +} + +std::vector> subsampling_n_random_points_from_file(std::string& off_file, unsigned nb_points) { + Gudhi::Points_off_reader> off_reader(off_file); + std::vector> points = off_reader.get_point_cloud(); + return subsampling_n_random_points(points, nb_points); +} + + } // namespace subsampling } // namespace Gudhi diff --git a/src/cython/test/test_subsampling.py b/src/cython/test/test_subsampling.py index e5f2d70a..2dc12a89 100755 --- a/src/cython/test/test_subsampling.py +++ b/src/cython/test/test_subsampling.py @@ -1,5 +1,4 @@ import gudhi -import os """This file is part of the Gudhi Library. The Gudhi library (Geometric Understanding in Higher Dimensions) is a generic C++ @@ -29,7 +28,7 @@ __license__ = "GPL v3" def test_write_off_file_for_tests(): - file = open("n_farthest.off", "w") + file = open("subsample.off", "w") file.write("nOFF\n") file.write("2 7 0 0\n") file.write("1.0 1.0\n") @@ -66,18 +65,17 @@ def test_simple_choose_n_farthest_points_with_a_starting_point(): assert gudhi.choose_n_farthest_points(points = [], nb_points = 0, starting_point = 1) == [] assert gudhi.choose_n_farthest_points(points = [], nb_points = 1, starting_point = 1) == [] - print(os.getcwd()) # From off file test for i in range (0, 7): - assert len(gudhi.choose_n_farthest_points(off_file = 'n_farthest.off', nb_points = i, starting_point = i)) == i + assert len(gudhi.choose_n_farthest_points(off_file = 'subsample.off', nb_points = i, starting_point = i)) == i def test_simple_choose_n_farthest_points_randomed(): point_set = [[0,1], [0,0], [1,0], [1,1]] - # Test the limits assert gudhi.choose_n_farthest_points(points = [], nb_points = 0) == [] assert gudhi.choose_n_farthest_points(points = [], nb_points = 1) == [] assert gudhi.choose_n_farthest_points(points = point_set, nb_points = 0) == [] + # Go furter than point set on purpose for iter in range(1,10): sub_set = gudhi.choose_n_farthest_points(points = point_set, nb_points = iter) @@ -86,9 +84,28 @@ def test_simple_choose_n_farthest_points_randomed(): for point in point_set: if point == sub: found = True + # Check each sub set point is existing in the point set assert found == True - print(os.getcwd()) # From off file test for i in range (0, 7): - assert len(gudhi.choose_n_farthest_points(off_file = 'n_farthest.off', nb_points = i)) == i + assert len(gudhi.choose_n_farthest_points(off_file = 'subsample.off', nb_points = i)) == i + +def test_simple_pick_n_random_points(): + point_set = [[0,1], [0,0], [1,0], [1,1]] + # Test the limits + assert gudhi.pick_n_random_points(points = [], nb_points = 0) == [] + assert gudhi.pick_n_random_points(points = [], nb_points = 1) == [] + assert gudhi.pick_n_random_points(points = point_set, nb_points = 0) == [] + + # Go furter than point set on purpose + for iter in range(1,10): + sub_set = gudhi.pick_n_random_points(points = point_set, nb_points = iter) + print(5) + for sub in sub_set: + found = False + for point in point_set: + if point == sub: + found = True + # Check each sub set point is existing in the point set + assert found == True -- cgit v1.2.3 From 0c85e54d44a95aa7aff3f6d51a587287ce4a88d6 Mon Sep 17 00:00:00 2001 From: vrouvrea Date: Sat, 3 Dec 2016 14:46:37 +0000 Subject: sparsify point set cythonization unitary tested git-svn-id: svn+ssh://scm.gforge.inria.fr/svnroot/gudhi/branches/ST_cythonize@1816 636b058d-ea47-450e-bf9e-a15bfbe3eedb Former-commit-id: 170f14ffcf009ebe1169df90a4e088441eaad13f --- src/cython/cython/subsampling.pyx | 30 +++++++++++++++++++++++++++-- src/cython/include/Subsampling_interface.h | 31 +++++++++++++++++++++--------- src/cython/test/test_subsampling.py | 22 +++++++++++++++++++++ 3 files changed, 72 insertions(+), 11 deletions(-) (limited to 'src/cython/include/Subsampling_interface.h') diff --git a/src/cython/cython/subsampling.pyx b/src/cython/cython/subsampling.pyx index c71f5810..05c0232f 100644 --- a/src/cython/cython/subsampling.pyx +++ b/src/cython/cython/subsampling.pyx @@ -37,6 +37,8 @@ cdef extern from "Subsampling_interface.h" namespace "Gudhi::subsampling": vector[vector[double]] subsampling_n_farthest_points_from_file(string off_file, unsigned nb_points, unsigned starting_point) vector[vector[double]] subsampling_n_random_points(vector[vector[double]] points, unsigned nb_points) vector[vector[double]] subsampling_n_random_points_from_file(string off_file, unsigned nb_points) + vector[vector[double]] subsampling_sparsify_points(vector[vector[double]] points, double min_squared_dist) + vector[vector[double]] subsampling_sparsify_points_from_file(string off_file, double min_squared_dist) def choose_n_farthest_points(points=[], off_file='', nb_points=0, starting_point = ''): """Subsample by a greedy strategy of iteratively adding the farthest point @@ -57,7 +59,7 @@ def choose_n_farthest_points(points=[], off_file='', nb_points=0, starting_point point`,which is the index of the poit to start with. If not set, this \ index is choosen randomly. :type starting_point: unsigned. - :returns: The subsamplepoint set. + :returns: The subsample point set. :rtype: vector[vector[double]] """ if off_file is not '': @@ -87,7 +89,7 @@ def pick_n_random_points(points=[], off_file='', nb_points=0): :param nb_points: Number of points of the subsample. :type nb_points: unsigned. - :returns: The subsamplepoint set. + :returns: The subsample point set. :rtype: vector[vector[double]] """ if off_file is not '': @@ -97,3 +99,27 @@ def pick_n_random_points(points=[], off_file='', nb_points=0): print("file " + off_file + " not found.") else: return subsampling_n_random_points(points, nb_points) + +def sparsify_point_set(points=[], off_file='', min_squared_dist=0.0): + """Subsample a point set by picking random vertices. + + :param points: The input point set. + :type points: vector[vector[double]]. + + Or + + :param off_file: An OFF file style name. + :type off_file: string + + :param min_squared_dist: Number of points of the subsample. + :type min_squared_dist: unsigned. + :returns: The subsample point set. + :rtype: vector[vector[double]] + """ + if off_file is not '': + if os.path.isfile(off_file): + return subsampling_sparsify_points_from_file(off_file, min_squared_dist) + else: + print("file " + off_file + " not found.") + else: + return subsampling_sparsify_points(points, min_squared_dist) diff --git a/src/cython/include/Subsampling_interface.h b/src/cython/include/Subsampling_interface.h index 8ef4fea1..9340cd86 100644 --- a/src/cython/include/Subsampling_interface.h +++ b/src/cython/include/Subsampling_interface.h @@ -24,6 +24,8 @@ #define SUBSAMPLING_INTERFACE_H #include +#include +#include #include #include @@ -40,9 +42,6 @@ using Subsampling_ft = Subsampling_dynamic_kernel::FT; // ------ choose_n_farthest_points ------ std::vector> subsampling_n_farthest_points(std::vector>& points, unsigned nb_points) { - std::vector input, output; - for (auto point : points) - input.push_back(Subsampling_point_d(point.size(), point.begin(), point.end())); std::vector> landmarks; Subsampling_dynamic_kernel k; choose_n_farthest_points(k, points, nb_points, std::back_inserter(landmarks)); @@ -51,9 +50,6 @@ std::vector> subsampling_n_farthest_points(std::vector> subsampling_n_farthest_points(std::vector>& points, unsigned nb_points, unsigned starting_point) { - std::vector input, output; - for (auto point : points) - input.push_back(Subsampling_point_d(point.size(), point.begin(), point.end())); std::vector> landmarks; Subsampling_dynamic_kernel k; choose_n_farthest_points(k, points, nb_points, starting_point, std::back_inserter(landmarks)); @@ -75,9 +71,6 @@ std::vector> subsampling_n_farthest_points_from_file(std::st // ------ pick_n_random_points ------ std::vector> subsampling_n_random_points(std::vector>& points, unsigned nb_points) { - std::vector input, output; - for (auto point : points) - input.push_back(Subsampling_point_d(point.size(), point.begin(), point.end())); std::vector> landmarks; pick_n_random_points(points, nb_points, std::back_inserter(landmarks)); @@ -90,6 +83,26 @@ std::vector> subsampling_n_random_points_from_file(std::stri return subsampling_n_random_points(points, nb_points); } +// ------ sparsify_point_set ------ +std::vector> subsampling_sparsify_points(std::vector>& points, double min_squared_dist) { + std::vector input, output; + for (auto point : points) + input.push_back(Subsampling_point_d(point.size(), point.begin(), point.end())); + Subsampling_dynamic_kernel k; + sparsify_point_set(k, input, min_squared_dist, std::back_inserter(output)); + + std::vector> landmarks; + for (auto point : output) + landmarks.push_back(std::vector(point.cartesian_begin(), point.cartesian_end())); + return landmarks; +} + +std::vector> subsampling_sparsify_points_from_file(std::string& off_file, double min_squared_dist) { + Gudhi::Points_off_reader> off_reader(off_file); + std::vector> points = off_reader.get_point_cloud(); + return subsampling_sparsify_points(points, min_squared_dist); +} + } // namespace subsampling diff --git a/src/cython/test/test_subsampling.py b/src/cython/test/test_subsampling.py index 2dc12a89..2caf4ddb 100755 --- a/src/cython/test/test_subsampling.py +++ b/src/cython/test/test_subsampling.py @@ -109,3 +109,25 @@ def test_simple_pick_n_random_points(): found = True # Check each sub set point is existing in the point set assert found == True + + # From off file test + for i in range (0, 7): + assert len(gudhi.pick_n_random_points(off_file = 'subsample.off', nb_points = i)) == i + +def test_simple_sparsify_points(): + point_set = [[0,1], [0,0], [1,0], [1,1]] + # Test the limits + # assert gudhi.sparsify_point_set(points = [], min_squared_dist = 0.0) == [] + # assert gudhi.sparsify_point_set(points = [], min_squared_dist = 10.0) == [] + assert gudhi.sparsify_point_set(points = point_set, min_squared_dist = 0.0) == point_set + assert gudhi.sparsify_point_set(points = point_set, min_squared_dist = 1.0) == point_set + assert gudhi.sparsify_point_set(points = point_set, min_squared_dist = 2.0) == [[0,1], [1,0]] + assert gudhi.sparsify_point_set(points = point_set, min_squared_dist = 2.01) == [[0,1]] + + assert len(gudhi.sparsify_point_set(off_file = 'subsample.off', min_squared_dist = 0.0)) == 7 + assert len(gudhi.sparsify_point_set(off_file = 'subsample.off', min_squared_dist = 30.0)) == 5 + assert len(gudhi.sparsify_point_set(off_file = 'subsample.off', min_squared_dist = 40.0)) == 4 + assert len(gudhi.sparsify_point_set(off_file = 'subsample.off', min_squared_dist = 90.0)) == 3 + assert len(gudhi.sparsify_point_set(off_file = 'subsample.off', min_squared_dist = 100.0)) == 2 + assert len(gudhi.sparsify_point_set(off_file = 'subsample.off', min_squared_dist = 325.0)) == 2 + assert len(gudhi.sparsify_point_set(off_file = 'subsample.off', min_squared_dist = 325.01)) == 1 -- cgit v1.2.3 From ad9c182c0ffa8b517cd20d174de823db05250514 Mon Sep 17 00:00:00 2001 From: vrouvrea Date: Wed, 25 Jan 2017 08:59:20 +0000 Subject: Fix rips complex with the new interface Remove mini simplex tree Fix persistent cohomology doc - only simplex tree used Remove useless type definition in Cython C++ interfaces git-svn-id: svn+ssh://scm.gforge.inria.fr/svnroot/gudhi/branches/ST_cythonize@2003 636b058d-ea47-450e-bf9e-a15bfbe3eedb Former-commit-id: fff43192b00df1c70d59109a6c14932013992ff1 --- src/cython/cython/mini_simplex_tree.pyx | 352 -------------------- src/cython/cython/rips_complex.pyx | 354 +++------------------ src/cython/doc/persistent_cohomology_sum.rst | 3 - src/cython/doc/persistent_cohomology_user.rst | 3 - src/cython/example/mini_simplex_tree_example.py | 73 ----- ...am_persistence_with_pandas_interface_example.py | 11 +- .../example/rips_complex_from_points_example.py | 10 +- src/cython/example/rips_persistence_diagram.py | 7 +- src/cython/gudhi.pyx.in | 1 - src/cython/include/Alpha_complex_interface.h | 9 +- src/cython/include/Cubical_complex_interface.h | 4 +- src/cython/include/Rips_complex_interface.h | 70 ++++ src/cython/include/Simplex_tree_interface.h | 34 +- src/cython/include/Subsampling_interface.h | 3 +- src/cython/include/Tangential_complex_interface.h | 5 - src/cython/include/Witness_complex_interface.h | 4 +- src/cython/test/test_mini_simplex_tree.py | 50 --- src/cython/test/test_rips_complex.py | 35 +- 18 files changed, 158 insertions(+), 870 deletions(-) delete mode 100644 src/cython/cython/mini_simplex_tree.pyx delete mode 100755 src/cython/example/mini_simplex_tree_example.py create mode 100644 src/cython/include/Rips_complex_interface.h delete mode 100755 src/cython/test/test_mini_simplex_tree.py (limited to 'src/cython/include/Subsampling_interface.h') diff --git a/src/cython/cython/mini_simplex_tree.pyx b/src/cython/cython/mini_simplex_tree.pyx deleted file mode 100644 index 3ba7e853..00000000 --- a/src/cython/cython/mini_simplex_tree.pyx +++ /dev/null @@ -1,352 +0,0 @@ -from cython cimport numeric -from libcpp.vector cimport vector -from libcpp.utility cimport pair - -"""This file is part of the Gudhi Library. The Gudhi library - (Geometric Understanding in Higher Dimensions) is a generic C++ - library for computational topology. - - Author(s): Vincent Rouvreau - - Copyright (C) 2016 INRIA - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . -""" - -__author__ = "Vincent Rouvreau" -__copyright__ = "Copyright (C) 2016 INRIA" -__license__ = "GPL v3" - -cdef extern from "Simplex_tree_interface.h" namespace "Gudhi": - cdef cppclass Simplex_tree_options_mini: - pass - - cdef cppclass Simplex_tree_interface_mini "Gudhi::Simplex_tree_interface": - Simplex_tree() - double filtration() - double simplex_filtration(vector[int] simplex) - void set_filtration(double filtration) - void initialize_filtration() - int num_vertices() - int num_simplices() - void set_dimension(int dimension) - int dimension() - bint find_simplex(vector[int] simplex) - bint insert_simplex_and_subfaces(vector[int] simplex, - double filtration) - vector[pair[vector[int], double]] get_filtered_tree() - vector[pair[vector[int], double]] get_skeleton_tree(int dimension) - vector[pair[vector[int], double]] get_star_tree(vector[int] simplex) - vector[pair[vector[int], double]] get_coface_tree(vector[int] simplex, - int dimension) - void remove_maximal_simplex(vector[int] simplex) - -cdef extern from "Persistent_cohomology_interface.h" namespace "Gudhi": - cdef cppclass Mini_simplex_tree_persistence_interface "Gudhi::Persistent_cohomology_interface>": - Mini_simplex_tree_persistence_interface(Simplex_tree_interface_mini * st) - vector[pair[int, pair[double, double]]] get_persistence(int homology_coeff_field, double min_persistence) - vector[int] betti_numbers() - vector[int] persistent_betti_numbers(double from_value, double to_value) - -# MiniSimplexTree python interface -cdef class MiniSimplexTree: - """The simplex tree is an efficient and flexible data structure for - representing general (filtered) simplicial complexes. The data structure - is described in Jean-Daniel Boissonnat and Clément Maria. The Simplex - Tree: An Efficient Data Structure for General Simplicial Complexes. - Algorithmica, pages 1–22, 2014. - - This class is a non-filtered, with keys, and non contiguous vertices - version of the simplex tree. - """ - cdef Simplex_tree_interface_mini * thisptr - - cdef Mini_simplex_tree_persistence_interface * pcohptr - - # Fake constructor that does nothing but documenting the constructor - def __init__(self, points=[], max_alpha_square=float('inf')): - """MiniSimplexTree constructor. - """ - - # The real cython constructor - def __cinit__(self): - self.thisptr = new Simplex_tree_interface_mini() - - def __dealloc__(self): - if self.thisptr != NULL: - del self.thisptr - if self.pcohptr != NULL: - del self.pcohptr - - def __is_defined(self): - """Returns true if MiniSimplexTree pointer is not NULL. - """ - return self.thisptr != NULL - - def __is_persistence_defined(self): - """Returns true if Persistence pointer is not NULL. - """ - return self.pcohptr != NULL - - def get_filtration(self): - """This function returns the main simplicial complex filtration value. - - :returns: float -- the simplicial complex filtration value. - """ - return self.thisptr.filtration() - - def filtration(self, simplex): - """This function returns the simplicial complex filtration value for a - given N-simplex. - - :param simplex: The N-simplex, represented by a list of vertex. - :type simplex: list of int. - :returns: float -- the simplicial complex filtration value. - """ - return self.thisptr.simplex_filtration(simplex) - - def set_filtration(self, filtration): - """This function sets the main simplicial complex filtration value. - - :param filtration: The filtration value. - :type filtration: float. - """ - self.thisptr.set_filtration( filtration) - - def initialize_filtration(self): - """This function initializes and sorts the simplicial complex - filtration vector. - - .. note:: - - This function must be launched before persistence, betti_numbers, - persistent_betti_numbers or get_filtered_tree after inserting or - removing simplices. - """ - self.thisptr.initialize_filtration() - - def num_vertices(self): - """This function returns the number of vertices of the simplicial - complex. - - :returns: int -- the simplicial complex number of vertices. - """ - return self.thisptr.num_vertices() - - def num_simplices(self): - """This function returns the number of simplices of the simplicial - complex. - - :returns: int -- the simplicial complex number of simplices. - """ - return self.thisptr.num_simplices() - - def dimension(self): - """This function returns the dimension of the simplicial complex. - - :returns: int -- the simplicial complex dimension. - """ - return self.thisptr.dimension() - - def set_dimension(self, dimension): - """This function sets the dimension of the simplicial complex. - - :param dimension: The new dimension value. - :type dimension: int. - """ - self.thisptr.set_dimension(dimension) - - def find(self, simplex): - """This function returns if the N-simplex was found in the simplicial - complex or not. - - :param simplex: The N-simplex to find, represented by a list of vertex. - :type simplex: list of int. - :returns: bool -- true if the simplex was found, false otherwise. - """ - cdef vector[int] complex - for i in simplex: - complex.push_back(i) - return self.thisptr.find_simplex(complex) - - def insert(self, simplex, filtration=0.0): - """This function inserts the given N-simplex with the given filtration - value (default value is '0.0'). - - :param simplex: The N-simplex to insert, represented by a list of - vertex. - :type simplex: list of int. - :param filtration: The filtration value of the simplex. - :type filtration: float. - :returns: bool -- true if the simplex was found, false otherwise. - """ - cdef vector[int] complex - for i in simplex: - complex.push_back(i) - return self.thisptr.insert_simplex_and_subfaces(complex, - filtration) - - def get_filtered_tree(self): - """This function returns the tree sorted by increasing filtration - values. - - :returns: list of tuples(simplex, filtration) -- the tree sorted by - increasing filtration values. - """ - cdef vector[pair[vector[int], double]] coface_tree \ - = self.thisptr.get_filtered_tree() - ct = [] - for filtered_complex in coface_tree: - v = [] - for vertex in filtered_complex.first: - v.append(vertex) - ct.append((v, filtered_complex.second)) - return ct - - def get_skeleton_tree(self, dimension): - """This function returns the tree skeleton of a maximum given - dimension. - - :param dimension: The skeleton dimension value. - :type dimension: int. - :returns: list of tuples(simplex, filtration) -- the skeleton tree - of a maximum dimension. - """ - cdef vector[pair[vector[int], double]] coface_tree \ - = self.thisptr.get_skeleton_tree(dimension) - ct = [] - for filtered_complex in coface_tree: - v = [] - for vertex in filtered_complex.first: - v.append(vertex) - ct.append((v, filtered_complex.second)) - return ct - - def get_star_tree(self, simplex): - """This function returns the star tree of a given N-simplex. - - :param simplex: The N-simplex, represented by a list of vertex. - :type simplex: list of int. - :returns: list of tuples(simplex, filtration) -- the star tree of a - simplex. - """ - cdef vector[int] complex - for i in simplex: - complex.push_back(i) - cdef vector[pair[vector[int], double]] coface_tree \ - = self.thisptr.get_star_tree(complex) - ct = [] - for filtered_complex in coface_tree: - v = [] - for vertex in filtered_complex.first: - v.append(vertex) - ct.append((v, filtered_complex.second)) - return ct - - def get_coface_tree(self, simplex, codimension): - """This function returns the coface tree of a given N-simplex with a - given codimension. - - :param simplex: The N-simplex, represented by a list of vertex. - :type simplex: list of int. - :param codimension: The codimension. If codimension = 0, all cofaces - are returned (equivalent of get_star_tree function) - :type codimension: int. - :returns: list of tuples(simplex, filtration) -- the coface tree of a - simplex. - """ - cdef vector[int] complex - for i in simplex: - complex.push_back(i) - cdef vector[pair[vector[int], double]] coface_tree \ - = self.thisptr.get_coface_tree(complex, codimension) - ct = [] - for filtered_complex in coface_tree: - v = [] - for vertex in filtered_complex.first: - v.append(vertex) - ct.append((v, filtered_complex.second)) - return ct - - def remove_maximal_simplex(self, simplex): - """This function removes a given maximal N-simplex from the simplicial - complex. - - :param simplex: The N-simplex, represented by a list of vertex. - :type simplex: list of int. - """ - self.thisptr.remove_maximal_simplex(simplex) - - def persistence(self, homology_coeff_field=11): - """This function returns the persistence of the simplicial complex. - - :param homology_coeff_field: The homology coefficient field. Must be a - prime number - :type homology_coeff_field: int. - :param min_persistence: The minimum persistence value to take into - account (strictly greater than min_persistence). Default value is - 0.0. - Sets min_persistence to -1.0 to see all values. - :type min_persistence: float. - :returns: list of pairs(dimension, pair(birth, death)) -- the - persistence of the simplicial complex. - """ - if self.pcohptr != NULL: - del self.pcohptr - self.pcohptr = new Mini_simplex_tree_persistence_interface(self.thisptr) - cdef vector[pair[int, pair[double, double]]] persistence_result - if self.pcohptr != NULL: - persistence_result = self.pcohptr.get_persistence(homology_coeff_field, 0) - return persistence_result - - def betti_numbers(self): - """This function returns the Betti numbers of the simplicial complex. - - :returns: list of int -- The Betti numbers ([B0, B1, ..., Bn]). - - :note: betti_numbers function requires persistence function to be - launched first. - """ - cdef vector[int] bn_result - if self.pcohptr != NULL: - bn_result = self.pcohptr.betti_numbers() - else: - print("betti_numbers function requires persistence function" - " to be launched first.") - return bn_result - - def persistent_betti_numbers(self, from_value, to_value): - """This function returns the persistent Betti numbers of the - simplicial complex. - - :param from_value: The persistence birth limit to be added in the - numbers (persistent birth <= from_value). - :type from_value: float. - :param to_value: The persistence death limit to be added in the - numbers (persistent death > to_value). - :type to_value: float. - - :returns: list of int -- The persistent Betti numbers ([B0, B1, ..., - Bn]). - - :note: persistent_betti_numbers function requires persistence - function to be launched first. - """ - cdef vector[int] pbn_result - if self.pcohptr != NULL: - pbn_result = self.pcohptr.persistent_betti_numbers(from_value, to_value) - else: - print("persistent_betti_numbers function requires persistence function" - " to be launched first.") - return pbn_result diff --git a/src/cython/cython/rips_complex.pyx b/src/cython/cython/rips_complex.pyx index 08bd2388..2e739ac3 100644 --- a/src/cython/cython/rips_complex.pyx +++ b/src/cython/cython/rips_complex.pyx @@ -3,6 +3,7 @@ from libcpp.vector cimport vector from libcpp.utility cimport pair from libcpp.string cimport string from libcpp cimport bool +import os """This file is part of the Gudhi Library. The Gudhi library (Geometric Understanding in Higher Dimensions) is a generic C++ @@ -30,61 +31,37 @@ __author__ = "Vincent Rouvreau" __copyright__ = "Copyright (C) 2016 INRIA" __license__ = "GPL v3" -cdef extern from "Simplex_tree_interface.h" namespace "Gudhi": - cdef cppclass Simplex_tree_options_full_featured: - pass - - cdef cppclass Rips_complex_interface "Gudhi::Simplex_tree_interface": - Simplex_tree() - double filtration() - double simplex_filtration(vector[int] simplex) - void set_filtration(double filtration) - void initialize_filtration() - int num_vertices() - int num_simplices() - void set_dimension(int dimension) - int dimension() - bint find_simplex(vector[int] simplex) - bint insert_simplex_and_subfaces(vector[int] simplex, - double filtration) - vector[pair[vector[int], double]] get_filtered_tree() - vector[pair[vector[int], double]] get_skeleton_tree(int dimension) - vector[pair[vector[int], double]] get_star_tree(vector[int] simplex) - vector[pair[vector[int], double]] get_coface_tree(vector[int] simplex, - int dimension) - void remove_maximal_simplex(vector[int] simplex) - void graph_expansion(vector[vector[double]] points, int max_dimension, - double max_edge_length) - void graph_expansion(string off_file, int max_dimension, - double max_edge_length, bool from_file) - -cdef extern from "Persistent_cohomology_interface.h" namespace "Gudhi": - cdef cppclass Rips_complex_persistence_interface "Gudhi::Persistent_cohomology_interface>": - Rips_complex_persistence_interface(Rips_complex_interface * st) - vector[pair[int, pair[double, double]]] get_persistence(int homology_coeff_field, double min_persistence) - vector[int] betti_numbers() - vector[int] persistent_betti_numbers(double from_value, double to_value) +cdef extern from "Rips_complex_interface.h" namespace "Gudhi": + cdef cppclass Rips_complex_interface "Gudhi::rips_complex::Rips_complex_interface": + Rips_complex_interface(vector[vector[double]] points, double threshold) + # bool from_file is a workaround for cython to find the correct signature + Rips_complex_interface(string off_file, double threshold, bool from_file) + void create_simplex_tree(Simplex_tree_interface_full_featured* simplex_tree, int dim_max) # RipsComplex python interface cdef class RipsComplex: - """RipsComplex is a simplicial complex constructed from a list of points. + """RipsComplex is a simplicial complex constructed from the finite cells + of a Delaunay Triangulation. + + The filtration value of each simplex is computed as the square of the + circumradius of the simplex if the circumsphere is empty (the simplex is + then said to be Gabriel), and as the minimum of the filtration values of + the codimension 1 cofaces that make it not Gabriel otherwise. + + All simplices that have a filtration value strictly greater than a given + alpha squared value are not inserted into the complex. + + .. note:: - Each point Pn is inserted as a vertex in the simplicial complex with a - null filtration value. + When Rips_complex is constructed with an infinite value of alpha, the + complex is a Delaunay complex. - A N-simplex represented by the list of vertices Vi, ..., Vj is inserted in - the simplicial complex if all the points Pi, ..., Pj corresponding to the - vertices are within a distance less or equal to a given maximum edge length - value, and if N (dimension of the N-simplex) is less or equal to a given - maximum dimension. """ - cdef Rips_complex_interface * thisptr - cdef Rips_complex_persistence_interface * pcohptr + cdef Rips_complex_interface * thisptr # Fake constructor that does nothing but documenting the constructor - def __init__(self, points=[], off_file='', max_dimension=3, - max_edge_length=float('inf')): + def __init__(self, points=[], off_file='', max_edge_length=float('inf')): """RipsComplex constructor. :param points: A list of points in d-Dimension. @@ -95,291 +72,40 @@ cdef class RipsComplex: :param off_file: An OFF file style name. :type off_file: string - :param max_dimension: Maximum dimension of the complex to be expanded. - :type max_dimension: int - :param max_edge_length: Maximum edge length value (rips radius). - :type max_edge_length: double + :param max_edge_length: Rips value. + :type max_edge_length: int """ # The real cython constructor - def __cinit__(self, points=[], off_file='', max_dimension=3, - max_edge_length=float('inf')): - self.thisptr = new Rips_complex_interface() - # Constructor from graph expansion + def __cinit__(self, points=[], off_file='', max_edge_length=float('inf')): if off_file is not '': if os.path.isfile(off_file): - self.thisptr.graph_expansion(off_file, max_dimension, - max_edge_length, True) + self.thisptr = new Rips_complex_interface(off_file, + max_edge_length, + True) else: print("file " + off_file + " not found.") else: - self.thisptr.graph_expansion(points, max_dimension, - max_edge_length) + self.thisptr = new Rips_complex_interface(points, max_edge_length) + def __dealloc__(self): if self.thisptr != NULL: del self.thisptr - if self.pcohptr != NULL: - del self.pcohptr def __is_defined(self): """Returns true if RipsComplex pointer is not NULL. """ return self.thisptr != NULL - def __is_persistence_defined(self): - """Returns true if Persistence pointer is not NULL. - """ - return self.pcohptr != NULL - - def get_filtration(self): - """This function returns the main simplicial complex filtration value. - - :returns: float -- the simplicial complex filtration value. - """ - return self.thisptr.filtration() - - def filtration(self, simplex): - """This function returns the simplicial complex filtration value for a - given N-simplex. - - :param simplex: The N-simplex, represented by a list of vertex. - :type simplex: list of int. - :returns: float -- the simplicial complex filtration value. - """ - return self.thisptr.simplex_filtration(simplex) - - def set_filtration(self, filtration): - """This function sets the main simplicial complex filtration value. - - :param filtration: The filtration value. - :type filtration: float. + def create_simplex_tree(self, max_dimension=1): """ - self.thisptr.set_filtration( filtration) - - def initialize_filtration(self): - """This function initializes and sorts the simplicial complex - filtration vector. - - .. note:: - - This function must be launched before persistence, betti_numbers, - persistent_betti_numbers or get_filtered_tree after inserting or - removing simplices. - """ - self.thisptr.initialize_filtration() - - def num_vertices(self): - """This function returns the number of vertices of the simplicial - complex. - - :returns: int -- the simplicial complex number of vertices. - """ - return self.thisptr.num_vertices() - - def num_simplices(self): - """This function returns the number of simplices of the simplicial - complex. - - :returns: int -- the simplicial complex number of simplices. - """ - return self.thisptr.num_simplices() - - def dimension(self): - """This function returns the dimension of the simplicial complex. - - :returns: int -- the simplicial complex dimension. - """ - return self.thisptr.dimension() - - def set_dimension(self, dimension): - """This function sets the dimension of the simplicial complex. - - :param dimension: The new dimension value. - :type dimension: int. - """ - self.thisptr.set_dimension(dimension) - - def find(self, simplex): - """This function returns if the N-simplex was found in the simplicial - complex or not. - - :param simplex: The N-simplex to find, represented by a list of vertex. - :type simplex: list of int. - :returns: bool -- true if the simplex was found, false otherwise. - """ - cdef vector[int] complex - for i in simplex: - complex.push_back(i) - return self.thisptr.find_simplex(complex) - - def insert(self, simplex, filtration=0.0): - """This function inserts the given N-simplex with the given filtration - value (default value is '0.0'). - - :param simplex: The N-simplex to insert, represented by a list of - vertex. - :type simplex: list of int. - :param filtration: The filtration value of the simplex. - :type filtration: float. - :returns: bool -- true if the simplex was found, false otherwise. - """ - cdef vector[int] complex - for i in simplex: - complex.push_back(i) - return self.thisptr.insert_simplex_and_subfaces(complex, - filtration) - - def get_filtered_tree(self): - """This function returns the tree sorted by increasing filtration - values. - - :returns: list of tuples(simplex, filtration) -- the tree sorted by - increasing filtration values. - """ - cdef vector[pair[vector[int], double]] coface_tree \ - = self.thisptr.get_filtered_tree() - ct = [] - for filtered_complex in coface_tree: - v = [] - for vertex in filtered_complex.first: - v.append(vertex) - ct.append((v, filtered_complex.second)) - return ct - - def get_skeleton_tree(self, dimension): - """This function returns the tree skeleton of a maximum given - dimension. - - :param dimension: The skeleton dimension value. - :type dimension: int. - :returns: list of tuples(simplex, filtration) -- the skeleton tree - of a maximum dimension. - """ - cdef vector[pair[vector[int], double]] coface_tree \ - = self.thisptr.get_skeleton_tree(dimension) - ct = [] - for filtered_complex in coface_tree: - v = [] - for vertex in filtered_complex.first: - v.append(vertex) - ct.append((v, filtered_complex.second)) - return ct - - def get_star_tree(self, simplex): - """This function returns the star tree of a given N-simplex. - - :param simplex: The N-simplex, represented by a list of vertex. - :type simplex: list of int. - :returns: list of tuples(simplex, filtration) -- the star tree of a - simplex. - """ - cdef vector[int] complex - for i in simplex: - complex.push_back(i) - cdef vector[pair[vector[int], double]] coface_tree \ - = self.thisptr.get_star_tree(complex) - ct = [] - for filtered_complex in coface_tree: - v = [] - for vertex in filtered_complex.first: - v.append(vertex) - ct.append((v, filtered_complex.second)) - return ct - - def get_coface_tree(self, simplex, codimension): - """This function returns the coface tree of a given N-simplex with a - given codimension. - - :param simplex: The N-simplex, represented by a list of vertex. - :type simplex: list of int. - :param codimension: The codimension. If codimension = 0, all cofaces - are returned (equivalent of get_star_tree function) - :type codimension: int. - :returns: list of tuples(simplex, filtration) -- the coface tree of a - simplex. - """ - cdef vector[int] complex - for i in simplex: - complex.push_back(i) - cdef vector[pair[vector[int], double]] coface_tree \ - = self.thisptr.get_coface_tree(complex, codimension) - ct = [] - for filtered_complex in coface_tree: - v = [] - for vertex in filtered_complex.first: - v.append(vertex) - ct.append((v, filtered_complex.second)) - return ct - - def remove_maximal_simplex(self, simplex): - """This function removes a given maximal N-simplex from the simplicial - complex. - - :param simplex: The N-simplex, represented by a list of vertex. - :type simplex: list of int. - """ - self.thisptr.remove_maximal_simplex(simplex) - - def persistence(self, homology_coeff_field=11, min_persistence=0): - """This function returns the persistence of the simplicial complex. - - :param homology_coeff_field: The homology coefficient field. Must be a - prime number - :type homology_coeff_field: int. - :param min_persistence: The minimum persistence value to take into - account (strictly greater than min_persistence). Default value is - 0.0. - Sets min_persistence to -1.0 to see all values. - :type min_persistence: float. - :note: list of pairs(dimension, pair(birth, death)) -- the - persistence of the simplicial complex. - """ - if self.pcohptr != NULL: - del self.pcohptr - self.pcohptr = new Rips_complex_persistence_interface(self.thisptr) - cdef vector[pair[int, pair[double, double]]] persistence_result - if self.pcohptr != NULL: - persistence_result = self.pcohptr.get_persistence(homology_coeff_field, min_persistence) - return persistence_result - - def betti_numbers(self): - """This function returns the Betti numbers of the simplicial complex. - - :returns: list of int -- The Betti numbers ([B0, B1, ..., Bn]). - - :note: betti_numbers function requires persistence function to be - launched first. - """ - cdef vector[int] bn_result - if self.pcohptr != NULL: - bn_result = self.pcohptr.betti_numbers() - else: - print("betti_numbers function requires persistence function" - " to be launched first.") - return bn_result - - def persistent_betti_numbers(self, from_value, to_value): - """This function returns the persistent Betti numbers of the - simplicial complex. - - :param from_value: The persistence birth limit to be added in the - numbers (persistent birth <= from_value). - :type from_value: float. - :param to_value: The persistence death limit to be added in the - numbers (persistent death > to_value). - :type to_value: float. - - :returns: list of int -- The persistent Betti numbers ([B0, B1, ..., - Bn]). - - :note: persistent_betti_numbers function requires persistence - function to be launched first. + :param max_dimension: graph expansion for rips until this given maximal + dimension. + :type max_dimension: int + :returns: A simplex tree created from the Delaunay Triangulation. + :rtype: SimplexTree """ - cdef vector[int] pbn_result - if self.pcohptr != NULL: - pbn_result = self.pcohptr.persistent_betti_numbers(from_value, to_value) - else: - print("persistent_betti_numbers function requires persistence function" - " to be launched first.") - return pbn_result + simplex_tree = SimplexTree() + self.thisptr.create_simplex_tree(simplex_tree.thisptr, max_dimension) + return simplex_tree diff --git a/src/cython/doc/persistent_cohomology_sum.rst b/src/cython/doc/persistent_cohomology_sum.rst index b306b3d4..cf3029fc 100644 --- a/src/cython/doc/persistent_cohomology_sum.rst +++ b/src/cython/doc/persistent_cohomology_sum.rst @@ -21,8 +21,5 @@ | :doc:`persistent_cohomology_user` | Please refer to each data structure that contains persistence | | | feature for reference: | | | | -| | * :doc:`alpha_complex_ref` | -| | * :doc:`cubical_complex_ref` | | | * :doc:`simplex_tree_ref` | -| | * :doc:`witness_complex_ref` | +---------------------------------------------+----------------------------------------------------------------------+ diff --git a/src/cython/doc/persistent_cohomology_user.rst b/src/cython/doc/persistent_cohomology_user.rst index 33b19ce2..ca936754 100644 --- a/src/cython/doc/persistent_cohomology_user.rst +++ b/src/cython/doc/persistent_cohomology_user.rst @@ -11,10 +11,7 @@ Definition | :doc:`persistent_cohomology_user` | Please refer to each data structure that contains persistence | | | feature for reference: | | | | -| | * :doc:`alpha_complex_ref` | -| | * :doc:`cubical_complex_ref` | | | * :doc:`simplex_tree_ref` | -| | * :doc:`witness_complex_ref` | +---------------------------------------------+----------------------------------------------------------------------+ diff --git a/src/cython/example/mini_simplex_tree_example.py b/src/cython/example/mini_simplex_tree_example.py deleted file mode 100755 index 7b65a9d6..00000000 --- a/src/cython/example/mini_simplex_tree_example.py +++ /dev/null @@ -1,73 +0,0 @@ -#!/usr/bin/env python - -import gudhi - -"""This file is part of the Gudhi Library. The Gudhi library - (Geometric Understanding in Higher Dimensions) is a generic C++ - library for computational topology. - - Author(s): Vincent Rouvreau - - Copyright (C) 2016 INRIA - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . -""" - -__author__ = "Vincent Rouvreau" -__copyright__ = "Copyright (C) 2016 INRIA" -__license__ = "GPL v3" - -print("#####################################################################") -print("MiniSimplexTree creation from insertion") - -""" Complex to build. - 1 3 - o---o - /X\ / - o---o o - 2 0 4 -""" - -triangle012 = [0, 1, 2] -edge03 = [0, 3] -edge13 = [1, 3] -vertex4 = [4] -mini_st = gudhi.MiniSimplexTree() -mini_st.insert(triangle012) -mini_st.insert(edge03) -mini_st.insert(edge13) -mini_st.insert(vertex4) - -# FIXME: Remove this line -mini_st.set_dimension(2) - -# initialize_filtration required before plain_homology -mini_st.initialize_filtration() - -print("persistence(homology_coeff_field=2)=") -print(mini_st.persistence(homology_coeff_field=2)) - -edge02 = [0, 2] -if mini_st.find(edge02): - # Only coface is 012 - print("coface(edge02,1)=", mini_st.get_coface_tree(edge02, 1)) - -if mini_st.get_coface_tree(triangle012, 1) == []: - # Precondition: Check the simplex has no coface before removing it. - mini_st.remove_maximal_simplex(triangle012) - -# initialize_filtration required after removing -mini_st.initialize_filtration() - -print("filtered_tree after triangle012 removal =", mini_st.get_filtered_tree()) diff --git a/src/cython/example/rips_complex_diagram_persistence_with_pandas_interface_example.py b/src/cython/example/rips_complex_diagram_persistence_with_pandas_interface_example.py index bcf2fbcb..8af1b767 100755 --- a/src/cython/example/rips_complex_diagram_persistence_with_pandas_interface_example.py +++ b/src/cython/example/rips_complex_diagram_persistence_with_pandas_interface_example.py @@ -53,16 +53,17 @@ message = "RipsComplex with max_edge_length=" + repr(args.max_edge_length) print(message) rips_complex = gudhi.RipsComplex(points=points.values, - max_dimension=len(points.values[0]), max_edge_length=args.max_edge_length) + max_edge_length=args.max_edge_length) -message = "Number of simplices=" + repr(rips_complex.num_simplices()) +simplex_tree = rips_complex.create_simplex_tree(max_dimension=len(points.values[0])) + +message = "Number of simplices=" + repr(simplex_tree.num_simplices()) print(message) -rips_complex.initialize_filtration() -diag = rips_complex.persistence() +diag = simplex_tree.persistence() print("betti_numbers()=") -print(rips_complex.betti_numbers()) +print(simplex_tree.betti_numbers()) if args.no_diagram == False: gudhi.diagram_persistence(diag) diff --git a/src/cython/example/rips_complex_from_points_example.py b/src/cython/example/rips_complex_from_points_example.py index 1a22d8e3..df6252cd 100755 --- a/src/cython/example/rips_complex_from_points_example.py +++ b/src/cython/example/rips_complex_from_points_example.py @@ -31,8 +31,10 @@ __license__ = "GPL v3" print("#####################################################################") print("RipsComplex creation from points") rips = gudhi.RipsComplex(points=[[0, 0], [1, 0], [0, 1], [1, 1]], - max_dimension=1, max_edge_length=42) + max_edge_length=42) -print("filtered_tree=", rips.get_filtered_tree()) -print("star([0])=", rips.get_star_tree([0])) -print("coface([0], 1)=", rips.get_coface_tree([0], 1)) +simplex_tree = rips.create_simplex_tree(max_dimension=1) + +print("filtered_tree=", simplex_tree.get_filtered_tree()) +print("star([0])=", simplex_tree.get_star_tree([0])) +print("coface([0], 1)=", simplex_tree.get_coface_tree([0], 1)) diff --git a/src/cython/example/rips_persistence_diagram.py b/src/cython/example/rips_persistence_diagram.py index fddea298..e485b2f5 100755 --- a/src/cython/example/rips_persistence_diagram.py +++ b/src/cython/example/rips_persistence_diagram.py @@ -31,9 +31,12 @@ __license__ = "GPL v3" print("#####################################################################") print("RipsComplex creation from points") rips = gudhi.RipsComplex(points=[[0, 0], [1, 0], [0, 1], [1, 1]], - max_dimension=1, max_edge_length=42) + max_edge_length=42) -diag = rips.persistence(homology_coeff_field=2, min_persistence=0) +simplex_tree = rips.create_simplex_tree(max_dimension=1) + + +diag = simplex_tree.persistence(homology_coeff_field=2, min_persistence=0) print("diag=", diag) gudhi.diagram_persistence(diag) diff --git a/src/cython/gudhi.pyx.in b/src/cython/gudhi.pyx.in index 60f4c30b..5dcb9d48 100644 --- a/src/cython/gudhi.pyx.in +++ b/src/cython/gudhi.pyx.in @@ -25,7 +25,6 @@ __copyright__ = "Copyright (C) 2016 INRIA" __license__ = "GPL v3" include "cython/simplex_tree.pyx" -include "cython/mini_simplex_tree.pyx" include "cython/rips_complex.pyx" include "cython/cubical_complex.pyx" include "cython/periodic_cubical_complex.pyx" diff --git a/src/cython/include/Alpha_complex_interface.h b/src/cython/include/Alpha_complex_interface.h index 81761c77..9f308ae9 100644 --- a/src/cython/include/Alpha_complex_interface.h +++ b/src/cython/include/Alpha_complex_interface.h @@ -29,9 +29,9 @@ #include "Simplex_tree_interface.h" -#include -#include // std::pair #include +#include +#include namespace Gudhi { @@ -40,11 +40,6 @@ namespace alpha_complex { class Alpha_complex_interface { using Dynamic_kernel = CGAL::Epick_d< CGAL::Dynamic_dimension_tag >; using Point_d = Dynamic_kernel::Point_d; - typedef typename Simplex_tree<>::Simplex_handle Simplex_handle; - typedef typename std::pair Insertion_result; - using Simplex = std::vector; - using Filtered_complex = std::pair; - using Complex_tree = std::vector; typedef typename Simplex_tree<>::Simplex_key Simplex_key; diff --git a/src/cython/include/Cubical_complex_interface.h b/src/cython/include/Cubical_complex_interface.h index 5d17ff6b..4c53523b 100644 --- a/src/cython/include/Cubical_complex_interface.h +++ b/src/cython/include/Cubical_complex_interface.h @@ -27,9 +27,9 @@ #include #include -#include -#include // std::pair #include +#include +#include namespace Gudhi { diff --git a/src/cython/include/Rips_complex_interface.h b/src/cython/include/Rips_complex_interface.h new file mode 100644 index 00000000..7e897b1d --- /dev/null +++ b/src/cython/include/Rips_complex_interface.h @@ -0,0 +1,70 @@ +/* This file is part of the Gudhi Library. The Gudhi library + * (Geometric Understanding in Higher Dimensions) is a generic C++ + * library for computational topology. + * + * Author(s): Vincent Rouvreau + * + * Copyright (C) 2016 INRIA + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef RIPS_COMPLEX_INTERFACE_H +#define RIPS_COMPLEX_INTERFACE_H + +#include +#include +#include +#include + +#include "Simplex_tree_interface.h" + +#include +#include +#include // std::pair +#include + +namespace Gudhi { + +namespace rips_complex { + +class Rips_complex_interface { + using Point_d = std::vector; + + public: + Rips_complex_interface(std::vector>&points, double threshold) { + rips_complex_ = new Rips_complex::Filtration_value>(points, threshold, + Euclidean_distance()); + } + + Rips_complex_interface(std::string off_file_name, double threshold, bool from_file = true) { + Gudhi::Points_off_reader off_reader(off_file_name); + rips_complex_ = new Rips_complex::Filtration_value>(off_reader.get_point_cloud(), + threshold, Euclidean_distance()); + } + + void create_simplex_tree(Simplex_tree_interface<>* simplex_tree, int dim_max) { + rips_complex_->create_complex(*simplex_tree, dim_max); + simplex_tree->initialize_filtration(); + } + + private: + Rips_complex::Filtration_value>* rips_complex_; +}; + +} // namespace rips_complex + +} // namespace Gudhi + +#endif // RIPS_COMPLEX_INTERFACE_H diff --git a/src/cython/include/Simplex_tree_interface.h b/src/cython/include/Simplex_tree_interface.h index 8e9dd966..19e02ca4 100644 --- a/src/cython/include/Simplex_tree_interface.h +++ b/src/cython/include/Simplex_tree_interface.h @@ -30,15 +30,17 @@ #include "Persistent_cohomology_interface.h" +#include #include #include // std::pair -#include namespace Gudhi { template class Simplex_tree_interface : public Simplex_tree { public: + typedef typename Simplex_tree::Filtration_value Filtration_value; + typedef typename Simplex_tree::Vertex_handle Vertex_handle; typedef typename Simplex_tree::Simplex_handle Simplex_handle; typedef typename std::pair Insertion_result; using Simplex = std::vector; @@ -115,42 +117,12 @@ class Simplex_tree_interface : public Simplex_tree { return coface_tree; } - void graph_expansion(std::vector>&points, int max_dimension, double max_edge_length) { - Graph_t prox_graph = compute_proximity_graph(points, max_edge_length, euclidean_distance>); - Simplex_tree::insert_graph(prox_graph); - Simplex_tree::expansion(max_dimension); - Simplex_tree::initialize_filtration(); - } - - void graph_expansion(std::string& off_file_name, int max_dimension, double max_edge_length, bool from_file=true) { - Gudhi::Points_off_reader> off_reader(off_file_name); - // Check the read operation was correct - if (!off_reader.is_valid()) { - std::cerr << "Unable to read file " << off_file_name << std::endl; - } else { - std::vector> points = off_reader.get_point_cloud(); - Graph_t prox_graph = compute_proximity_graph(points, max_edge_length, - euclidean_distance>); - Simplex_tree::insert_graph(prox_graph); - Simplex_tree::expansion(max_dimension); - Simplex_tree::initialize_filtration(); - } - } - void create_persistence(Gudhi::Persistent_cohomology_interface>* pcoh) { pcoh = new Gudhi::Persistent_cohomology_interface>(*this); } }; -struct Simplex_tree_options_mini : Simplex_tree_options_full_featured { - // Not doing persistence, so we don't need those - static const bool store_key = true; - static const bool store_filtration = false; - // I have few vertices - typedef short Vertex_handle; -}; - } // namespace Gudhi #endif // SIMPLEX_TREE_INTERFACE_H diff --git a/src/cython/include/Subsampling_interface.h b/src/cython/include/Subsampling_interface.h index 9340cd86..fb047441 100644 --- a/src/cython/include/Subsampling_interface.h +++ b/src/cython/include/Subsampling_interface.h @@ -29,8 +29,9 @@ #include #include -#include #include +#include +#include namespace Gudhi { diff --git a/src/cython/include/Tangential_complex_interface.h b/src/cython/include/Tangential_complex_interface.h index 9da32757..7c774c73 100644 --- a/src/cython/include/Tangential_complex_interface.h +++ b/src/cython/include/Tangential_complex_interface.h @@ -41,11 +41,6 @@ namespace tangential_complex { class Tangential_complex_interface { using Dynamic_kernel = CGAL::Epick_d< CGAL::Dynamic_dimension_tag >; using Point_d = Dynamic_kernel::Point_d; - typedef typename Simplex_tree<>::Simplex_handle Simplex_handle; - typedef typename std::pair Insertion_result; - using Simplex = std::vector; - using Filtered_complex = std::pair; - using Complex_tree = std::vector; using TC = Tangential_complex; public: diff --git a/src/cython/include/Witness_complex_interface.h b/src/cython/include/Witness_complex_interface.h index ab99adf5..a753bc1d 100644 --- a/src/cython/include/Witness_complex_interface.h +++ b/src/cython/include/Witness_complex_interface.h @@ -40,6 +40,8 @@ namespace witness_complex { class Witness_complex_interface { typedef typename Simplex_tree<>::Simplex_handle Simplex_handle; + typedef typename Simplex_tree<>::Filtration_value Filtration_value; + typedef typename Simplex_tree<>::Vertex_handle Vertex_handle; typedef typename std::pair Insertion_result; using Simplex = std::vector; using Filtered_complex = std::pair; @@ -51,7 +53,7 @@ class Witness_complex_interface { std::vector > knn; std::vector> landmarks; Gudhi::subsampling::pick_n_random_points(points, number_of_landmarks, std::back_inserter(landmarks)); - Gudhi::witness_complex::construct_closest_landmark_table(points, landmarks, knn); + Gudhi::witness_complex::construct_closest_landmark_table(points, landmarks, knn); Gudhi::witness_complex::witness_complex(knn, number_of_landmarks, points[0].size(), simplex_tree_); } diff --git a/src/cython/test/test_mini_simplex_tree.py b/src/cython/test/test_mini_simplex_tree.py deleted file mode 100755 index e44bfdbc..00000000 --- a/src/cython/test/test_mini_simplex_tree.py +++ /dev/null @@ -1,50 +0,0 @@ -from gudhi import MiniSimplexTree - -"""This file is part of the Gudhi Library. The Gudhi library - (Geometric Understanding in Higher Dimensions) is a generic C++ - library for computational topology. - - Author(s): Vincent Rouvreau - - Copyright (C) 2016 INRIA - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . -""" - -__author__ = "Vincent Rouvreau" -__copyright__ = "Copyright (C) 2016 INRIA" -__license__ = "GPL v3" - - -def test_mini(): - triangle012 = [0, 1, 2] - edge03 = [0, 3] - mini_st = MiniSimplexTree() - assert mini_st.__is_defined() == True - assert mini_st.__is_persistence_defined() == False - assert mini_st.insert(triangle012) == True - assert mini_st.insert(edge03) == True - # FIXME: Remove this line - mini_st.set_dimension(2) - - edge02 = [0, 2] - assert mini_st.find(edge02) == True - assert mini_st.get_coface_tree(edge02, 1) == \ - [([0, 1, 2], 0.0)] - - # remove_maximal_simplex test - assert mini_st.get_coface_tree(triangle012, 1) == [] - mini_st.remove_maximal_simplex(triangle012) - assert mini_st.find(edge02) == True - assert mini_st.find(triangle012) == False diff --git a/src/cython/test/test_rips_complex.py b/src/cython/test/test_rips_complex.py index 877289cf..687e8529 100755 --- a/src/cython/test/test_rips_complex.py +++ b/src/cython/test/test_rips_complex.py @@ -30,36 +30,39 @@ __license__ = "GPL v3" def test_empty_rips(): rips_complex = RipsComplex() assert rips_complex.__is_defined() == True - assert rips_complex.__is_persistence_defined() == False def test_rips(): point_list = [[0, 0], [1, 0], [0, 1], [1, 1]] - rips_complex = RipsComplex(points=point_list, max_dimension=1, - max_edge_length=42) - assert rips_complex.__is_defined() == True - assert rips_complex.__is_persistence_defined() == False + rips_complex = RipsComplex(points=point_list, max_edge_length=42) + + simplex_tree = rips_complex.create_simplex_tree(max_dimension=1) + + assert simplex_tree.__is_defined() == True + assert simplex_tree.__is_persistence_defined() == False - assert rips_complex.num_simplices() == 10 - assert rips_complex.num_vertices() == 4 + assert simplex_tree.num_simplices() == 10 + assert simplex_tree.num_vertices() == 4 - assert rips_complex.get_filtered_tree() == \ + assert simplex_tree.get_filtered_tree() == \ [([0], 0.0), ([1], 0.0), ([2], 0.0), ([3], 0.0), ([0, 1], 1.0), ([0, 2], 1.0), ([1, 3], 1.0), ([2, 3], 1.0), ([1, 2], 1.4142135623730951), ([0, 3], 1.4142135623730951)] - assert rips_complex.get_star_tree([0]) == \ + assert simplex_tree.get_star_tree([0]) == \ [([0], 0.0), ([0, 1], 1.0), ([0, 2], 1.0), ([0, 3], 1.4142135623730951)] - assert rips_complex.get_coface_tree([0], 1) == \ + assert simplex_tree.get_coface_tree([0], 1) == \ [([0, 1], 1.0), ([0, 2], 1.0), ([0, 3], 1.4142135623730951)] def test_filtered_rips(): point_list = [[0, 0], [1, 0], [0, 1], [1, 1]] - filtered_rips = RipsComplex(points=point_list, max_dimension=1, - max_edge_length=1.0) - assert filtered_rips.__is_defined() == True - assert filtered_rips.__is_persistence_defined() == False + filtered_rips = RipsComplex(points=point_list, max_edge_length=1.0) + + simplex_tree = filtered_rips.create_simplex_tree(max_dimension=1) + + assert simplex_tree.__is_defined() == True + assert simplex_tree.__is_persistence_defined() == False - assert filtered_rips.num_simplices() == 8 - assert filtered_rips.num_vertices() == 4 + assert simplex_tree.num_simplices() == 8 + assert simplex_tree.num_vertices() == 4 -- cgit v1.2.3 From 10411aae9845d28d36a9d4394bd668ed84d540f1 Mon Sep 17 00:00:00 2001 From: vrouvrea Date: Mon, 20 Mar 2017 13:44:20 +0000 Subject: constify interfaces git-svn-id: svn+ssh://scm.gforge.inria.fr/svnroot/gudhi/branches/ST_cythonize@2203 636b058d-ea47-450e-bf9e-a15bfbe3eedb Former-commit-id: 55cf020d2a7989dc4e7125bcf6f91443aad4dda1 --- src/cython/include/Alpha_complex_interface.h | 4 ++-- src/cython/include/Bottleneck_distance_interface.h | 8 ++++---- .../Euclidean_strong_witness_complex_interface.h | 6 ++++-- .../include/Euclidean_witness_complex_interface.h | 3 ++- src/cython/include/Off_reader_interface.h | 2 +- src/cython/include/Rips_complex_interface.h | 4 ++-- .../include/Strong_witness_complex_interface.h | 2 +- src/cython/include/Subsampling_interface.h | 24 ++++++++++++++-------- src/cython/include/Tangential_complex_interface.h | 4 ++-- src/cython/include/Witness_complex_interface.h | 2 +- 10 files changed, 35 insertions(+), 24 deletions(-) (limited to 'src/cython/include/Subsampling_interface.h') diff --git a/src/cython/include/Alpha_complex_interface.h b/src/cython/include/Alpha_complex_interface.h index bcd2849b..f11a464b 100644 --- a/src/cython/include/Alpha_complex_interface.h +++ b/src/cython/include/Alpha_complex_interface.h @@ -42,11 +42,11 @@ class Alpha_complex_interface { using Point_d = Dynamic_kernel::Point_d; public: - Alpha_complex_interface(std::vector>&points) { + Alpha_complex_interface(const std::vector>& points) { alpha_complex_ = new Alpha_complex(points); } - Alpha_complex_interface(std::string off_file_name, bool from_file = true) { + Alpha_complex_interface(const std::string& off_file_name, bool from_file = true) { alpha_complex_ = new Alpha_complex(off_file_name); } diff --git a/src/cython/include/Bottleneck_distance_interface.h b/src/cython/include/Bottleneck_distance_interface.h index b814661e..6819734b 100644 --- a/src/cython/include/Bottleneck_distance_interface.h +++ b/src/cython/include/Bottleneck_distance_interface.h @@ -34,14 +34,14 @@ namespace Gudhi { namespace persistence_diagram { // bottleneck_distance function renamed for the python function can be called bottleneck_dstance - double bottleneck(const std::vector> &diag1, - const std::vector> &diag2, + double bottleneck(const std::vector>& diag1, + const std::vector>& diag2, double e) { return bottleneck_distance(diag1, diag2, e); } - double bottleneck(const std::vector> &diag1, - const std::vector> &diag2) { + double bottleneck(const std::vector>& diag1, + const std::vector>& diag2) { return bottleneck_distance(diag1, diag2); } diff --git a/src/cython/include/Euclidean_strong_witness_complex_interface.h b/src/cython/include/Euclidean_strong_witness_complex_interface.h index 739014b9..fc88a82d 100644 --- a/src/cython/include/Euclidean_strong_witness_complex_interface.h +++ b/src/cython/include/Euclidean_strong_witness_complex_interface.h @@ -47,13 +47,15 @@ class Euclidean_strong_witness_complex_interface { typedef typename Simplex_tree<>::Simplex_key Simplex_key; public: - Euclidean_strong_witness_complex_interface(std::vector>&landmarks, std::vector>&witnesses) + Euclidean_strong_witness_complex_interface(const std::vector>& landmarks, + const std::vector>& witnesses) : landmarks_(landmarks.begin(), landmarks.end()), witnesses_(witnesses.begin(), witnesses.end()), witness_complex_(landmarks_, witnesses_) { } - void create_simplex_tree(Gudhi::Simplex_tree<>* simplex_tree, double max_alpha_square, std::size_t limit_dimension) { + void create_simplex_tree(Gudhi::Simplex_tree<>* simplex_tree, double max_alpha_square, + std::size_t limit_dimension) { witness_complex_.create_complex(*simplex_tree, max_alpha_square, limit_dimension); simplex_tree->initialize_filtration(); } diff --git a/src/cython/include/Euclidean_witness_complex_interface.h b/src/cython/include/Euclidean_witness_complex_interface.h index efa8885f..a1ec68aa 100644 --- a/src/cython/include/Euclidean_witness_complex_interface.h +++ b/src/cython/include/Euclidean_witness_complex_interface.h @@ -47,7 +47,8 @@ class Euclidean_witness_complex_interface { typedef typename Simplex_tree<>::Simplex_key Simplex_key; public: - Euclidean_witness_complex_interface(std::vector>&landmarks, std::vector>&witnesses) + Euclidean_witness_complex_interface(const std::vector>& landmarks, + const std::vector>& witnesses) : landmarks_(landmarks.begin(), landmarks.end()), witnesses_(witnesses.begin(), witnesses.end()), witness_complex_(landmarks_, witnesses_) { diff --git a/src/cython/include/Off_reader_interface.h b/src/cython/include/Off_reader_interface.h index 257331f8..97d64d3e 100644 --- a/src/cython/include/Off_reader_interface.h +++ b/src/cython/include/Off_reader_interface.h @@ -31,7 +31,7 @@ namespace Gudhi { -std::vector> read_points_from_OFF_file(std::string& off_file) { +std::vector> read_points_from_OFF_file(const std::string& off_file) { Gudhi::Points_off_reader> off_reader(off_file); return off_reader.get_point_cloud(); } diff --git a/src/cython/include/Rips_complex_interface.h b/src/cython/include/Rips_complex_interface.h index 9295906c..01df5366 100644 --- a/src/cython/include/Rips_complex_interface.h +++ b/src/cython/include/Rips_complex_interface.h @@ -45,7 +45,7 @@ class Rips_complex_interface { using Distance_matrix = std::vector::Filtration_value>>; public: - Rips_complex_interface(std::vector>&values, double threshold, bool euclidean) { + Rips_complex_interface(const std::vector>& values, double threshold, bool euclidean) { if (euclidean) { // Rips construction where values is a vector of points rips_complex_ = new Rips_complex::Filtration_value>(values, threshold, @@ -57,7 +57,7 @@ class Rips_complex_interface { } } - Rips_complex_interface(std::string file_name, double threshold, bool euclidean, bool from_file = true) { + Rips_complex_interface(const std::string& file_name, double threshold, bool euclidean, bool from_file = true) { if (euclidean) { // Rips construction where file_name is an OFF file Gudhi::Points_off_reader off_reader(file_name); diff --git a/src/cython/include/Strong_witness_complex_interface.h b/src/cython/include/Strong_witness_complex_interface.h index 5081ec2d..70e78a2a 100644 --- a/src/cython/include/Strong_witness_complex_interface.h +++ b/src/cython/include/Strong_witness_complex_interface.h @@ -42,7 +42,7 @@ class Strong_witness_complex_interface { using Nearest_landmark_table = std::vector; public: - Strong_witness_complex_interface(Nearest_landmark_table& nlt) { + Strong_witness_complex_interface(const Nearest_landmark_table& nlt) { witness_complex_ = new Strong_witness_complex(nlt); } diff --git a/src/cython/include/Subsampling_interface.h b/src/cython/include/Subsampling_interface.h index fb047441..5fc16767 100644 --- a/src/cython/include/Subsampling_interface.h +++ b/src/cython/include/Subsampling_interface.h @@ -42,7 +42,8 @@ using Subsampling_point_d = Subsampling_dynamic_kernel::Point_d; using Subsampling_ft = Subsampling_dynamic_kernel::FT; // ------ choose_n_farthest_points ------ -std::vector> subsampling_n_farthest_points(std::vector>& points, unsigned nb_points) { +std::vector> subsampling_n_farthest_points(const std::vector>& points, + unsigned nb_points) { std::vector> landmarks; Subsampling_dynamic_kernel k; choose_n_farthest_points(k, points, nb_points, std::back_inserter(landmarks)); @@ -50,7 +51,8 @@ std::vector> subsampling_n_farthest_points(std::vector> subsampling_n_farthest_points(std::vector>& points, unsigned nb_points, unsigned starting_point) { +std::vector> subsampling_n_farthest_points(const std::vector>& points, + unsigned nb_points, unsigned starting_point) { std::vector> landmarks; Subsampling_dynamic_kernel k; choose_n_farthest_points(k, points, nb_points, starting_point, std::back_inserter(landmarks)); @@ -58,34 +60,39 @@ std::vector> subsampling_n_farthest_points(std::vector> subsampling_n_farthest_points_from_file(std::string& off_file, unsigned nb_points) { +std::vector> subsampling_n_farthest_points_from_file(const std::string& off_file, + unsigned nb_points) { Gudhi::Points_off_reader> off_reader(off_file); std::vector> points = off_reader.get_point_cloud(); return subsampling_n_farthest_points(points, nb_points); } -std::vector> subsampling_n_farthest_points_from_file(std::string& off_file, unsigned nb_points, unsigned starting_point) { +std::vector> subsampling_n_farthest_points_from_file(const std::string& off_file, + unsigned nb_points, unsigned starting_point) { Gudhi::Points_off_reader> off_reader(off_file); std::vector> points = off_reader.get_point_cloud(); return subsampling_n_farthest_points(points, nb_points, starting_point); } // ------ pick_n_random_points ------ -std::vector> subsampling_n_random_points(std::vector>& points, unsigned nb_points) { +std::vector> subsampling_n_random_points(const std::vector>& points, + unsigned nb_points) { std::vector> landmarks; pick_n_random_points(points, nb_points, std::back_inserter(landmarks)); return landmarks; } -std::vector> subsampling_n_random_points_from_file(std::string& off_file, unsigned nb_points) { +std::vector> subsampling_n_random_points_from_file(const std::string& off_file, + unsigned nb_points) { Gudhi::Points_off_reader> off_reader(off_file); std::vector> points = off_reader.get_point_cloud(); return subsampling_n_random_points(points, nb_points); } // ------ sparsify_point_set ------ -std::vector> subsampling_sparsify_points(std::vector>& points, double min_squared_dist) { +std::vector> subsampling_sparsify_points(const std::vector>& points, + double min_squared_dist) { std::vector input, output; for (auto point : points) input.push_back(Subsampling_point_d(point.size(), point.begin(), point.end())); @@ -98,7 +105,8 @@ std::vector> subsampling_sparsify_points(std::vector> subsampling_sparsify_points_from_file(std::string& off_file, double min_squared_dist) { +std::vector> subsampling_sparsify_points_from_file(const std::string& off_file, + double min_squared_dist) { Gudhi::Points_off_reader> off_reader(off_file); std::vector> points = off_reader.get_point_cloud(); return subsampling_sparsify_points(points, min_squared_dist); diff --git a/src/cython/include/Tangential_complex_interface.h b/src/cython/include/Tangential_complex_interface.h index 7c774c73..93d9bad7 100644 --- a/src/cython/include/Tangential_complex_interface.h +++ b/src/cython/include/Tangential_complex_interface.h @@ -44,7 +44,7 @@ class Tangential_complex_interface { using TC = Tangential_complex; public: - Tangential_complex_interface(std::vector>&points) { + Tangential_complex_interface(const std::vector>& points) { Dynamic_kernel k; unsigned intrisic_dim = 0; if (points.size() > 0) @@ -55,7 +55,7 @@ class Tangential_complex_interface { num_inconsistencies_ = tangential_complex_->number_of_inconsistent_simplices(); } - Tangential_complex_interface(std::string off_file_name, bool from_file = true) { + Tangential_complex_interface(const std::string& off_file_name, bool from_file = true) { Gudhi::Points_off_reader off_reader(off_file_name); Dynamic_kernel k; unsigned intrisic_dim = 0; diff --git a/src/cython/include/Witness_complex_interface.h b/src/cython/include/Witness_complex_interface.h index 3761b43d..835b69ab 100644 --- a/src/cython/include/Witness_complex_interface.h +++ b/src/cython/include/Witness_complex_interface.h @@ -42,7 +42,7 @@ class Witness_complex_interface { using Nearest_landmark_table = std::vector; public: - Witness_complex_interface(Nearest_landmark_table& nlt) { + Witness_complex_interface(const Nearest_landmark_table& nlt) { witness_complex_ = new Witness_complex(nlt); } -- cgit v1.2.3 From f48eae4cd7dc50dbbe0c8ec4f63bb98dda51a5d8 Mon Sep 17 00:00:00 2001 From: vrouvrea Date: Fri, 24 Mar 2017 06:20:50 +0000 Subject: Fix cpplint on cython interfaces git-svn-id: svn+ssh://scm.gforge.inria.fr/svnroot/gudhi/trunk@2229 636b058d-ea47-450e-bf9e-a15bfbe3eedb Former-commit-id: 41a958b1be51ac938b45b384cde7940a85e9dea0 --- .../doc/Intro_bottleneck_distance.h | 6 ++-- src/cython/include/Alpha_complex_interface.h | 6 ++-- src/cython/include/Bottleneck_distance_interface.h | 8 +++--- src/cython/include/Cubical_complex_interface.h | 8 ++---- .../Euclidean_strong_witness_complex_interface.h | 10 +++---- .../include/Euclidean_witness_complex_interface.h | 10 +++---- src/cython/include/Off_reader_interface.h | 6 ++-- .../include/Persistent_cohomology_interface.h | 32 +++++++++++----------- src/cython/include/Rips_complex_interface.h | 12 ++++---- src/cython/include/Simplex_tree_interface.h | 12 +++----- .../include/Strong_witness_complex_interface.h | 10 +++---- src/cython/include/Subsampling_interface.h | 8 ++---- src/cython/include/Tangential_complex_interface.h | 12 ++++---- src/cython/include/Witness_complex_interface.h | 9 +++--- 14 files changed, 68 insertions(+), 81 deletions(-) (limited to 'src/cython/include/Subsampling_interface.h') diff --git a/src/Bottleneck_distance/doc/Intro_bottleneck_distance.h b/src/Bottleneck_distance/doc/Intro_bottleneck_distance.h index 5223678d..3998fe8d 100644 --- a/src/Bottleneck_distance/doc/Intro_bottleneck_distance.h +++ b/src/Bottleneck_distance/doc/Intro_bottleneck_distance.h @@ -35,9 +35,9 @@ namespace persistence_diagram { * * \section bottleneckdefinition Definition * - * The bottleneck distance measures the similarity between two persistence diagrams. It is the shortest distance b for which there exists a perfect matching between - * the points of the two diagrams (completed with all the points on the diagonal in order to ignore cardinality mismatchs) such that - * any couple of matched points are at distance at most b. + * The bottleneck distance measures the similarity between two persistence diagrams. It is the shortest distance b for + * which there exists a perfect matching between the points of the two diagrams (completed with all the points on the + * diagonal in order to ignore cardinality mismatchs) such that any couple of matched points are at distance at most b. * * \image html perturb_pd.png On this picture, the red edges represent the matching. The bottleneck distance is the length of the longest edge. * diff --git a/src/cython/include/Alpha_complex_interface.h b/src/cython/include/Alpha_complex_interface.h index d74ff304..d47db71f 100644 --- a/src/cython/include/Alpha_complex_interface.h +++ b/src/cython/include/Alpha_complex_interface.h @@ -20,8 +20,8 @@ * along with this program. If not, see . */ -#ifndef ALPHA_COMPLEX_INTERFACE_H -#define ALPHA_COMPLEX_INTERFACE_H +#ifndef INCLUDE_ALPHA_COMPLEX_INTERFACE_H_ +#define INCLUDE_ALPHA_COMPLEX_INTERFACE_H_ #include #include @@ -79,4 +79,4 @@ class Alpha_complex_interface { } // namespace Gudhi -#endif // ALPHA_COMPLEX_INTERFACE_H +#endif // INCLUDE_ALPHA_COMPLEX_INTERFACE_H_ diff --git a/src/cython/include/Bottleneck_distance_interface.h b/src/cython/include/Bottleneck_distance_interface.h index 6819734b..d5fbf6ea 100644 --- a/src/cython/include/Bottleneck_distance_interface.h +++ b/src/cython/include/Bottleneck_distance_interface.h @@ -20,8 +20,8 @@ * along with this program. If not, see . */ -#ifndef BOTTLENECK_DISTANCE_INTERFACE_H -#define BOTTLENECK_DISTANCE_INTERFACE_H +#ifndef INCLUDE_BOTTLENECK_DISTANCE_INTERFACE_H_ +#define INCLUDE_BOTTLENECK_DISTANCE_INTERFACE_H_ #include @@ -45,9 +45,9 @@ namespace persistence_diagram { return bottleneck_distance(diag1, diag2); } -} // namespace alpha_complex +} // namespace persistence_diagram } // namespace Gudhi -#endif // BOTTLENECK_DISTANCE_INTERFACE_H +#endif // INCLUDE_BOTTLENECK_DISTANCE_INTERFACE_H_ diff --git a/src/cython/include/Cubical_complex_interface.h b/src/cython/include/Cubical_complex_interface.h index 4c53523b..7c0148f1 100644 --- a/src/cython/include/Cubical_complex_interface.h +++ b/src/cython/include/Cubical_complex_interface.h @@ -20,8 +20,8 @@ * along with this program. If not, see . */ -#ifndef CUBICAL_COMPLEX_INTERFACE_H -#define CUBICAL_COMPLEX_INTERFACE_H +#ifndef INCLUDE_CUBICAL_COMPLEX_INTERFACE_H_ +#define INCLUDE_CUBICAL_COMPLEX_INTERFACE_H_ #include #include @@ -38,7 +38,6 @@ namespace cubical_complex { template> class Cubical_complex_interface : public Bitmap_cubical_complex { public: - Cubical_complex_interface(const std::vector& dimensions, const std::vector& top_dimensional_cells) : Bitmap_cubical_complex(dimensions, top_dimensional_cells) { @@ -47,12 +46,11 @@ class Cubical_complex_interface : public Bitmap_cubical_complex(perseus_file.c_str()) { } - }; } // namespace cubical_complex } // namespace Gudhi -#endif // CUBICAL_COMPLEX_INTERFACE_H +#endif // INCLUDE_CUBICAL_COMPLEX_INTERFACE_H_ diff --git a/src/cython/include/Euclidean_strong_witness_complex_interface.h b/src/cython/include/Euclidean_strong_witness_complex_interface.h index 67d85e18..b9dd8177 100644 --- a/src/cython/include/Euclidean_strong_witness_complex_interface.h +++ b/src/cython/include/Euclidean_strong_witness_complex_interface.h @@ -20,8 +20,8 @@ * along with this program. If not, see . */ -#ifndef EUCLIDEAN_STRONG_WITNESS_COMPLEX_INTERFACE_H -#define EUCLIDEAN_STRONG_WITNESS_COMPLEX_INTERFACE_H +#ifndef INCLUDE_EUCLIDEAN_STRONG_WITNESS_COMPLEX_INTERFACE_H_ +#define INCLUDE_EUCLIDEAN_STRONG_WITNESS_COMPLEX_INTERFACE_H_ #include #include @@ -50,7 +50,7 @@ class Euclidean_strong_witness_complex_interface { Euclidean_strong_witness_complex_interface(const std::vector>& landmarks, const std::vector>& witnesses) { landmarks_.reserve(landmarks.size()); - for(auto& landmark : landmarks) + for (auto& landmark : landmarks) landmarks_.emplace_back(landmark.begin(), landmark.end()); witness_complex_ = new Euclidean_strong_witness_complex(landmarks_, witnesses); } @@ -87,7 +87,7 @@ class Euclidean_strong_witness_complex_interface { } // namespace witness_complex -} // namespace Gudhi +} // namespace Gudhi -#endif // EUCLIDEAN_STRONG_WITNESS_COMPLEX_INTERFACE_H +#endif // INCLUDE_EUCLIDEAN_STRONG_WITNESS_COMPLEX_INTERFACE_H_ diff --git a/src/cython/include/Euclidean_witness_complex_interface.h b/src/cython/include/Euclidean_witness_complex_interface.h index a2db6a2d..2a09b3b5 100644 --- a/src/cython/include/Euclidean_witness_complex_interface.h +++ b/src/cython/include/Euclidean_witness_complex_interface.h @@ -20,8 +20,8 @@ * along with this program. If not, see . */ -#ifndef EUCLIDEAN_WITNESS_COMPLEX_INTERFACE_H -#define EUCLIDEAN_WITNESS_COMPLEX_INTERFACE_H +#ifndef INCLUDE_EUCLIDEAN_WITNESS_COMPLEX_INTERFACE_H_ +#define INCLUDE_EUCLIDEAN_WITNESS_COMPLEX_INTERFACE_H_ #include #include @@ -50,7 +50,7 @@ class Euclidean_witness_complex_interface { Euclidean_witness_complex_interface(const std::vector>& landmarks, const std::vector>& witnesses) { landmarks_.reserve(landmarks.size()); - for(auto& landmark : landmarks) + for (auto& landmark : landmarks) landmarks_.emplace_back(landmark.begin(), landmark.end()); witness_complex_ = new Euclidean_witness_complex(landmarks_, witnesses); } @@ -86,7 +86,7 @@ class Euclidean_witness_complex_interface { } // namespace witness_complex -} // namespace Gudhi +} // namespace Gudhi -#endif // EUCLIDEAN_WITNESS_COMPLEX_INTERFACE_H +#endif // INCLUDE_EUCLIDEAN_WITNESS_COMPLEX_INTERFACE_H_ diff --git a/src/cython/include/Off_reader_interface.h b/src/cython/include/Off_reader_interface.h index 97d64d3e..0ca55500 100644 --- a/src/cython/include/Off_reader_interface.h +++ b/src/cython/include/Off_reader_interface.h @@ -20,8 +20,8 @@ * along with this program. If not, see . */ -#ifndef OFF_READER_INTERFACE_H -#define OFF_READER_INTERFACE_H +#ifndef INCLUDE_OFF_READER_INTERFACE_H_ +#define INCLUDE_OFF_READER_INTERFACE_H_ #include @@ -38,5 +38,5 @@ std::vector> read_points_from_OFF_file(const std::string& of } // namespace Gudhi -#endif // OFF_READER_INTERFACE_H +#endif // INCLUDE_OFF_READER_INTERFACE_H_ diff --git a/src/cython/include/Persistent_cohomology_interface.h b/src/cython/include/Persistent_cohomology_interface.h index 1ff0e09b..25c458d2 100644 --- a/src/cython/include/Persistent_cohomology_interface.h +++ b/src/cython/include/Persistent_cohomology_interface.h @@ -20,13 +20,14 @@ * along with this program. If not, see . */ -#ifndef PERSISTENT_COHOMOLOGY_INTERFACE_H -#define PERSISTENT_COHOMOLOGY_INTERFACE_H +#ifndef INCLUDE_PERSISTENT_COHOMOLOGY_INTERFACE_H_ +#define INCLUDE_PERSISTENT_COHOMOLOGY_INTERFACE_H_ #include #include #include // for std::pair +#include // for sort namespace Gudhi { @@ -34,12 +35,10 @@ template class Persistent_cohomology_interface : public persistent_cohomology::Persistent_cohomology { private: - /* * Compare two intervals by dimension, then by length. */ struct cmp_intervals_by_dim_then_length { - explicit cmp_intervals_by_dim_then_length(FilteredComplex * sc) : sc_(sc) { } @@ -55,23 +54,26 @@ persistent_cohomology::Persistent_cohomology(*stptr), stptr_(stptr) { } Persistent_cohomology_interface(FilteredComplex* stptr, bool persistence_dim_max) - : persistent_cohomology::Persistent_cohomology(*stptr, - persistence_dim_max), - stptr_(stptr) { } + : persistent_cohomology::Persistent_cohomology(*stptr, persistence_dim_max), + stptr_(stptr) { } - std::vector>> get_persistence(int homology_coeff_field, double min_persistence) { - persistent_cohomology::Persistent_cohomology::init_coefficients(homology_coeff_field); - persistent_cohomology::Persistent_cohomology::compute_persistent_cohomology(min_persistence); + std::vector>> get_persistence(int homology_coeff_field, + double min_persistence) { + persistent_cohomology::Persistent_cohomology::init_coefficients(homology_coeff_field); + persistent_cohomology::Persistent_cohomology::compute_persistent_cohomology(min_persistence); // Custom sort and output persistence cmp_intervals_by_dim_then_length cmp(stptr_); - auto persistent_pairs = persistent_cohomology::Persistent_cohomology::get_persistent_pairs(); + auto persistent_pairs = persistent_cohomology::Persistent_cohomology::get_persistent_pairs(); std::sort(std::begin(persistent_pairs), std::end(persistent_pairs), cmp); std::vector>> persistence; @@ -81,7 +83,6 @@ persistent_cohomology::Persistent_cohomologyfiltration(get<1>(pair))))); } return persistence; - } private: @@ -90,7 +91,6 @@ persistent_cohomology::Persistent_cohomology. */ -#ifndef RIPS_COMPLEX_INTERFACE_H -#define RIPS_COMPLEX_INTERFACE_H +#ifndef INCLUDE_RIPS_COMPLEX_INTERFACE_H_ +#define INCLUDE_RIPS_COMPLEX_INTERFACE_H_ #include #include @@ -53,7 +53,6 @@ class Rips_complex_interface { } else { // Rips construction where values is a distance matrix rips_complex_ = new Rips_complex::Filtration_value>(values, threshold); - } } @@ -65,11 +64,10 @@ class Rips_complex_interface { threshold, Euclidean_distance()); } else { // Rips construction where values is a distance matrix - Distance_matrix distances = read_lower_triangular_matrix_from_csv_file::Filtration_value>(file_name); + Distance_matrix distances = + read_lower_triangular_matrix_from_csv_file::Filtration_value>(file_name); rips_complex_ = new Rips_complex::Filtration_value>(distances, threshold); - } - } void create_simplex_tree(Simplex_tree_interface<>* simplex_tree, int dim_max) { @@ -85,4 +83,4 @@ class Rips_complex_interface { } // namespace Gudhi -#endif // RIPS_COMPLEX_INTERFACE_H +#endif // INCLUDE_RIPS_COMPLEX_INTERFACE_H_ diff --git a/src/cython/include/Simplex_tree_interface.h b/src/cython/include/Simplex_tree_interface.h index c2783e22..4266b3ef 100644 --- a/src/cython/include/Simplex_tree_interface.h +++ b/src/cython/include/Simplex_tree_interface.h @@ -20,8 +20,8 @@ * along with this program. If not, see . */ -#ifndef SIMPLEX_TREE_INTERFACE_H -#define SIMPLEX_TREE_INTERFACE_H +#ifndef INCLUDE_SIMPLEX_TREE_INTERFACE_H_ +#define INCLUDE_SIMPLEX_TREE_INTERFACE_H_ #include #include @@ -48,7 +48,6 @@ class Simplex_tree_interface : public Simplex_tree { using Complex = std::vector>; public: - bool find_simplex(const Simplex& vh) { return (Base::find(vh) != Base::null_simplex()); } @@ -98,7 +97,6 @@ class Simplex_tree_interface : public Simplex_tree { filtered_tree.push_back(std::make_pair(simplex, Base::filtration(f_simplex))); } return filtered_tree; - } Complex get_skeleton_tree(int dimension) { @@ -144,10 +142,8 @@ class Simplex_tree_interface : public Simplex_tree { void create_persistence(Gudhi::Persistent_cohomology_interface* pcoh) { pcoh = new Gudhi::Persistent_cohomology_interface(*this); } - }; -} // namespace Gudhi - -#endif // SIMPLEX_TREE_INTERFACE_H +} // namespace Gudhi +#endif // INCLUDE_SIMPLEX_TREE_INTERFACE_H_ diff --git a/src/cython/include/Strong_witness_complex_interface.h b/src/cython/include/Strong_witness_complex_interface.h index 83bf0f3c..d05eaac5 100644 --- a/src/cython/include/Strong_witness_complex_interface.h +++ b/src/cython/include/Strong_witness_complex_interface.h @@ -20,8 +20,8 @@ * along with this program. If not, see . */ -#ifndef STRONG_WITNESS_COMPLEX_INTERFACE_H -#define STRONG_WITNESS_COMPLEX_INTERFACE_H +#ifndef INCLUDE_STRONG_WITNESS_COMPLEX_INTERFACE_H_ +#define INCLUDE_STRONG_WITNESS_COMPLEX_INTERFACE_H_ #include #include @@ -64,12 +64,10 @@ class Strong_witness_complex_interface { private: Strong_witness_complex* witness_complex_; - }; } // namespace witness_complex -} // namespace Gudhi - -#endif // STRONG_WITNESS_COMPLEX_INTERFACE_H +} // namespace Gudhi +#endif // INCLUDE_STRONG_WITNESS_COMPLEX_INTERFACE_H_ diff --git a/src/cython/include/Subsampling_interface.h b/src/cython/include/Subsampling_interface.h index 5fc16767..1c6032c0 100644 --- a/src/cython/include/Subsampling_interface.h +++ b/src/cython/include/Subsampling_interface.h @@ -20,8 +20,8 @@ * along with this program. If not, see . */ -#ifndef SUBSAMPLING_INTERFACE_H -#define SUBSAMPLING_INTERFACE_H +#ifndef INCLUDE_SUBSAMPLING_INTERFACE_H_ +#define INCLUDE_SUBSAMPLING_INTERFACE_H_ #include #include @@ -112,10 +112,8 @@ std::vector> subsampling_sparsify_points_from_file(const std return subsampling_sparsify_points(points, min_squared_dist); } - } // namespace subsampling } // namespace Gudhi -#endif // SUBSAMPLING_INTERFACE_H - +#endif // INCLUDE_SUBSAMPLING_INTERFACE_H_ diff --git a/src/cython/include/Tangential_complex_interface.h b/src/cython/include/Tangential_complex_interface.h index 2ca4c393..5e9dc0e4 100644 --- a/src/cython/include/Tangential_complex_interface.h +++ b/src/cython/include/Tangential_complex_interface.h @@ -20,8 +20,8 @@ * along with this program. If not, see . */ -#ifndef TANGENTIAL_COMPLEX_INTERFACE_H -#define TANGENTIAL_COMPLEX_INTERFACE_H +#ifndef INCLUDE_TANGENTIAL_COMPLEX_INTERFACE_H_ +#define INCLUDE_TANGENTIAL_COMPLEX_INTERFACE_H_ #include #include @@ -33,6 +33,7 @@ #include #include // std::pair #include +#include namespace Gudhi { @@ -49,7 +50,7 @@ class Tangential_complex_interface { unsigned intrisic_dim = 0; if (points.size() > 0) intrisic_dim = points[0].size() - 1; - + tangential_complex_ = new TC(points, intrisic_dim, k); tangential_complex_->compute_tangential_complex(); num_inconsistencies_ = tangential_complex_->number_of_inconsistent_simplices(); @@ -117,7 +118,6 @@ class Tangential_complex_interface { } // namespace tangential_complex -} // namespace Gudhi - -#endif // TANGENTIAL_COMPLEX_INTERFACE_H +} // namespace Gudhi +#endif // INCLUDE_TANGENTIAL_COMPLEX_INTERFACE_H_ diff --git a/src/cython/include/Witness_complex_interface.h b/src/cython/include/Witness_complex_interface.h index 4f2a903b..6501cc35 100644 --- a/src/cython/include/Witness_complex_interface.h +++ b/src/cython/include/Witness_complex_interface.h @@ -20,8 +20,8 @@ * along with this program. If not, see . */ -#ifndef WITNESS_COMPLEX_INTERFACE_H -#define WITNESS_COMPLEX_INTERFACE_H +#ifndef INCLUDE_WITNESS_COMPLEX_INTERFACE_H_ +#define INCLUDE_WITNESS_COMPLEX_INTERFACE_H_ #include #include @@ -64,12 +64,11 @@ class Witness_complex_interface { private: Witness_complex* witness_complex_; - }; } // namespace witness_complex -} // namespace Gudhi +} // namespace Gudhi -#endif // WITNESS_COMPLEX_INTERFACE_H +#endif // INCLUDE_WITNESS_COMPLEX_INTERFACE_H_ -- cgit v1.2.3