forked from topology-tool-kit/topology-tool-kit.github.io
-
Notifications
You must be signed in to change notification settings - Fork 0
/
bettiNumbers.html
592 lines (500 loc) · 24.1 KB
/
bettiNumbers.html
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
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta name="description" content="The Topology ToolKit">
<meta name="author" content="The Topology ToolKit">
<meta name="keywords" content="TTK, Topology ToolKit, Topological Data
Analysis, Visualization, Reeb graph, Reeb Space, Morse-Smale complex, contour
tree, persistence diagram, persistence curve, continuous scatterplot, fiber
surface, contour forests, jacobi set, mandatory critical points, topological
simplification, VTK, ParaView, Python" />
<title>TTK - the Topology ToolKit - Topological Data Analysis and
Visualization</title>
<!-- Bootstrap Core CSS -->
<link href="vendor/bootstrap/css/bootstrap.min.css" rel="stylesheet">
<!-- Theme CSS -->
<link href="css/clean-blog.min.css" rel="stylesheet">
<!-- Custom Fonts -->
<link href="vendor/font-awesome/css/font-awesome.min.css" rel="stylesheet" type="text/css">
<link href='https://fonts.googleapis.com/css?family=Lora:400,700,400italic,700italic' rel='stylesheet' type='text/css'>
<link href='https://fonts.googleapis.com/css?family=Open+Sans:300italic,400italic,600italic,700italic,800italic,400,300,600,700,800' rel='stylesheet' type='text/css'>
<!-- HTML5 Shim and Respond.js IE8 support of HTML5 elements and media queries -->
<!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
<!--[if lt IE 9]>
<script src="https://oss.maxcdn.com/libs/html5shiv/3.7.0/html5shiv.js"></script>
<script src="https://oss.maxcdn.com/libs/respond.js/1.4.2/respond.min.js"></script>
<![endif]-->
<!-- Google Analytics -->
<script>
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','https://www.google-analytics.com/analytics.js','ga'
);
ga('create', 'UA-88087813-1', 'auto');
ga('send', 'pageview');
</script>
<script type="text/javascript">
var _gaq = _gaq || [];
var pluginUrl =
'//www.google-analytics.com/plugins/ga/inpage_linkid.js';
_gaq.push(['_require', 'inpage_linkid', pluginUrl]);
_gaq.push(['_setAccount', 'UA-88087813-1']);
_gaq.push(['_trackPageview']);
(function() {
var ga = document.createElement('script'); ga.type =
'text/javascript'; ga.async = true;
ga.src = ('https:' == document.location.protocol ? 'https://ssl'
: 'http://www') + '.google-analytics.com/ga.js';
var s = document.getElementsByTagName('script')[0];
s.parentNode.insertBefore(ga, s);
})();
</script>
<!-- End Google Analytics -->
</head>
<body>
<!-- Navigation -->
<nav class="navbar navbar-default navbar-custom navbar-fixed-top">
<div class="container-fluid">
<!-- Brand and toggle get grouped for better mobile display -->
<div class="navbar-header page-scroll">
<button type="button" class="navbar-toggle"
data-toggle="collapse" data-target="#bs-example-navbar-collapse-1">
<span class="sr-only">Toggle navigation</span>
Menu <i class="fa fa-bars"></i>
</button>
<a class="navbar-brand" href="index.html">
TTK Home</a>
</div>
<!-- Collect the nav links, forms, and other content for toggling
-->
<div class="collapse navbar-collapse"
id="bs-example-navbar-collapse-1">
<ul class="nav navbar-nav navbar-right">
<li>
<a href="gallery.html">Gallery</a>
</li>
<li>
<a href="downloads.html">Downloads</a>
</li>
<li>
<a href="installation.html">Installation</a>
</li>
<li>
<a href="tutorials.html">Tutorials</a>
</li>
<li>
<a href="documentation.html">Documentation</a>
</li>
<li>
<a href="contribute.html">Contribute</a>
</li>
<li>
<a href="contact.html">Contact</a>
</li>
</ul>
</div>
<!-- /.navbar-collapse -->
</div>
<!-- /.container -->
</nav>
<!-- Page Header -->
<!-- Set your background image for this header on the line below. -->
<header class="intro-header"
style="background-image: url('img/builtinExample.png'">
<div class="container">
<div class="row">
<div class="col-lg-8 col-lg-offset-2 col-md-10 col-md-offset-1">
<div class="page-heading">
<h1>Topology ToolKit</h1>
<hr class="small">
<span class="subheading">Tutorials</span>
</div>
</div>
</div>
</div>
</header>
<!-- Main Content -->
<div class="container">
<div class="row">
<div class="col-lg-8 col-lg-offset-2 col-md-10 col-md-offset-1">
<p>
<h3>Writing a TTK module:<br> An introduction with Betti numbers</h3>
<br>
The purpose of this exercise tutorial is threefold:<br>
· Introduce you to the usage of TTK in
ParaView;<br>
· Introduce you to the development of a TTK
module;<br>
· Make you learn more about
the homology groups of 3-manifolds in R3!<br><br>
This exercise requires some minor background in C++. <br>
It should take no more
than 2 hours of your time.
<br><br>
<p>
<h4><a name="betti_downloads">1.</a> Downloads</h4>
In the following, we will assume that TTK has been installed successfully on
your system. If not, please visit our installation page for detailed
instructions
<a href="installation.html" target="new">
HERE</a>.<br>
Before starting the exercise, please download the data package
<a href="stuff/bettiData.tar.gz" target=new>
HERE</a> as well as the latest TTK source tree
<a href="https://codeload.github.com/topology-tool-kit/ttk/tar.gz/v0.9.2"
target="new">
THERE</a>.<br>
Move the tarballs to a working directory (for instance called
<code>~/ttk</code>) and decompress them by entering the following commands (omit
the <code>$</code> character) in
a terminal (this assumes that you downloaded the tarballs to the
<code>~/Downloads</code> directory):<br><br>
<code>$ mkdir ~/ttk</code><br>
<code>$ mv ~/Downloads/ttk-0.9.2.tar.gz ~/ttk/</code><br>
<code>$ mv ~/Downloads/bettiData.tar.gz ~/ttk/</code><br>
<code>$ cd ~/ttk</code><br>
<code>$ tar xvzf ttk-0.9.2.tar.gz</code><br>
<code>$ tar xvzf bettiData.tar.gz</code><br><br>
You can delete the tarballs after the source trees have been decompressed by
entering the following commands:<br><br>
<code>$ rm ttk-0.9.2.tar.gz</code><br>
<code>$ rm bettiData.tar.gz</code><br><br>
</p>
<p>
<h4><a name="betti_paraview">2.</a> TTK/ParaView 101</h4>
<a href="http://www.paraview.org" target="new">ParaView</a> is the leading
application for the interactive analysis and visualization of scientific data.
It is open-source (BSD license). It is developed by <a
href="http://www.kitware.com" target="new">Kitware</a>, a prominent company in
open-source software (<a href="http://www.cmake.org" target="new">CMake</a>,
<a href="http://www.cdash.org" target="new">CDash</a>,
<a href="http://www.vtk.org" target="new">VTK</a>,
<a href="http://www.itk.org" target="new">ITK</a>, etc.).<br><br>
ParaView is a graphical user interface to the <a href="http://www.vtk.org"
target="new">Visualization ToolKit</a>, a C++ library for data
visualization and analysis, also developed in open-source by Kitware.<br>
<div class=caption>
<a href="img/bettiNumbers_intro.png" target="new">
<img width="100%" src="img/bettiNumbers_intro.png">
</a>
</div>
VTK and ParaView both implement a
pipeline model, where the data to analyze and visualize is passed on the input
of a (possibly complex) sequence of elementary processing units, called
<i>filters</i>. Each filter is implemented by a single C++ class in VTK. In
ParaView, users can design advanced processing pipelines
by placing manually each filter in their
pipelines. <br>
In the above example, the active pipeline (shown in the "Pipeline Browser",
upper left panel) can be interpreted as a series of processing instructions and
reads similarly to some source code:
first, the input PL 3-manifold is clipped (<code>Clip1</code>); second, the
boundary of the input PL 3-manifold is extracted
(<code>ExtractSurface1</code>), third the connected components of the boundary
are isolated and clipped with the same parameters as the rest of the volume
(<code>Clip2</code>).<br><br>
The output of each filter can be visualized independently (by
toggling the eye icon, left column). The algorithmic parameters of each filter
can be tuned in the "Properties" panel (bottom left panel) by selecting a
filter in the pipeline (in the above example
<code>GenerateSurfaceNormals1</code>).
The display properties of the output of a filter in the main central view can
also be modified from this panel.<br>
<div class=caption>
<a href="img/bettiNumbers_menu.png" target="new">
<img width="100%" src="img/bettiNumbers_menu.png">
</a>
</div>
To create a pipeline from scratch, users typically load their input data and
apply successively the required filters, by browsing the filter menu
(exhaustive list shown above), where the filters which are not compatible
with the object currently selected in the pipeline are shaded. <br>
<div class=caption>
<a href="img/bettiNumbers_search.png" target="new">
<img width="100%" src="img/bettiNumbers_search.png">
</a>
</div>
Alternatively to the filter menu, users can toggle a fast search dialog by
pressing the <code>Ctrl+space</code> keystroke (under Linux) and enter keywords
as shown above to quickly call filters.<br><br>
Once users are satisfied with their analysis and visualization pipeline, they
can save it to disk for later re-use in the form of a Python script with the
menu <code>File</code>, <code>Save state...</code> and choosing the Python
state file type. In the Python script, each filter instance is modeled by an
independent Python object, for which attributes can be changed and functions
can be called.<br>
Note that the output Python script can be run independently of ParaView (for
instance in batch mode) and its content can be included in any Python code (the
<code>pvpython</code> interpreter is then recommended). Thus, ParaView can be
viewed as an interactive designer of advanced analysis Python programs.
Then, writing up your own TTK module will not only expose your C++ code to
ParaView, but it will also make it readily available in Python.
To
learn more about the available ParaView filters, please see the following
tutorials:
<a href="http://www-pequan.lip6.fr/~tierny/visualizationExerciseParaView.html"
target="new">
HERE </a>
and
<a href="http://www.paraview.org/Wiki/The_ParaView_Tutorial"
target="new">
THERE</a>.
<br><br>
<h4>Exercise 1</h4>
Open the skull data set in ParaView with the following command (omit
the <code>$</code> character):<br><br>
<code>$ paraview ~/ttk/bettiData/skull.vtu</code>
<br><br>
Next, try to reproduce the visualization shown in the first screenshot above,
which shows a clipped view of the PL 3-manifold, with the visible interior
triangles in white with dark edges, each boundary component displayed with
its edges with a distinct color and the rest of the (unclipped) boundary shown
in transparent.
</p>
<p>
<h4><a name="betti_paraview">3.</a> Betti numbers of PL 3-manifolds</h4>
In the following, you will write your first TTK module, dedicated to the
computation of Betti numbers of PL 3-manifolds. For this, we will exploit the
results by Dey and Guha, published in their 1998 paper
<a
href="http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.41.2252&rep=rep1&
type=pdf"
target="new">
"Computing Homology Groups of Simplicial Complexes in R3"</a>.<br><br>
Go ahead and create your TTK module by entering the following commands (omit
the <code>$</code> character):<br><br>
<code>$ cd ~/ttk/ttk-0.9.2/</code><br>
<code>$ scripts/createTTKmodule.sh BettiNumbers</code><br><br>
The above script will create all the files and classes of your TTK module. This
module includes automatically generated standalone command line and GUI
programs, as well as a ParaView plugin. <br><br>
For this exercise, we will only need to build your TTK module, and not the
entire TTK collection. Thus, edit the file
<code>~/ttk/ttk-0.9.2/CMakeLists.txt</code> to remove all entries, except the
first line and all the lines containing the word <code>BettiNumbers</code>.<br>
Now, to build your TTK module, enter the following commands, where
<code>N</code> is the number of available cores on your system (omit
the <code>$</code> character):<br><br>
<code>$ cd ~/ttk/ttk-0.9.2/</code><br>
<code>$ mkdir build</code><br>
<code>$ cd build</code><br>
<code>$ cmake ../</code><br>
<code>$ make -jN</code><br><br>
Note that, in order to rebuild your module in the future, you'll only need to
enter the last command (<code>make -jN</code>).<br>
<div class=caption>
<a href="img/bettiNumbers_plugin.png" target="new">
<img width="100%" src="img/bettiNumbers_plugin.png">
</a>
</div>
To load your module in ParaView, open
ParaView, go to the menu <code>Tools</code>, <code>Manage Plugins...</code>,
then click on the <code>Load New...</code> button. Next, from the file browser
dialog, select the library we've just built:
<code>~/ttk/ttk-0.9.2/build/paraview/BettiNumbers/libBettiNumbers.so</code>.
Next, you may want to check the checkbox <code>AutoLoad</code> as shown above
(available after expending your plugin entry) to force ParaView to
automatically load your plugin at startup.<br>
At this point, if your plugin was successfully loaded, it should appear as the
entry <code>TTK BettiNumbers</code> under the menu <code>Filters</code> then
<code>TTK - Misc</code>, as shown below.<br>
<div class=caption>
<a href="img/bettiNumbers_pluginMenu.png" target="new">
<img width="100%" src="img/bettiNumbers_pluginMenu.png">
</a>
</div>
Now open the file
<code>~/ttk/ttk-0.9.2/core/baseCode/bettiNumbers/BettiNumbers.h</code>. In the
function <code>execute()</code>, add the line <code>cout << endl <<
"Hello World!" << endl << endl;</code> before the <code>return</code>
statement. Now build your module again, load the skull data set in ParaView and
apply your BettiNumbers plugin. You should see your message "Hello World!"
appear in the terminal, as shown below.<br>
<div class=caption>
<a href="img/bettiNumbers_helloWorld.png" target="new">
<img width="100%" src="img/bettiNumbers_helloWorld.png">
</a>
</div>
If this is the case, congratulations! You've just written your first TTK module!
<br><br>
<h4>Exercise 2: B0 (~20 lines of code)</h4>
The 0-th Betti number (noted <code>B0</code>) corresponds to the number of
connected component of the input manifold <code>M</code>. In the following, we
will compute this number and display it in the output of the terminal (next to
our "Hello World!" message).<br><br>
Several algorithms exist to enumerate connected components in a triangulation,
the simplest being a simple
<a href="https://en.wikipedia.org/wiki/Breadth-first_search" target="new">
breadth-first search</a> traversal. Instead, we will use a <i>Union-Find</i>
data-structure, which will make the implementation even simpler.<br><br>
The
<a href="https://en.wikipedia.org/wiki/Disjoint-set_data_structure"
target="new">
Union-Find</a> (UF) data-structure is a simple, yet powerful data-structure
which tracks the connectivity of a graph over successive edge additions. It is
a fundamental object which plays a key role in many computational topology
algorithms.<br><br>
Initially, a UF object is created for each vertex of the graph. The operation
<code>find()</code> on this object returns its <i>parent</i>, that is
a
unique representative UF object which <i>represents</i> the connected component
of the
queried vertex.<br><br>
When adding an edge between two vertices <code>v0</code> and <code>v1</code>,
the <code>makeUnion()</code> operation is called between the UF objects of
<code>v0</code> and <code>v1</code>. This will have the effect of merging the
representatives of the corresponding connected components.<br><br>
Thus, to enumerate the connected components of a PL manifold <code>M</code>,
one just needs to proceed as follows. First, one should iterate over the edges
of <code>M</code>, call the <code>makeUnion()</code> operation between the UF
objects of the vertices of each edge of <code>M</code>. Finally, one should
iterate over all the UF objects, call the <code>find()</code> operation and
enumerate the number of unique remaining representatives. This number
corresponds to the number of remaining connected components after all edges have
been added (initially, the number of connected components is equal to the
number of vertices in <code>M</code>).<br><br>
TTK provides a reference implementation of the Union-Find data structure (with
path compression and union by rank), which we will use in this exercise. Its
online documentation can be found
<a
href="https://topology-tool-kit.github.io/doc/html/classttk_1_1UnionFind.html"
target="new">
HERE</a>.<br><br>
To use it in your module, edit the file
<code>~/ttk/ttk-0.9.2/core/baseCode/bettiNumbers/bettiNumbers.cmake</code> and
add the line <code>ttk_add_baseCode_package(unionFind)</code> at the
top of the file. Next, in
<code>~/ttk/ttk-0.9.2/core/baseCode/bettiNumbers/BettiNumbers.h</code>, add the
line <code>#include <UnionFind.h></code> in the file preamble.<br><br>
TTK provides an efficient data structure for fast triangulation traversal. Its
online documentation can be found
<a
href="https://topology-tool-kit.github.io/doc/html/classttk_1_1Triangulation.
html"
target="new">
HERE</a>.<br><br>
In <code>~/ttk/ttk-0.9.2/core/baseCode/bettiNumbers/BettiNumbers.h</code>, a
pointer to an object of this class (<code>triangulation_</code>) is
readily available and correctly initialized to the triangulation passed on the
input of your module.<br><br>
TTK's triangulation data-structure supports a cache based access. This means
the data-structure needs to be pre-conditioned depending on the type of
traversal it will undergo, before it gets actually traversed. For instance, if
you want to access the i-th vertex of the j-th edge of the triangulation (with
the function <code>getEdgeVertex()</code>), you will need, before the actual
traversal, to call the pre-conditioning function
<code>preprocessEdges()</code> in a pre-process, as explained in the
<a
href="https://topology-tool-kit.github.io/doc/html/classttk_1_1Triangulation.
html#a0c7e36ed34696d0d26eb411272145880"
target="new">documentation of the
<code>getEdgeVertex()</code> function</a>.
Note that each traversal function comes with its own pre-conditioning function,
to be called in the pre-processing stage of your module.
<br><br>
Typically, in
<code>~/ttk/ttk-0.9.2/core/baseCode/bettiNumbers/BettiNumbers.h</code>, the
function <code>setupTriangulation()</code> is the right placeholder to put such
a pre-conditioning statement, while the actual traversal should happen in the
<code>execute()</code> function, next to our prior "Hello World!"
message.<br><br>
Now go ahead and compute <code>B0</code>, the number of connected components of
<code>M</code>.<br><br>
To do this, you'll need to allocate an array (typically an STL vector) of
<code>UnionFind</code> objects with as many entries as vertices in
<code>M</code>. Next, you'll need to iterate over the edges of <code>M</code>
and call the <code>makeUnion()</code> operation on the UF objects of each edge.
Finally, you'll need to iterate over your initial array of UF objects,
re-assign to each entry the result of its <code>find()</code> operation (to
obtain the latest representative) and enumerate the number of unique remaining
representatives.
<br><br>
<h4>Exercise 3: B2 (~30 lines of code)</h4>
The 2-nd Betti number (noted <code>B2</code>) corresponds to the number of
voids of the input manifold <code>M</code>. To compute <code>B2</code>, we will
exploit one of the results by Dey and Guha, published in their 1998 paper
<a
href="http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.41.2252&rep=rep1&
type=pdf"
target="new">
"Computing Homology Groups of Simplicial Complexes in R3"</a>.<br><br>
Parse the above paper and identify the expression of <code>B2</code>. From
there, edit the function <code>execute()</code> of
<code>~/ttk/ttk-0.9.2/core/baseCode/bettiNumbers/BettiNumbers.h</code> to also
compute and display <code>B2</code>.
<br><br>
<h4>Exercise 4: B1 (~20 lines of code)</h4>
The 1-st Betti number (noted <code>B1</code>) corresponds to the number of
independent cycles
of the input manifold <code>M</code>.
To compute <code>B1</code>, we will
exploit one of the results by Dey and Guha, published in their 1998 paper
<a
href="http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.41.2252&rep=rep1&
type=pdf"
target="new">
"Computing Homology Groups of Simplicial Complexes in R3"</a>.<br><br>
Parse the above paper and identify the expression of <code>B1</code>.
From there, edit the function <code>execute()</code> of
<code>~/ttk/ttk-0.9.2/core/baseCode/bettiNumbers/BettiNumbers.h</code> to also
compute and display <code>B1</code>.
<br><br>
<h4>Exercise 5: Euler characteristic and beyond (~3 lines of code)</h4>
Compute and display the Euler characteristic <code>X</code> of <code>M</code>.
How does it relate to the Betti numbers of <code>M</code>?<br>
<div class=caption>
<a href="img/bettiNumbers_thresholding.png" target="new">
<img width="100%" src="img/bettiNumbers_thresholding.png">
</a>
</div>
Now, in ParaView, use the <code>Threshold</code> filter on your input
triangulation and modify the <code>Maximum</code> parameter (the upper bound).
Since our test data sets come with an attached scalar field, this will have the
effect of selecting all the tetrahedra of <code>M</code> with vertices having a
default scalar value below the <code>Maximum</code> parameter.<br><br>
Now use your module to compute the Betti numbers of this selection. Now adjust
the <code>Maximum</code> parameter again and click on <code>Apply</code>. The
Betti numbers should be updated automatically.<br><br>
Keep on modifying the value <code>Maximum</code>. Where do the Betti numbers
change? What do these configurations correspond to?<br><br>
Check your intuition with the other data-sets available in the
<code>~/ttk/bettiData/</code> directory. Note that for <code>at.vti</code>, you
will need to call the filter <code>Tetrahedralize</code> prior to any other
processing.<br><br>
Now, instead of changing the <code>Maximum</code> parameter of the
<code>Threshold</code> filter, change the <code>Minimum</code> parameter
instead. What do you observe in terms of the changes of Betti numbers?
</p>
</p>
</div>
</div>
</div>
<hr>
<!-- Footer -->
<footer>
<div class="container">
<div class="row">
<div class="col-lg-8 col-lg-offset-2 col-md-10 col-md-offset-1">
<p class="copyright text-muted">
Contact: <a href="mailto:[email protected]">
[email protected]</a><br>
Updated on November 19, 2017.</p>
</div>
</div>
</div>
</footer>
<!-- jQuery -->
<script src="vendor/jquery/jquery.min.js"></script>
<!-- Bootstrap Core JavaScript -->
<script src="vendor/bootstrap/js/bootstrap.min.js"></script>
<!-- Contact Form JavaScript -->
<script src="js/jqBootstrapValidation.js"></script>
<script src="js/contact_me.js"></script>
<!-- Theme JavaScript -->
<script src="js/clean-blog.min.js"></script>
</body>
</html>