1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
/* 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) 2016 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/>.
*/
#ifndef PERSISTENCE_HEAT_MAPS_INTERFACE_H_
#define PERSISTENCE_HEAT_MAPS_INTERFACE_H_
// gudhi include
#include <gudhi/read_persistence_from_file.h>
#include <gudhi/common_persistence_representations.h>
// standard include
#include <vector>
#include <sstream>
#include <iostream>
#include <cmath>
#include <limits>
#include <algorithm>
#include <utility>
#include <string>
#include <functional>
namespace Gudhi {
namespace Persistence_representations {
class Persistence_heat_maps_interface : public Persistence_heat_maps {
public:
Persistence_heat_maps_interface():Persistence_heat_maps(){}
Persistence_heat_maps_interface(const std::vector<std::pair<double, double> >& interval,
std::vector<std::vector<double> > filter = create_Gaussian_filter(5, 1),
bool erase_below_diagonal = false, size_t number_of_pixels = 1000,
double min_ = std::numeric_limits<double>::max(),
double max_ = std::numeric_limits<double>::max()):
Persistence_heat_maps(interval,filter,erase_below_diagonal,number_of_pixels,min_max_){}
Persistence_heat_maps_interface(const char* filename, std::vector<std::vector<double> > filter = create_Gaussian_filter(5, 1),
bool erase_below_diagonal = false, size_t number_of_pixels = 1000,
double min_ = std::numeric_limits<double>::max(),
double max_ = std::numeric_limits<double>::max(),
unsigned dimension = std::numeric_limits<unsigned>::max()):
Persistence_heat_maps(filename,filter,erase_below_diagonal,number_of_pixels,min_,max_,dimension){}
void compute_mean_interface(const std::vector<Persistence_heat_maps*>& maps)
{
this->compute_mean(maps);
}
void compute_median_interface(const std::vector<Persistence_heat_maps*>& maps)
{
this->compute_median(maps);
}
void compute_percentage_of_active_interface(const std::vector<Persistence_heat_maps*>& maps, size_t cutoff = 1)
{
this->compute_percentage_of_active(maps,cutoff);
}
void print_to_file_interface(const char* filename) const
{
this->print_to_file(filename);
}
void load_from_file_interface(const char* filename)
{
this->load_from_file( filename );
}
inline bool check_if_the_same_interface(const Persistence_heat_maps& second) const
{
return this->check_if_the_same( second );
}
inline double get_min_interface() const
{
return this->get_min();
}
inline double get_max_interface() const
{
return this->get_max();
}
std::vector<double> vectorize_interface(int number_of_function) const
{
return this->vectorize(number_of_function);
}
size_t number_of_vectorize_functions_interface() const
{
return this->number_of_vectorize_functions();
}
double project_to_R_interface(int number_of_function) const
{
return this->project_to_R( number_of_function );
}
size_t number_of_projections_to_R_interface() const
{
return this->number_of_projections_to_R();
}
double distance_interface(const Persistence_heat_maps& second_, double power = 1) const
{
return this->distance( second, power );
}
void compute_average_interface(const std::vector<Persistence_heat_maps*>& to_average)
{
this->compute_average( to_average );
}
double compute_scalar_product_interface(const Persistence_heat_maps& second_) const
{
return this->compute_scalar_product( second_ );
}
std::pair<double, double> get_x_range_interface() const
{
return this->get_x_range();
}
std::pair<double, double> get_y_range_interface() const
{
return this->get_y_range();
}
};
} // namespace Persistence_representations
} // namespace Gudhi
#endif // PERSISTENCE_HEAT_MAPS_INTERFACE_H_
|
