diff options
Diffstat (limited to 'src/Persistence_representations/utilities/persistence_heat_maps')
11 files changed, 797 insertions, 0 deletions
diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/CMakeLists.txt b/src/Persistence_representations/utilities/persistence_heat_maps/CMakeLists.txt new file mode 100644 index 00000000..c90c637d --- /dev/null +++ b/src/Persistence_representations/utilities/persistence_heat_maps/CMakeLists.txt @@ -0,0 +1,42 @@ +cmake_minimum_required(VERSION 2.6) +project(GUDHI_STAT) + +#persitence heat maps + +add_executable ( create_persistence_heat_maps create_persistence_heat_maps.cpp ) +target_link_libraries(create_persistence_heat_maps ${Boost_SYSTEM_LIBRARY}) +#add_test ( create_persistence_heat_maps ${CMAKE_CURRENT_BINARY_DIR}/create_persistence_heat_maps 10 -1 -1 4 -1 simple_diagram.txt ) +add_test ( create_persistence_heat_maps ${CMAKE_CURRENT_BINARY_DIR}/create_persistence_heat_maps 10 -1 -1 4 -1 "${CMAKE_SOURCE_DIR}/data/persistence_diagram/simple_diagram.txt" ) + +add_executable ( create_pssk create_pssk.cpp ) +target_link_libraries(create_pssk ${Boost_SYSTEM_LIBRARY}) +add_test ( create_pssk ${CMAKE_CURRENT_BINARY_DIR}/create_pssk 10 -1 -1 4 -1 "${CMAKE_SOURCE_DIR}/data/persistence_diagram/simple_diagram.txt" ) + +add_executable ( create_p_h_m_weighted_by_distance_from_diagonal create_p_h_m_weighted_by_distance_from_diagonal.cpp ) +target_link_libraries(create_p_h_m_weighted_by_distance_from_diagonal ${Boost_SYSTEM_LIBRARY}) +add_test ( create_p_h_m_weighted_by_distance_from_diagonal ${CMAKE_CURRENT_BINARY_DIR}/create_p_h_m_weighted_by_distance_from_diagonal 10 -1 -1 4 -1 "${CMAKE_SOURCE_DIR}/data/persistence_diagram/simple_diagram.txt" ) + +add_executable ( create_p_h_m_weighted_by_squared_diag_distance create_p_h_m_weighted_by_squared_diag_distance.cpp ) +target_link_libraries(create_p_h_m_weighted_by_squared_diag_distance ${Boost_SYSTEM_LIBRARY}) +add_test (create_p_h_m_weighted_by_squared_diag_distance ${CMAKE_CURRENT_BINARY_DIR}/create_p_h_m_weighted_by_squared_diag_distance 10 -1 -1 4 -1 "${CMAKE_SOURCE_DIR}/data/persistence_diagram/simple_diagram.txt" ) + +add_executable ( create_p_h_m_weighted_by_arctan_of_their_persistence create_p_h_m_weighted_by_arctan_of_their_persistence.cpp ) +target_link_libraries(create_p_h_m_weighted_by_arctan_of_their_persistence ${Boost_SYSTEM_LIBRARY}) +add_test ( create_p_h_m_weighted_by_arctan_of_their_persistence ${CMAKE_CURRENT_BINARY_DIR}/create_p_h_m_weighted_by_arctan_of_their_persistence 10 -1 -1 4 -1 "${CMAKE_SOURCE_DIR}/data/persistence_diagram/simple_diagram.txt" ) + +add_executable ( average_persistence_heat_maps average_persistence_heat_maps.cpp ) +target_link_libraries(average_persistence_heat_maps ${Boost_SYSTEM_LIBRARY}) +add_test ( average_persistence_heat_maps ${CMAKE_CURRENT_BINARY_DIR}/average_persistence_heat_maps "${CMAKE_SOURCE_DIR}/data/persistence_diagram/simple_diagram.txt" "${CMAKE_SOURCE_DIR}/data/persistence_diagram/simple_diagram.txt" ) + +add_executable ( plot_persistence_heat_map plot_persistence_heat_map.cpp ) +target_link_libraries(plot_persistence_heat_map ${Boost_SYSTEM_LIBRARY}) +add_test ( plot_persistence_heat_map ${CMAKE_CURRENT_BINARY_DIR}/plot_persistence_heat_map "${CMAKE_SOURCE_DIR}/data/persistence_diagram/simple_diagram.txt" ) + +add_executable ( compute_distance_of_persistence_heat_maps compute_distance_of_persistence_heat_maps.cpp ) +target_link_libraries(compute_distance_of_persistence_heat_maps ${Boost_SYSTEM_LIBRARY}) +add_test ( compute_distance_of_persistence_heat_maps ${CMAKE_CURRENT_BINARY_DIR}/compute_distance_of_persistence_heat_maps 1 "${CMAKE_SOURCE_DIR}/data/persistence_diagram/simple_diagram.txt" "${CMAKE_SOURCE_DIR}/data/persistence_diagram/simple_diagram.txt" ) + +add_executable ( compute_scalar_product_of_persistence_heat_maps compute_scalar_product_of_persistence_heat_maps.cpp ) +target_link_libraries(compute_scalar_product_of_persistence_heat_maps ${Boost_SYSTEM_LIBRARY}) +add_test ( compute_scalar_product_of_persistence_heat_maps ${CMAKE_CURRENT_BINARY_DIR}/compute_scalar_product_of_persistence_heat_maps "${CMAKE_SOURCE_DIR}/data/persistence_diagram/simple_diagram.txt" "${CMAKE_SOURCE_DIR}/data/persistence_diagram/simple_diagram.txt" ) + diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/average_persistence_heat_maps.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/average_persistence_heat_maps.cpp new file mode 100644 index 00000000..2d221d27 --- /dev/null +++ b/src/Persistence_representations/utilities/persistence_heat_maps/average_persistence_heat_maps.cpp @@ -0,0 +1,72 @@ +/* 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): Pawel Dlotko + * + * Copyright (C) 2015 INRIA (France) + * + * 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 <http://www.gnu.org/licenses/>. + */ + + + +#include <gudhi/Persistence_heat_maps.h> + + + +using namespace Gudhi; +using namespace Gudhi::Persistence_representations; + +#include <iostream> + + +int main( int argc , char** argv ) +{ + std::cout << "This program computes average persistence landscape of persistence landscapes created based on persistence diagrams provided as an input. Please call this program with the names of files with persistence diagrams \n"; + std::vector< const char* > filenames; + + if ( argc == 1 ) + { + std::cout << "No input files given, the program will now terminate \n"; + return 1; + } + + for ( int i = 1 ; i < argc ; ++i ) + { + filenames.push_back( argv[i] ); + } + + std::cout << "Creating persistence landscapes...\n"; + std::vector< Persistence_heat_maps<constant_scaling_function>* > maps; + for ( size_t i = 0 ; i != filenames.size() ; ++i ) + { + Persistence_heat_maps<constant_scaling_function>* l = new Persistence_heat_maps<constant_scaling_function>; + l->load_from_file( filenames[i] ); + maps.push_back( l ); + } + + Persistence_heat_maps<constant_scaling_function> av; + av.compute_average( maps ); + + av.print_to_file( "average.mps" ); + + for ( size_t i = 0 ; i != filenames.size() ; ++i ) + { + delete maps[i]; + } + + std::cout << "Done \n"; + return 0; +} diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/compute_distance_of_persistence_heat_maps.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/compute_distance_of_persistence_heat_maps.cpp new file mode 100644 index 00000000..d3e6f322 --- /dev/null +++ b/src/Persistence_representations/utilities/persistence_heat_maps/compute_distance_of_persistence_heat_maps.cpp @@ -0,0 +1,111 @@ +/* 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): Pawel Dlotko + * + * Copyright (C) 2015 INRIA (France) + * + * 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 <http://www.gnu.org/licenses/>. + */ + + +#include <gudhi/Persistence_heat_maps.h> + + + +using namespace Gudhi; +using namespace Gudhi::Persistence_representations; + +#include <iostream> +#include <sstream> + + +int main( int argc , char** argv ) +{ + std::cout << "This program compute dsitance of persistence heat maps stored in a file (the file needs to be created beforehand). \n"; + std::cout << "The first parameter of a program is an interger p. The program compute L^p distance of the two heat maps. For L^infty distance choose p = -1. \n"; + std::cout << "The remaining parameters of this programs are names of files with persistence heat maps.\n"; + + if ( argc < 3 ) + { + std::cout << "Wrong number of parameters, the program will now terminate \n"; + return 1; + } + + int pp = atoi( argv[1] ); + double p = std::numeric_limits<double>::max(); + if ( pp != -1 ) + { + p = pp; + } + + + std::vector< const char* > filenames; + for ( int i = 2 ; i < argc ; ++i ) + { + filenames.push_back( argv[i] ); + } + std::vector< Persistence_heat_maps<constant_scaling_function> > maps; + maps.reserve( filenames.size() ); + for ( size_t file_no = 0 ; file_no != filenames.size() ; ++file_no ) + { + Persistence_heat_maps<constant_scaling_function> l; + l.load_from_file( filenames[file_no] ); + maps.push_back( l ); + } + + //and now we will compute the scalar product of landscapes. + + //first we prepare an array: + std::vector< std::vector< double > > distance( filenames.size() ); + for ( size_t i = 0 ; i != filenames.size() ; ++i ) + { + std::vector< double > v( filenames.size() , 0 ); + distance[i] = v; + } + + //and now we can compute the distnaces: + for ( size_t i = 0 ; i != filenames.size() ; ++i ) + { + for ( size_t j = i ; j != filenames.size() ; ++j ) + { + distance[i][j] = distance[j][i] = maps[i].distance( maps[j] , p ) ; + } + } + + //and now output the result to the screen and a file: + std::ofstream out; + out.open( "distance" ); + for ( size_t i = 0 ; i != distance.size() ; ++i ) + { + for ( size_t j = 0 ; j != distance.size() ; ++j ) + { + std::cout << distance[i][j] << " "; + out << distance[i][j] << " "; + } + std::cout << std::endl; + out << std::endl; + } + out.close(); + + return 0; +} + + + + + + + diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/compute_scalar_product_of_persistence_heat_maps.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/compute_scalar_product_of_persistence_heat_maps.cpp new file mode 100644 index 00000000..edbf16c1 --- /dev/null +++ b/src/Persistence_representations/utilities/persistence_heat_maps/compute_scalar_product_of_persistence_heat_maps.cpp @@ -0,0 +1,89 @@ +/* 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): Pawel Dlotko + * + * Copyright (C) 2015 INRIA (France) + * + * 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 <http://www.gnu.org/licenses/>. + */ + + +#include <gudhi/Persistence_heat_maps.h> + + + +using namespace Gudhi; +using namespace Gudhi::Persistence_representations; + +#include <iostream> +#include <sstream> + + +int main( int argc , char** argv ) +{ + std::cout << "This program compute scalar product of persistence landscapes stored in a file (the file needs to be created beforehand). \n"; + std::cout << "The parameters of this programs are names of files with persistence landscapes.\n"; + + std::vector< const char* > filenames; + for ( int i = 1 ; i < argc ; ++i ) + { + filenames.push_back( argv[i] ); + } + std::vector< Persistence_heat_maps<constant_scaling_function> > maps; + maps.reserve( filenames.size() ); + for ( size_t file_no = 0 ; file_no != filenames.size() ; ++file_no ) + { + Persistence_heat_maps<constant_scaling_function> l; + l.load_from_file( filenames[file_no] ); + maps.push_back( l ); + } + + //and now we will compute the scalar product of landscapes. + + //first we prepare an array: + std::vector< std::vector< double > > scalar_product( filenames.size() ); + for ( size_t i = 0 ; i != filenames.size() ; ++i ) + { + std::vector< double > v( filenames.size() , 0 ); + scalar_product[i] = v; + } + + //and now we can compute the scalar product: + for ( size_t i = 0 ; i != maps.size() ; ++i ) + { + for ( size_t j = i ; j != maps.size() ; ++j ) + { + scalar_product[i][j] = scalar_product[j][i] = maps[i].compute_scalar_product( maps[j] ) ; + } + } + + //and now output the result to the screen and a file: + std::ofstream out; + out.open( "scalar_product" ); + for ( size_t i = 0 ; i != scalar_product.size() ; ++i ) + { + for ( size_t j = 0 ; j != scalar_product.size() ; ++j ) + { + std::cout << scalar_product[i][j] << " "; + out << scalar_product[i][j] << " "; + } + std::cout << std::endl; + out << std::endl; + } + out.close(); + + return 0; +} diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_arctan_of_their_persistence.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_arctan_of_their_persistence.cpp new file mode 100644 index 00000000..aa887c9c --- /dev/null +++ b/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_arctan_of_their_persistence.cpp @@ -0,0 +1,88 @@ + /* 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): Pawel Dlotko + * + * Copyright (C) 2015 INRIA (France) + * + * 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 <http://www.gnu.org/licenses/>. + */ + + + +#include <gudhi/Persistence_heat_maps.h> + + + +using namespace Gudhi; +using namespace Gudhi::Persistence_representations; + +#include <iostream> +#include <sstream> + + + +int main( int argc , char** argv ) +{ + std::cout << "This program creates persistence heat map of diagrams provided as an input. The Gaussian kernels are weighted by the arcus tangens of their persistence.\n"; + std::cout << "The first parameter of a program is an integer, a size of a grid.\n"; + std::cout << "The second and third parameters are min and max of the grid. If you want those numbers to be computed based on the data, set them both to -1 \n"; + std::cerr << "The fourth parameter is an integer, the standard deviation of a gaussian kernel expressed in a number of pixels \n"; + std::cout << "The fifth parameter of this program is a dimension of persistence that will be used in creation of the persistence heat maps."; + std::cout << "If our input files contain persistence pairs of various dimension, as a fifth parameter of the procedure please provide the dimension of persistence you want to use."; + std::cout << "If in your file there are only birth-death pairs of the same dimension, set the first parameter to -1." << std::endl; + std::cout << "The remaining parameters are the names of files with persistence diagrams. \n"; + + if ( argc < 5 ) + { + std::cout << "Wrong parameter list, the program will now terminate \n"; + return 1; + } + + size_t size_of_grid = (size_t)atoi( argv[1] ); + double min_ = atof( argv[2] ); + double max_ = atof( argv[3] ); + size_t stdiv = atof( argv[4] ); + + unsigned dimension = std::numeric_limits<unsigned>::max(); + int dim = atoi( argv[5] ); + if ( dim >= 0 ) + { + dimension = (unsigned)dim; + } + + std::vector< const char* > filenames; + for ( int i = 6 ; i < argc ; ++i ) + { + filenames.push_back( argv[i] ); + } + + + + std::cout << "Creating persistence heat maps...\n"; + std::vector< std::vector<double> > filter = create_Gaussian_filter(stdiv,1); + + for ( size_t i = 0 ; i != filenames.size() ; ++i ) + { + std::cout << "Creating a heat map based on a file : " << filenames[i] << std::endl; + Persistence_heat_maps<arc_tan_of_persistence_of_point> l( filenames[i] , filter, false , size_of_grid , min_ , max_ , dimension ); + + std::stringstream ss; + ss << filenames[i] << ".mps"; + l.print_to_file( ss.str().c_str() ); + } + std::cout << "Done \n"; + return 0; +} diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_distance_from_diagonal.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_distance_from_diagonal.cpp new file mode 100644 index 00000000..aa13d786 --- /dev/null +++ b/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_distance_from_diagonal.cpp @@ -0,0 +1,89 @@ +/* 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): Pawel Dlotko + * + * Copyright (C) 2015 INRIA (France) + * + * 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 <http://www.gnu.org/licenses/>. + */ + + +#include <gudhi/Persistence_heat_maps.h> + + + +using namespace Gudhi; +using namespace Gudhi::Persistence_representations; + +#include <iostream> +#include <sstream> + + + +int main( int argc , char** argv ) +{ + std::cout << "This program creates persistence heat map of diagrams provided as an input. The Gaussian kernels are weighted by the distance of a center from the diagonal.\n"; + std::cout << "The first parameter of a program is an integer, a size of a grid.\n"; + std::cout << "The second and third parameters are min and max of the grid. If you want those numbers to be computed based on the data, set them both to -1 \n"; + std::cerr << "The fourth parameter is an integer, the standard deviation of a gaussian kernel expressed in a number of pixels \n"; + std::cout << "The fifth parameter of this program is a dimension of persistence that will be used in creation of the persistence heat maps."; + std::cout << "If our input files contain persistence pairs of various dimension, as a fifth parameter of the procedure please provide the dimension of persistence you want to use."; + std::cout << "If in your file there are only birth-death pairs of the same dimension, set the first parameter to -1." << std::endl; + std::cout << "The remaining parameters are the names of files with persistence diagrams. \n"; + + if ( argc < 5 ) + { + std::cout << "Wrong parameter list, the program will now terminate \n"; + return 1; + } + + size_t size_of_grid = (size_t)atoi( argv[1] ); + double min_ = atof( argv[2] ); + double max_ = atof( argv[3] ); + size_t stdiv = atof( argv[4] ); + + unsigned dimension = std::numeric_limits<unsigned>::max(); + int dim = atoi( argv[5] ); + if ( dim >= 0 ) + { + dimension = (unsigned)dim; + } + + //std::cout << "Parameters of the program : size_of_grid : " << size_of_grid << ", min_ : " << min_ << ", max_ : " << max_ << ", stdiv: " << stdiv << ", dim : " << dim << std::endl; + + std::vector< const char* > filenames; + for ( int i = 6 ; i != argc ; ++i ) + { + filenames.push_back( argv[i] ); + } + + + + std::cout << "Creating persistence heat maps...\n"; + std::vector< std::vector<double> > filter = create_Gaussian_filter(stdiv,1); + + for ( size_t i = 0 ; i != filenames.size() ; ++i ) + { + std::cout << "Creating a heat map based on a file : " << filenames[i] << std::endl; + Persistence_heat_maps<distance_from_diagonal_scaling> l( filenames[i] , filter , false , size_of_grid , min_ , max_ , dimension ); + + std::stringstream ss; + ss << filenames[i] << ".mps"; + l.print_to_file( ss.str().c_str() ); + } + std::cout << "Done \n"; + return 0; +} diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_squared_diag_distance.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_squared_diag_distance.cpp new file mode 100644 index 00000000..46258329 --- /dev/null +++ b/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_squared_diag_distance.cpp @@ -0,0 +1,85 @@ +/* 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): Pawel Dlotko + * + * Copyright (C) 2015 INRIA (France) + * + * 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 <http://www.gnu.org/licenses/>. + */ + + +#include <gudhi/Persistence_heat_maps.h> + + + +using namespace Gudhi; +using namespace Gudhi::Persistence_representations; + +#include <iostream> +#include <sstream> + + + +int main( int argc , char** argv ) +{ + std::cout << "This program creates persistence heat map of diagrams provided as an input. The Gaussian kernels are weighted by the square of distance of a center from the diagonal.\n"; + std::cout << "The first parameter of a program is an integer, a size of a grid.\n"; + std::cout << "The second and third parameters are min and max of the grid. If you want those numbers to be computed based on the data, set them both to -1 \n"; + std::cerr << "The fourth parameter is an integer, the standard deviation of a gaussian kernel expressed in a number of pixels \n"; + std::cout << "The fifth parameter of this program is a dimension of persistence that will be used in creation of the persistence heat maps."; + std::cout << "If our input files contain persistence pairs of various dimension, as a fifth parameter of the procedure please provide the dimension of persistence you want to use."; + std::cout << "If in your file there are only birth-death pairs of the same dimension, set the first parameter to -1." << std::endl; + std::cout << "The remaining parameters are the names of files with persistence diagrams. \n"; + + if ( argc < 5 ) + { + std::cout << "Wrong parameter list, the program will now terminate \n"; + return 1; + } + + size_t size_of_grid = (size_t)atoi( argv[1] ); + double min_ = atof( argv[2] ); + double max_ = atof( argv[3] ); + size_t stdiv = atof( argv[4] ); + + unsigned dimension = std::numeric_limits<unsigned>::max(); + int dim = atoi( argv[5] ); + if ( dim >= 0 ) + { + dimension = (unsigned)dim; + } + + std::vector< const char* > filenames; + for ( int i = 6 ; i < argc ; ++i ) + { + filenames.push_back( argv[i] ); + } + + std::cout << "Creating persistence heat maps...\n"; + std::vector< std::vector<double> > filter = create_Gaussian_filter(stdiv,1); + + for ( size_t i = 0 ; i != filenames.size() ; ++i ) + { + std::cout << "Creating a heat map based on a file : " << filenames[i] << std::endl; + Persistence_heat_maps<squared_distance_from_diagonal_scaling> l( filenames[i] , filter, false , size_of_grid , min_ , max_ , dimension ); + + std::stringstream ss; + ss << filenames[i] << ".mps"; + l.print_to_file( ss.str().c_str() ); + } + std::cout << "Done \n"; + return 0; +} diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/create_persistence_heat_maps.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/create_persistence_heat_maps.cpp new file mode 100644 index 00000000..cac81495 --- /dev/null +++ b/src/Persistence_representations/utilities/persistence_heat_maps/create_persistence_heat_maps.cpp @@ -0,0 +1,84 @@ +/* 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): Pawel Dlotko + * + * Copyright (C) 2015 INRIA (France) + * + * 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 <http://www.gnu.org/licenses/>. + */ + + + +#include <gudhi/Persistence_heat_maps.h> + + + +using namespace Gudhi; +using namespace Gudhi::Persistence_representations; + +#include <iostream> +#include <sstream> + + + +int main( int argc , char** argv ) +{ + std::cout << "This program creates persistence heat map of diagrams provided as an input.\n"; + std::cout << "The first parameter of a program is an integer, a size of a grid.\n"; + std::cout << "The second and third parameters are min and max of the grid. If you want those numbers to be computed based on the data, set them both to -1 \n"; + std::cerr << "The fourth parameter is an integer, the standard deviation of a gaussian kernel expressed in a number of pixels \n"; + + std::cout << "The fifth parameter of this program is a dimension of persistence that will be used in creation of the persistence heat maps."; + std::cout << "If our input files contain persistence pairs of various dimension, as a fifth parameter of the procedure please provide the dimension of persistence you want to use."; + std::cout << "If in your file there are only birth-death pairs of the same dimension, set the first parameter to -1." << std::endl; + std::cout << "The remaining parameters are the names of files with persistence diagrams. \n"; + if ( argc < 5 ) + { + std::cout << "Wrong parameter list, the program will now terminate \n"; + return 1; + } + size_t size_of_grid = (size_t)atoi( argv[1] ); + double min_ = atof( argv[2] ); + double max_ = atof( argv[3] ); + size_t stdiv = atof( argv[4] ); + + unsigned dimension = std::numeric_limits<unsigned>::max(); + int dim = atoi( argv[5] ); + if ( dim >= 0 ) + { + dimension = (unsigned)dim; + } + std::vector< const char* > filenames; + for ( int i = 6 ; i < argc ; ++i ) + { + filenames.push_back( argv[i] ); + } + + std::cout << "Creating persistence heat maps...\n"; + std::vector< std::vector<double> > filter = create_Gaussian_filter(stdiv,1); + + for ( size_t i = 0 ; i != filenames.size() ; ++i ) + { + std::cout << "Creating a heat map based on a file : " << filenames[i] << std::endl; + Persistence_heat_maps<constant_scaling_function> l( filenames[i] , filter, false , size_of_grid , min_ , max_ , dimension ); + + std::stringstream ss; + ss << filenames[i] << ".mps"; + l.print_to_file( ss.str().c_str() ); + } + std::cout << "Done \n"; + return 0; +} diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/create_pssk.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/create_pssk.cpp new file mode 100644 index 00000000..6aab42f7 --- /dev/null +++ b/src/Persistence_representations/utilities/persistence_heat_maps/create_pssk.cpp @@ -0,0 +1,84 @@ +/* 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): Pawel Dlotko + * + * Copyright (C) 2015 INRIA (France) + * + * 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 <http://www.gnu.org/licenses/>. + */ + +#include <gudhi/PSSK.h> + + + +using namespace Gudhi; +using namespace Gudhi::Persistence_representations; + +#include <iostream> +#include <sstream> + + + +int main( int argc , char** argv ) +{ + std::cout << "This program creates PSSK of diagrams provided as an input.\n"; + std::cout << "The first parameter of a program is an integer, a size of a grid.\n"; + std::cout << "The second and third parameters are min and max of the grid. If you want those numbers to be computed based on the data, set them both to -1 \n"; + std::cerr << "The fourth parameter is an integer, the standard deviation of a gaussian kernel expressed in a number of pixels \n"; + std::cout << "The fifth parameter of this program is a dimension of persistence that will be used in creation of the persistence heat maps."; + std::cout << "If our input files contain persistence pairs of various dimension, as a fifth parameter of the procedure please provide the dimension of persistence you want to use."; + std::cout << "If in your file there are only birth-death pairs of the same dimension, set the first parameter to -1." << std::endl; + std::cout << "The remaining parameters are the names of files with persistence diagrams. \n"; + + if ( argc < 5 ) + { + std::cout << "Wrong parameter list, the program will now terminate \n"; + return 1; + } + + size_t size_of_grid = (size_t)atoi( argv[1] ); + double min_ = atof( argv[2] ); + double max_ = atof( argv[3] ); + size_t stdiv = atof( argv[4] ); + + unsigned dimension = std::numeric_limits<unsigned>::max(); + int dim = atoi( argv[5] ); + if ( dim >= 0 ) + { + dimension = (unsigned)dim; + } + + std::vector< const char* > filenames; + for ( int i = 6 ; i < argc ; ++i ) + { + filenames.push_back( argv[i] ); + } + + std::cout << "Creating persistence heat maps...\n"; + std::vector< std::vector<double> > filter = create_Gaussian_filter(stdiv,1); + + for ( size_t i = 0 ; i != filenames.size() ; ++i ) + { + std::cout << "Creating a heat map based on a file : " << filenames[i] << std::endl; + PSSK l( filenames[i] , filter , size_of_grid , min_ , max_ , dimension ); + + std::stringstream ss; + ss << filenames[i] << ".pssk"; + l.print_to_file( ss.str().c_str() ); + } + std::cout << "Done \n"; + return 0; +} diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/plot_persistence_heat_map.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/plot_persistence_heat_map.cpp new file mode 100644 index 00000000..5a4776ff --- /dev/null +++ b/src/Persistence_representations/utilities/persistence_heat_maps/plot_persistence_heat_map.cpp @@ -0,0 +1,42 @@ +/* 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): Pawel Dlotko + * + * Copyright (C) 2015 INRIA (France) + * + * 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 <http://www.gnu.org/licenses/>. + */ + + +#include <gudhi/Persistence_heat_maps.h> + + + +using namespace Gudhi; +using namespace Gudhi::Persistence_representations; + +#include <iostream> +#include <sstream> + + +int main( int argc , char** argv ) +{ + std::cout << "This program plot persistence landscape stored in a file (the file needs to be created beforehand). Please call the code with the name of a landsape file \n"; + Persistence_heat_maps<constant_scaling_function> l; + l.load_from_file( argv[1] ); + l.plot( argv[1] ); + return 0; +} diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/simple_diagram.txt.mps b/src/Persistence_representations/utilities/persistence_heat_maps/simple_diagram.txt.mps new file mode 100644 index 00000000..b7643887 --- /dev/null +++ b/src/Persistence_representations/utilities/persistence_heat_maps/simple_diagram.txt.mps @@ -0,0 +1,11 @@ +0.93 8.0707 +0.0492104 0.03889 0.0190956 0.00603584 0.00131569 0.000120934 2.10152e-05 0 0 0 +0.0650745 0.0539306 0.0296488 0.011745 0.00357642 0.000695928 0.000120934 0 0 0 +0.0572665 0.0559446 0.0409942 0.0230905 0.00937173 0.00242903 0.000422102 0 0 0 +0.0409942 0.0559656 0.0573874 0.0408475 0.0192639 0.00628964 0.00178718 0.000422102 0.000120934 2.10152e-05 +0.0296488 0.0540515 0.0657704 0.0519133 0.0283092 0.0132056 0.00628964 0.00242903 0.000695928 0.000120934 +0.0190956 0.0393121 0.0516395 0.0465955 0.0359385 0.0283092 0.0192639 0.00937173 0.00357642 0.00131569 +0.00847814 0.0188418 0.0281882 0.0358964 0.0465955 0.0519133 0.0408475 0.0230905 0.011745 0.00603584 +0.00242903 0.00628964 0.0132056 0.0281882 0.0516395 0.0657704 0.0573874 0.0409942 0.0296488 0.0190956 +0.000422102 0.00178718 0.00628964 0.0188418 0.0393121 0.0540515 0.0559656 0.0559446 0.0539306 0.03889 +0 0.000422102 0.00242903 0.00847814 0.0190956 0.0296488 0.0409942 0.0572665 0.0650745 0.0492104 |