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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
|
/* 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
*
* Modification(s):
* - YYYY/MM Author: Description of the modification
*/
#define BOOST_TEST_DYN_LINK
#define BOOST_TEST_MODULE "Persistence_heat_maps_test"
#include <boost/test/unit_test.hpp>
#include <gudhi/reader_utils.h>
#include <gudhi/Persistence_heat_maps.h>
#include <gudhi/Unitary_tests_utils.h>
#include <iostream>
using namespace Gudhi;
using namespace Gudhi::Persistence_representations;
double epsilon = 0.0005;
BOOST_AUTO_TEST_CASE(check_construction_of_heat_maps) {
std::vector<std::vector<double> > filter = create_Gaussian_filter(100, 1);
Persistence_heat_maps<constant_scaling_function> p("data/file_with_diagram", filter, false, 1000, 0, 1);
p.print_to_file("data/persistence_heat_map_from_file_with_diagram");
Persistence_heat_maps<constant_scaling_function> q;
q.load_from_file("data/persistence_heat_map_from_file_with_diagram");
BOOST_CHECK(p == q);
}
BOOST_AUTO_TEST_CASE(check_averages_of_heat_maps) {
std::vector<std::vector<double> > filter = create_Gaussian_filter(30, 1);
Persistence_heat_maps<constant_scaling_function> p("data/file_with_diagram", filter, false, 1000, 0, 10);
Persistence_heat_maps<constant_scaling_function> q("data/file_with_diagram_1", filter, false, 1000, 0, 10);
Persistence_heat_maps<constant_scaling_function> r("data/file_with_diagram_2", filter, false, 1000, 0, 10);
Persistence_heat_maps<constant_scaling_function> av;
av.compute_average({&p, &q, &r});
Persistence_heat_maps<constant_scaling_function> template_average;
template_average.load_from_file("data/template_average_of_heat_maps");
BOOST_CHECK(av == template_average);
}
BOOST_AUTO_TEST_CASE(check_median_of_heat_maps) {
std::vector<std::vector<double> > filter = create_Gaussian_filter(30, 1);
Persistence_heat_maps<constant_scaling_function> p("data/file_with_diagram", filter, false, 1000, 0, 1);
Persistence_heat_maps<constant_scaling_function> q("data/file_with_diagram_1", filter, false, 1000, 0, 1);
Persistence_heat_maps<constant_scaling_function> r("data/file_with_diagram_2", filter, false, 1000, 0, 1);
std::vector<Persistence_heat_maps<constant_scaling_function>*> to_compute_median;
to_compute_median.push_back(&p);
to_compute_median.push_back(&q);
to_compute_median.push_back(&r);
Persistence_heat_maps<constant_scaling_function> median;
median.compute_median(to_compute_median);
Persistence_heat_maps<constant_scaling_function> template_median;
template_median.load_from_file("data/template_median_of_heat_maps");
BOOST_CHECK(median == template_median);
}
BOOST_AUTO_TEST_CASE(check_compute_percentage_of_active_of_heat_maps) {
std::vector<std::vector<double> > filter = create_Gaussian_filter(30, 1);
Persistence_heat_maps<constant_scaling_function> p("data/file_with_diagram", filter, false, 1000, 0, 1);
Persistence_heat_maps<constant_scaling_function> q("data/file_with_diagram_1", filter, false, 1000, 0, 1);
Persistence_heat_maps<constant_scaling_function> r("data/file_with_diagram_2", filter, false, 1000, 0, 1);
std::vector<Persistence_heat_maps<constant_scaling_function>*> to_compute_percentage_of_active;
to_compute_percentage_of_active.push_back(&p);
to_compute_percentage_of_active.push_back(&q);
to_compute_percentage_of_active.push_back(&r);
Persistence_heat_maps<constant_scaling_function> percentage_of_active;
percentage_of_active.compute_percentage_of_active(to_compute_percentage_of_active, 0.1);
Persistence_heat_maps<constant_scaling_function> template_percentage_of_active;
template_percentage_of_active.load_from_file("data/template_percentage_of_active_of_heat_maps");
BOOST_CHECK(percentage_of_active == template_percentage_of_active);
}
BOOST_AUTO_TEST_CASE(check_vectorize_for_heat_maps) {
std::vector<std::vector<double> > filter = create_Gaussian_filter(30, 1);
Persistence_heat_maps<constant_scaling_function> p("data/file_with_diagram", filter, false, 5, 0, 1);
std::vector<double> p_vect_template;
p_vect_template.push_back(0.0606728);
p_vect_template.push_back(0.0610023);
p_vect_template.push_back(0.0607978);
p_vect_template.push_back(0.0600647);
p_vect_template.push_back(0.0588224);
p_vect_template.push_back(0.0619829);
p_vect_template.push_back(0.0623218);
p_vect_template.push_back(0.0621152);
p_vect_template.push_back(0.0613686);
p_vect_template.push_back(0.0601016);
p_vect_template.push_back(0.0627679);
p_vect_template.push_back(0.0631134);
p_vect_template.push_back(0.0629066);
p_vect_template.push_back(0.0621528);
p_vect_template.push_back(0.0608719);
p_vect_template.push_back(0.0630073);
p_vect_template.push_back(0.0633564);
p_vect_template.push_back(0.0631511);
p_vect_template.push_back(0.0623968);
p_vect_template.push_back(0.0611132);
p_vect_template.push_back(0.0626947);
p_vect_template.push_back(0.0630445);
p_vect_template.push_back(0.0628425);
p_vect_template.push_back(0.0620941);
p_vect_template.push_back(0.060819);
std::vector<double> p_vect = p.vectorize(0);
for (size_t i = 0; i != p_vect.size(); ++i) {
BOOST_CHECK(almost_equal(p_vect_template[i], p_vect[i]));
}
}
BOOST_AUTO_TEST_CASE(check_distance_for_heat_maps) {
std::vector<std::vector<double> > filter = create_Gaussian_filter(30, 1);
Persistence_heat_maps<constant_scaling_function> p("data/file_with_diagram", filter, false, 1000, 0, 1);
Persistence_heat_maps<constant_scaling_function> q("data/file_with_diagram_1", filter, false, 1000, 0, 1);
Persistence_heat_maps<constant_scaling_function> r("data/file_with_diagram_2", filter, false, 1000, 0, 1);
GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.distance(p), 0., epsilon);
GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.distance(q), 624.183, epsilon);
GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.distance(r), 415.815, epsilon);
GUDHI_TEST_FLOAT_EQUALITY_CHECK(q.distance(p), 624.183, epsilon);
GUDHI_TEST_FLOAT_EQUALITY_CHECK(q.distance(q), 0., epsilon);
GUDHI_TEST_FLOAT_EQUALITY_CHECK(q.distance(r), 528.066, epsilon);
GUDHI_TEST_FLOAT_EQUALITY_CHECK(r.distance(p), 415.815, epsilon);
GUDHI_TEST_FLOAT_EQUALITY_CHECK(r.distance(q), 528.066, epsilon);
GUDHI_TEST_FLOAT_EQUALITY_CHECK(r.distance(r), 0., epsilon);
}
BOOST_AUTO_TEST_CASE(check_projections_to_R_for_heat_maps) {
std::vector<std::vector<double> > filter = create_Gaussian_filter(30, 1);
Persistence_heat_maps<constant_scaling_function> p("data/file_with_diagram", filter, false, 1000, 0, 1);
Persistence_heat_maps<constant_scaling_function> q("data/file_with_diagram_1", filter, false, 1000, 0, 1);
Persistence_heat_maps<constant_scaling_function> r("data/file_with_diagram_2", filter, false, 1000, 0, 1);
GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.project_to_R(0), 44.3308, epsilon);
GUDHI_TEST_FLOAT_EQUALITY_CHECK(q.project_to_R(0), 650.568, epsilon);
GUDHI_TEST_FLOAT_EQUALITY_CHECK(r.project_to_R(0), 429.287, epsilon);
}
BOOST_AUTO_TEST_CASE(check_scalar_products_for_heat_maps) {
std::vector<std::vector<double> > filter = create_Gaussian_filter(30, 1);
Persistence_heat_maps<constant_scaling_function> p("data/file_with_diagram", filter, false, 1000, 0, 1);
Persistence_heat_maps<constant_scaling_function> q("data/file_with_diagram_1", filter, false, 1000, 0, 1);
Persistence_heat_maps<constant_scaling_function> r("data/file_with_diagram_2", filter, false, 1000, 0, 1);
GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_scalar_product(p), 0.0345687, epsilon);
GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_scalar_product(q), 0.0509357, epsilon);
GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_scalar_product(r), 0.0375608, epsilon);
GUDHI_TEST_FLOAT_EQUALITY_CHECK(q.compute_scalar_product(p), 0.0509357, epsilon);
GUDHI_TEST_FLOAT_EQUALITY_CHECK(q.compute_scalar_product(q), 1.31293, epsilon);
GUDHI_TEST_FLOAT_EQUALITY_CHECK(q.compute_scalar_product(r), 0.536799, epsilon);
GUDHI_TEST_FLOAT_EQUALITY_CHECK(r.compute_scalar_product(p), 0.0375608, epsilon);
GUDHI_TEST_FLOAT_EQUALITY_CHECK(r.compute_scalar_product(q), 0.536799, epsilon);
GUDHI_TEST_FLOAT_EQUALITY_CHECK(r.compute_scalar_product(r), 0.672907, epsilon);
}
BOOST_AUTO_TEST_CASE(check_arythmetic_operations_for_heat_maps) {
std::vector<std::vector<double> > filter = create_Gaussian_filter(30, 1);
Persistence_heat_maps<constant_scaling_function> p("data/file_with_diagram", filter, false, 1000, 0, 1);
Persistence_heat_maps<constant_scaling_function> q("data/file_with_diagram_1", filter, false, 1000, 0, 1);
Persistence_heat_maps<constant_scaling_function> sum = p + q;
Persistence_heat_maps<constant_scaling_function> difference = p - q;
Persistence_heat_maps<constant_scaling_function> multiply_by_scalar = 2 * p;
// sum.print_to_file( "sum" );
// difference.print_to_file( "difference" );
// multiply_by_scalar.print_to_file( "multiply_by_scalar" );
Persistence_heat_maps<constant_scaling_function> sum_template;
sum_template.load_from_file("data/heat_map_sum");
Persistence_heat_maps<constant_scaling_function> difference_template;
difference_template.load_from_file("data/heat_map_difference");
Persistence_heat_maps<constant_scaling_function> multiply_by_scalar_template;
multiply_by_scalar_template.load_from_file("data/heat_map_multiply_by_scalar");
BOOST_CHECK(sum == sum_template);
}
BOOST_AUTO_TEST_CASE(check_distance_of_heat_maps_infinite_power_parameters) {
std::vector<std::vector<double> > filter = create_Gaussian_filter(100, 1);
Persistence_heat_maps<constant_scaling_function> p("data/file_with_diagram", filter, false, 1000, 0, 1);
std::vector<std::vector<double> > filter_2 = create_Gaussian_filter(150, 1);
Persistence_heat_maps<constant_scaling_function> q("data/file_with_diagram", filter_2, true, 1000, 0, 1);
double distance_max_double_parameter = p.distance(q, std::numeric_limits<double>::max());
double distance_inf_double_parameter = p.distance(q, std::numeric_limits<double>::infinity());
// std::cerr << "distance_max_double_parameter: " << distance_max_double_parameter << std::endl;
// std::cerr << "distance_inf_double_parameter: " << distance_inf_double_parameter << std::endl;
BOOST_CHECK(distance_max_double_parameter == distance_inf_double_parameter);
}
// Below I am storing the code used to generate tests for that functionality.
/*
std::vector< std::pair< double,double > > intervals;
intervals.push_back( std::make_pair(0.5,0.5) );
std::vector< std::vector<double> > filter = create_Gaussian_filter(5,1);
Persistence_heat_maps p( intervals , filter , constant_function, false , 100 , 0 , 1 );
p.plot( "heat_map_1" );
std::vector< std::pair< double,double > > intervals2;
intervals2.push_back( std::make_pair(7,12) );
Persistence_heat_maps q( intervals2 , filter , constant_function, false , 100 , 0 , 10 );
q.plot( "heat_map_2" );
*/
/*
std::vector< std::pair< double,double > > intervals;
intervals.push_back( std::make_pair(0.5,0.5) );
std::vector< std::vector<double> > filter = create_Gaussian_filter(5,1);
Persistence_heat_maps p( intervals , filter , constant_function, false , 10 , 0 , 1 );
p.write_to_file( "aaa" );
Persistence_heat_maps q;
q.load_from_file( "aaa" );
cerr << ( p == q ) << endl;
*/
/*
std::vector< std::vector<double> > filter = create_Gaussian_filter(30,1);
Persistence_heat_maps p( "file_with_diagram" , filter , constant_function, false , 100 , 0 , 1 );
p.plot( "heat_map_1" );
*/
/*
//test to construct persistence heat map:
std::vector< std::vector<double> > filter = create_Gaussian_filter(100,1);
Persistence_heat_maps p( "file_with_diagram" , filter , constant_function, false , 1000 , 0 , 1 );
p.print_to_file( "persistence_heat_map_from_file_with_diagram" );
Persistence_heat_maps q;
q.load_from_file( "persistence_heat_map_from_file_with_diagram" );
cerr << (p == q) << endl;
*/
/*
//test of computations of a mean:
std::vector< std::pair< double,double > > intervals;
intervals.push_back( std::make_pair(5,5) );
std::vector< std::vector<double> > filter = create_Gaussian_filter(5,1);
Persistence_heat_maps p( intervals , filter , constant_function, false , 100 , 0 , 10 );
p.plot( "heat_map_1" );
std::vector< std::pair< double,double > > intervals2;
intervals2.push_back( std::make_pair(7,7) );
Persistence_heat_maps q( intervals2 , filter , constant_function, false , 100 , 0 , 10 );
q.plot( "heat_map_2" );
Persistence_heat_maps av;
av.compute_average( { &P , &q } );
av.plot( "average" );
*/
/*
std::vector< std::vector<double> > filter = create_Gaussian_filter(30,1);
Persistence_heat_maps p( "file_with_diagram" , filter , constant_function, false , 1000 , 0 , 10 );
Persistence_heat_maps q( "file_with_diagram_1" , filter , constant_function, false , 1000 , 0 , 10 );
Persistence_heat_maps r( "file_with_diagram_2" , filter , constant_function, false , 1000 , 0 , 10 );
Persistence_heat_maps av;
av.compute_average( {&p,&q,&r} );
av.print_to_file( "template_average_of_heat_maps" );
*/
/*
std::vector< std::pair< double,double > > intervals;
intervals.push_back( std::make_pair(5,5) );
std::vector< std::vector<double> > filter = create_Gaussian_filter(5,1);
Persistence_heat_maps p( intervals , filter , constant_function, false , 10 , 0 , 10 );
p.plot( "heat_map_1" );
std::vector< std::pair< double,double > > intervals2;
intervals2.push_back( std::make_pair(7,7) );
Persistence_heat_maps q( intervals2 , filter , constant_function, false , 10 , 0 , 10 );
q.plot( "heat_map_2" );
Persistence_heat_maps median;
median.compute_median( {&p,&q} );
median.plot( "median" );
*/
/*
std::vector< std::vector<double> > filter = create_Gaussian_filter(30,1);
Persistence_heat_maps p( "file_with_diagram" , filter , constant_function, false , 1000 , 0 , 1 );
Persistence_heat_maps q( "file_with_diagram_1" , filter , constant_function, false , 1000 , 0 , 1 );
Persistence_heat_maps r( "file_with_diagram_2" , filter , constant_function, false , 1000 , 0 , 1 );
Persistence_heat_maps median;
median.compute_median( {&p,&q,&r} );
median.print_to_file( "template_median_of_heat_maps" );
*/
/*
std::vector< std::vector<double> > filter = create_Gaussian_filter(30,1);
Persistence_heat_maps p( "file_with_diagram" , filter , constant_function, false , 1000 , 0 , 1 );
Persistence_heat_maps q( "file_with_diagram_1" , filter , constant_function, false , 1000 , 0 , 1 );
Persistence_heat_maps r( "file_with_diagram_2" , filter , constant_function, false , 1000 , 0 , 1 );
Persistence_heat_maps percentage_of_active;
percentage_of_active.compute_percentage_of_active( {&p,&q,&r} , 0.1 );
percentage_of_active.print_to_file( "template_percentage_of_active_of_heat_maps" );
//percentage_of_active.plot( "template_percentage_of_active_of_heat_maps" );
*/
|