A Structural Average of Labeled Merge Trees for Uncertainty Visualization

TL;DR

This paper introduces a method to compute a structural average of labeled merge trees to encode and visualize uncertainty in scalar field data, using interleaving distance and consistency measures.

Contribution

It presents a novel approach to aggregate merge trees under uncertainty, employing interleaving distance and heuristic algorithms for structural averaging.

Findings

Developed a 1-center tree that minimizes maximum distance to input trees.

Created an interactive visualization system for merge tree averaging.

Demonstrated the approach on ensembles of scalar fields.

Abstract

Physical phenomena in science and engineering are frequently modeled using scalar fields. In scalar field topology, graph-based topological descriptors such as merge trees, contour trees, and Reeb graphs are commonly used to characterize topological changes in the (sub)level sets of scalar fields. One of the biggest challenges and opportunities to advance topology-based visualization is to understand and incorporate uncertainty into such topological descriptors to effectively reason about their underlying data. In this paper, we study a structural average of a set of labeled merge trees and use it to encode uncertainty in data. Specifically, we compute a 1-center tree that minimizes its maximum distance to any other tree in the set under a well-defined metric called the interleaving distance. We provide heuristic strategies that compute structural averages of merge trees whose labels do not fully agree. We further provide an interactive visualization system that resembles a numerical calculator that takes as input a set of merge trees and outputs a tree as their structural average. We also highlight structural similarities between the input and the average and incorporate uncertainty information for visual exploration. We develop a novel measure of uncertainty, referred to as consistency, via a metric-space view of the input trees. Finally, we demonstrate an application of our framework through merge trees that arise from ensembles of scalar fields. Our work is the first to employ interleaving distances and consistency to study a global, mathematically rigorous, structural average of merge trees in the context of uncertainty visualization.

Equations

$${\mathcal{D}}_{ij}=\frac{1}{2}\left|\max \{{\mathcal{D}}_{ij}^{\ell }{\}}_{\ell =1}^k-\min \{{\mathcal{D}}_{ij}^{\ell }{\}}_{\ell =1}^k\right|.$$

$$\text{mbox}{sim}_{\delta }(A,B)=\frac{{\sum }_i\left(e^{-\frac{A_i^2+B_i^2}{{\delta }^2}}{A}_i{B}_i\right)}{\sqrt{\left({\sum }_i{e}^{-\frac{2A_i^2}{{\delta }^2}}{A}_i^2\right)}\cdot \sqrt{\left({\sum }_i{e}^{-\frac{2B_i^2}{{\delta }^2}}{B}_i^2\right)}}.$$

Full text

\CCScatlist

Topological data analysis, uncertainty visualization, merge trees

1 Introduction

In topological data analysis and visualization, topological descriptors have been used to understand and summarize the shape of complex data in science and engineering, ranging from gene expression of breast cancer tumors [44] to high-throughput screening of nanoporous materials [42]. For data modeled as scalar fields, the most popular descriptors include vector-based such as persistence diagrams [25] and barcodes [32, 13], graph-based such as merge trees [7], contour trees [15], and Reeb graphs [64], as well as complex-based such as Morse and Morse-Smale complexes [31, 24, 23].

These topological descriptors provide meaningful abstractions, reduce the amount of data to be processed, utilize sophisticated hierarchical representations that capture features at multiple scales, and enable progressive feature simplifications. However, as pointed out by Heine et al. [36], one of the biggest challenges and opportunities is to develop original approaches that incorporate uncertainty into topological descriptors to advance topology-based visualization. In this paper, we focus on merge trees, which are a special type of topological descriptor that tracks the evolution of connected components in the sublevel sets of scalar fields [47]. We compute structural averages of a set of labeled merge trees (referred to as an ensemble), and utilize such averages in uncertainty visualization. Our work is motivated from a statistical and a visualization perspective.

Statistics on topological descriptors. In statistics, the concept of an average refers to a measure of central tendency. Given a set of numbers, the notions of mean, median, and mode are considered as numeric averages in different contexts. In this paper, we study a certain structural average among a set of labeled merge trees. In particular, we would like to find a metric 1-center of a finite set of labeled merge trees; that is, an average tree that minimizes the maximum distance to any other tree in the set. Given a metric space $(X,d)$, a $1$-center of a finite point set $P=\{p_{1},\cdots,p_{m}\}\subset X$ is a point $c\in X$ which satisfies $c=\displaystyle\arg\min_{x\in X}\max_{p\in P}d(x,p),$ i.e., $c\in X$ is the center of a minimum enclosing the ball of $P$. Here, our metric space is the space of all labeled merge trees equipped with a metric referred to as the interleaving distance for labeled merge trees [48]. The $1$-center is our notion of an average tree.

Our implementation in computing a 1-center is a first step toward performing statistical analysis of merge trees. By introducing a potentially extendable metric between labeled merge trees, we envision a complete suite of statistics describing the probability distribution of graph-based topological descriptors.

Visualization of uncertainty. Advances in technology such as increased bandwidth, storage, and computational power have led to a large amount of complex data. To effectively and accurately communicate such data to scientists via visualization, we should pay close attention to information about uncertainty, including accuracy, confidence, variability, and model bias [8].

Conveying uncertainty information through visualization, i.e., uncertainty visualization, is a very active area of research; e.g., see surveys [33, 71, 62]. Uncertainty information is often summarized via statistical quantities (such as mean, median, and standard deviation) and encoded with data via color, opacity, texture, glyphs, animation, etc. [62]. Uncertainty for 1D scalar fields is often expressed point-wise as error bars or boxplots [59]. In the case of 2D and 3D scalar fields, uncertainty can be encoded feature-wise within spatial domains (such as contours [57, 58, 75], 2D surfaces [60], and 3D volumes [61, 22]), as well as structure-wise as trees [41] or lattice graphs [19].

The challenges associated with the study of structure-wise uncertainty in graph-based descriptors can be attributed, in part, to the difficulty in characterizing and quantifying their structural uncertainty. In particular, ensemble datasets combining multiple realizations of a phenomenon are often used to mitigate the effects of uncertainty. State-of-the-art approaches typically aggregate over inherent data dimensions to reduce the structure and size of the data. Unfortunately, these aggregations can lose the richness in both global and local structures. For instance, a scalar field obtained by averaging the values from all the ensemble scalar field members at each data point (as a form of aggregation) was treated previously as the ensemble mean, and the contour tree of the ensemble mean was referred to as the mean contour tree [77].

In this regard, our work differs from previous approaches significantly. First, instead of computing a merge tree from an average scalar field, we calculate an average merge tree directly from a set of input trees that perhaps arise from an ensemble, and use such an average to encode uncertainty. Second, constructing an average labeled merge tree has a clean, mathematical foundation via a metric-space view, and does not rely on ad hoc operations. To the best of our knowledge, our work is the first to employ interleaving distances and consistency measures to study a mathematically rigorous structural average of merge trees in the context of uncertainty visualization.

Contributions. In this paper, we compute and visualize a structural average of labeled merge trees. Our work builds upon theoretical foundations regarding interleaving distances between labeled merge trees [30]. Such a distance is chosen because, unlike many of the other metrics available for merge trees, it is easily computable. It is also stable with respect to the input function data [48], and has a well-defined 1-center as well as geodesics. Our main contributions are the algorithms, implementations, and visualization design in moving from theory to practice, all of which are highly nontrivial.

• •

We provide an interactive visualization system to demonstrate the utilities of our proposed algorithms. It resembles a numerical calculator that takes as input an ensemble of leaf-labeled merge trees and outputs a tree as their structural average.

• •

We introduce heuristic strategies that complete the labelings for an ensemble of merge trees whose labels do not fully agree in order to provide structural averages.

• •

We highlight structural similarities between the input and the average tree and incorporate uncertainty information for visual exploration. To achieve this, we develop a novel measure of uncertainty for each vertex in the tree, via a metric-space view of the input trees. This measure is also flexible, allowing a local-global tradeoff in understanding structure variations.

• •

We demonstrate an application of our framework through merge trees that arise from ensembles of scalar fields.

Our framework is applicable to merge trees of the most general form; we give an additional example of applying our framework to merge trees derived from neuron morphology in Appx. F. Our visualization tool and algorithms are released open source under MIT license on Github: https://github.com/tdavislab/amt.

2 Related Work

We review the most relevant literature on uncertainty visualization of scalar fields, with a focus on graph-based topological descriptors and topological features. Our work is primarily concerned with structure-wise data uncertainty of scalar fields; for vector and tensor fields, see an overview in [36].

Graph-based topological descriptors. Graph-based topological descriptors include merge trees [7] (also known as barrier trees [27] or join trees [15]), contour trees [15], Reeb graphs [64], mapper graphs [67], and joint contour nets [14]. These descriptors are graph-based representations to illustrate how the topology of level sets or sublevel sets of scalar fields changes with a scalar value parameter.

For a topological space ${\mathbb{X}}$ equipped with a function $f:{\mathbb{X}}\to{\mathbb{R}}$, the merge tree encodes the connected components of the sublevel sets $f^{-1}(-\infty,a]$ for $a\in{\mathbb{R}}$. A closely related descriptor, the Reeb graph, encodes the connected components of the level sets $f^{-1}(a)$ instead. The contour tree [15] is a type of Reeb graph when ${\mathbb{X}}$ is simply connected. All these descriptors are related to Morse theory [46] and level-set topology through relations among critical points. They are widely applied in scientific visualization [74, 49, 76].

Since a contour tree of a function $f:{\mathbb{X}}\to{\mathbb{R}}$ can be constructed by carefully combining the merge trees of $f$ and $-f$ in linear time [15], merge tree visualization shares the same design space as that of a contour tree. Contour trees are often visualized with node-link diagrams in two or three dimensions [51, 15, 70, 52]. Such diagrams are simple and powerful tools for abstract data representations [74], contour extraction [73], and data explorations in various application domains [52, 2]. Many attempts have been made in contour tree visualization to overcome difficulties in visual interpretation, visual clutter, and missing topological features [78].

Uncertainty visualization of topological features. Critical points and contours (level sets, iso-surfaces) are important features for the study of scalar field topology. When data is affected by uncertainty, visualization of such topological features should adapt accordingly.

Mihai and Westermann [45] measure the likelihood of the occurrence of critical points with respect to both the positions and types of the critical points. Specifically, when the data uncertainty is described by a Gaussian distribution, confidence intervals are derived for the gradient and the determinant and trace of the Hessian matrix in scalar field ensembles to infer confidence regions for critical points [45]. Gunther et al. [35] characterize critical points and their spatial relation for 2D uncertain scalar fields, where each vertex in a regular grid is assigned a probability density function (PDF) describing its scalar value. They identify so-called mandatory critical points – spatial regions and function ranges where critical points have to occur in any realization of the input based on the PDF.

To visualize the effect of uncertainty on contours, envelopes within a gridded domain are extracted to indicate in which volume the contour will lie (with a certain confidence) [80, 50]. Uncertainty associated with a contour can also be rendered via animation [10] or as a collection of points where each point is displayed from “its original location along the surface normal by an amount proportional to the uncertainty at that point” [34]. Positional and geometrical variations of contours are captured by variability in gradients for uncertain scalar fields [54]. Positional uncertainty of contours could also be encoded by spatial correlation [55, 56] or numerical sensitivity [57]. Building on the notions of functional boxplots and data depth, contour boxplots [75] display statistical quantities analogous to the mean, median, and order statistics for ensembles of contours.

Finally, from an algorithmic perspective, probabilistic marching cubes [58] and positionally uncertain iso-contours [57] study the uncertainties inherent in computing the visual representations.

Uncertainty visualization of graph-based decriptors. Lee et al. have introduced CandidTree, which merges two trees into one and visualizes both location and subtree structural uncertainty [41]. Wu et al. have developed an interactive visualization tool that uses contour trees as abstract data representations to explore data-level uncertainty, contour and topology variability [77]. Kraus has employed grayscale morphology to visualize uncertain substructures in contour trees [39]. Zhang et al. have proposed sampling-based Monte Carlo methods to study contour trees of uncertain terrains, where uncertainty lies in the height function described by a probability distribution [81]. The work most relevant to ours is [77], where a mean contour tree is computed as the contour tree of the mean of an ensemble. However, our work differs significantly from [77] in that instead of computing a tree from an average of the ensemble members, we compute an average tree directly from a set of input trees (that potentially arise from ensemble members).

Distances between topological structures. Recently, many metrics have been proposed for merge trees, often by way of a restriction from a metric on the more general Reeb graph [7, 47, 20, 4, 6, 3, 5, 69, 16]. In this paper, we focus on the interleaving distance for labeled merge trees [48]. This distance is an example of an interleaving distance between persistence modules [17], which is brought to graph-based descriptors such as merge trees [47] and Reeb graphs [20] via category theory [11, 21].

The application of the interleaving distance to labeled merge trees can also be viewed as an interpretation of a metric for phylogenetic trees [12]. Our framework differs from the previous work as it relies on a clean and simple metric-space view of input trees that is equipped with geodesics, as well as easy-to-implement algorithms.

3 Technical Background

We first review mathematical notions in graph theory and computational topology, including merge trees, labeled merge trees, and the interleaving distance on labeled merge trees. We then introduce leaf-labeled merge trees with full, partial, or no label agreements, which are structures we deal with in our algorithms. We end this section by giving an example of a scalar field induced merge tree, that is, a merge tree that arises from a scalar function on a topological space.

3.1 Theoretical Foundations for Labeled Merge Trees

Our implementation and visualization design is built upon theoretical foundations established in [30], which focus on labeled merge trees of the most general form, and which we review below.

Merge trees and labeled merge trees. A tree is an undirected graph in which any two vertices (nodes) are connected by a unique path. A rooted tree is a tree in which a special vertex is chosen to be the root. The degree of a vertex is the number of edges incident to the vertex. We assume the root is of degree $1$.

Let $T=(V,E)$ denote a rooted tree with vertex set $V$ and edge set $E$. The leaves $L\subset V$ of $T$ are the nonroot vertices of degree $1$; other nonroot vertices are internal vertices.

Definition 3.1**.**

A merge tree is a pair $(T,f)$ consisting of a rooted tree $T$ and a function $f:V\to{\mathbb{R}}\cup\{\infty\}$ such that $f(u)\neq f(v)$ for all $uv\in E$, $f(v)=\infty$ if and only if $v$ is the root, and every nonroot vertex has exactly one neighbor with a higher function value.

A scalar field induced merge tree is a special case of a merge tree in Definition 3.1, which we review in Sec. 3.3. We require $f(v)=\infty$ for the root $v$ for technical reasons. We also require $f(u)\neq f(v)$ for all $uv\in T$; in practice, this can be achieved by the simulation of simplicity [26]. For any pair of vertices $u,v\in V$, we write ${a}(u,v)\in V$ for their lowest common ancestor; that is, the unique vertex of minimum function value such that the unique path from ${a}(u,v)$ to either $u$ or $v$ strictly decreases in the value of $f$. Then $f(a(u,v))$ denotes its function value. For ease of notation, let $[n]:=\{1,\ldots,n\}$ denote a label set.

Definition 3.2**.**

A labeled merge tree ${\mathcal{T}}$ is a triple $(T,f,\mu)$ that consists of a merge tree $(T,f)$ along with a map $\mu:[n]\to V$ called a labeling that is surjective on the set of leaves $L\subset V$. When we need to emphasize the number of labels, we will call this an $n$-labeled merge tree.

Let $|T|=m$ be the size of the merge tree, or in other words, the number of nonroot vertices in the tree. Note that the definition permits trees with labeled internal vertices as well as vertices with multiple labels; see Fig. 1 (left) for an example. Surjectivity on $L$ means that $n$, an arbitrary positive integer, satisfies $n\geq|L|$. For practical purposes, we will usually have $n\leq m$, but this is by no means required. Finally, a merge tree $(T,f)$ without a labeling is referred to as an unlabeled merge tree.

Induced matrix and interleaving distance. We can build a matrix from a labeled merge tree. The induced matrix of an $n$-labeled merge tree ${\mathcal{T}}=(T,f,\mu)$ is the symmetric matrix ${\mathcal{D}}\in{\mathbb{R}}^{n\times n}$ where ${\mathcal{D}}_{ij}=f({a}(\mu(i),\mu(j)))$. See Fig. 1 (middle) for an example of an induced matrix. The reason for turning the trees into matrices is that we can immediately use a natural choice of distance between the matrices to obtain a distance between the trees as follows:

Definition 3.3**.**

Given two $n$-labeled merge trees ${\mathcal{T}}^{1}=(T_{1},f_{1},\mu_{1})$ and ${\mathcal{T}}^{2}=(T_{2},f_{2},\mu_{2})$, the (labeled) interleaving distance between them is defined to be the $L_{\infty}$ distance between their corresponding induced matrices ${\mathcal{D}}^{1}$ and ${\mathcal{D}}^{2}$, namely $d_{I}({\mathcal{T}}^{1},{\mathcal{T}}^{2})=||{\mathcal{D}}^{1}-{\mathcal{D}}^{2}||_{\infty}.$

Notice that Definition 3.3 requires that the two given trees have the same labeling, so that they are both $n$-labeled merge trees.

Labeled merge tree of a valid matrix. We can also turn certain matrices back into trees. A symmetric matrix ${\mathcal{D}}\in{\mathbb{R}}^{n\times n}$ is called valid if ${\mathcal{D}}_{ii}\leq{\mathcal{D}}_{ij}$ for all $i,j$. A valid matrix encodes a function $f$ on the complete graph $K$ of $n$ vertices modeled after $n$ labels, with function value ${\mathcal{D}}_{ii}$ on the vertex $i$ and ${\mathcal{D}}_{ij}$ on the edge $ij$.

The labeled merge tree of a valid matrix ${\mathcal{D}}\in{\mathbb{R}}^{n\times n}$, denoted ${\rm MergeTree\,}({\mathcal{D}})$, is the labeled merge tree of the complete graph with the induced function $f$. For a fixed $a\in{\mathbb{R}}$, let $K_{a}=f^{-1}(-\infty,a]$. Such a merge tree is obtained by tracking the connected components of $K_{a}$ as $a$ increases. See Fig. 1 (right) for an example and Sec. 4 for implementation details.

A valid matrix ${\mathcal{D}}$ is called ultra if ${\mathcal{D}}_{ij}\leq\max\{{\mathcal{D}}_{ik},{\mathcal{D}}_{kj}\}$. The induced matrix of a labeled merge tree is an ultra matrix; in fact, this construction induces a bijection between the space of labeled merge trees and the space of ultra matrices [30].

It has been shown that the interleaving distance defined above enjoys nice properties including stability [48]; in particular, two theoretical results from [30] that are central to our paper are included here for completeness. Theorem 3.1, which is a proposition from [30], lays the foundation for computing a $1$-center for a set of labeled merge trees.

Theorem 3.1** (Proposition LMT 1-Center [30]).**

Given $n$-labeled merge trees ${\mathcal{T}}^{1},\ldots,{\mathcal{T}}^{k}$ and their corresponding induced ultra matrices ${\mathcal{D}}^{1},\ldots,{\mathcal{D}}^{k}$, let ${\mathcal{D}}$ be the element-wise $1$-center of ${\mathcal{D}}^{1},\ldots,{\mathcal{D}}^{k}$. Set ${\mathcal{T}}={\rm MergeTree\,}({\mathcal{D}})$. Then ${\mathcal{T}}$ is a $1$-center of the labeled merge trees ${\mathcal{T}}^{1},...,{\mathcal{T}}^{k}$.

Note that when using the $L_{\infty}$ distance, the 1-center for the matrices is not unique. However, it is easy enough to compute one of these, which we will make use of in our implementation described in Sec. 4. The next theorem implies the existence of an animated morphing between trees, which is also used in our implementation.

Theorem 3.2** (Corollary LMT Geodesics [30]).**

Given any two $n$-labeled merge trees ${\mathcal{T}}^{1}$ and ${\mathcal{T}}^{2}$ and their corresponding induced ultra matrices ${\mathcal{D}}^{1}$ and ${\mathcal{D}}^{2}$, the family of merge trees $\left\{{\mathcal{T}}^{\lambda}:={\rm MergeTree\,}\left({\mathcal{D}}^{\lambda}\right)\mid{\lambda\in[0,1]}\right\}$ defines a geodesic between ${\mathcal{T}}^{1}$ and ${\mathcal{T}}^{2}$ in the metric $d_{I}$ where ${\mathcal{D}}^{\lambda}=(1-\lambda)\,{\mathcal{D}}^{1}+\lambda\,{\mathcal{D}}^{2}$.

3.2 Leaf-Labeled Merge Trees

We will focus on a restricted class of labeled merge trees defined as follows. Recall $[n]:=\{1,\ldots,n\}$.

Definition 3.4**.**

A leaf-labeled merge tree ${\mathcal{T}}$ is a triple $(T,f,\omega)$ that consists of a merge tree $(T,f)$ together with a labeling $\omega:S\to L$ that is surjective on the set of leaves $L$, where $S\subseteq[n]$.

Unlike Definition 3.2, leaf-labeled merge trees allow labels only on the leaves. Also, unlike the traditional definition of a leaf-labeled tree where each of its leaves is labeled by precisely one element from a given label set [37], Definition 3.4 permits multiple labels on the same leaf. The set of leaf-labeled merge trees can be considered as a subset of labeled merge trees by considering $\omega$ as a restriction of $\mu$ to a subset of $[n]$. Up to reindexing the label set, the properties involving induced matrices (Theorems 3.1 and 3.2) and interleaving distance (Definition 3.3) therefore apply to leaf-labeled merge trees.

Full agreement, partial agreement and disagreement. In our implementation, we work with input data with various levels of labeling, so we discuss some terminology for various types of missing information next. First, an ensemble of leaf-labeled merge trees $\{(T_{i},f_{i},\omega_{i})\}_{i=1}^{k}$ is in full agreement if the trees all share the same label set; that is, if the domain of $\omega_{i}$ is the same for all $i$. Second, an ensemble of leaf-labeled merge trees $\{(T_{i},f_{i},\omega_{i})\}_{i=1}^{k}$ is in partial agreement if the trees are not in full agreement and $\bigcap_{i=1}^{k}S_{i}\neq\emptyset$. Third, an ensemble of leaf-labeled merge trees $\{(T_{i},f_{i},\omega_{i})\}_{i=1}^{k}$ is in disagreement if $\bigcap_{i=1}^{k}S_{i}=\emptyset$. Ensembles of the second and the third type can also be treated as being partially labeled and unlabeled, respectively, although we rarely use these terminologies here.

3.3 Merge Trees from Scalar Field Ensembles

Of particular interest to visualization is merge trees that arise from an ensemble of scalar fields. Each tree captures the connectivity of the sublevel sets of a scalar field. In this paper, we refer to it as a scalar field induced merge tree.

Given a scalar function $f$ defined on a topological space ${\mathbb{X}}$, $f:{\mathbb{X}}\to{\mathbb{R}}$, let ${\mathbb{X}}_{a}:=f^{-1}(-\infty,a]$ denote the sublevel set of $f$ for some $a\in{\mathbb{R}}$. Two points $x,y\in{\mathbb{X}}$ are equivalent, $x\sim y$, if they have the same function value, so $f(x)=f(y)=a$, and if they belong to the same component of the sublevel set ${\mathbb{X}}_{a}$. The quotient space ${\mathbb{X}}$ with respect to the above equivalence relation, ${\mathbb{X}}/\sim$, is referred to as a scalar field induced merge tree to differentiate it from the more general Definition 3.1. We still refer to such a tree as a merge tree when it is clear from the context.

A scalar field induced merge tree is constructed by tracking the evolution of the components of ${\mathbb{X}}_{a}$ as we vary the parameter $a$. Fig. 2 gives an example: leaves represent the creation of a component at a local minimum, internal vertices (saddles) represent the merging of components, and the root represents the entire space as a single component; see a straight line drawing in Fig. 2(c). We can further augment a scalar field induced merge tree with noncritical points, producing an augmented merge tree [15, Section 3.3]; otherwise it is unaugmented. In this paper, we always visualize an augmented merge tree by embedding its vertices (both critical and noncritical) inside the graph of $f$, as in Fig. 2(b).

3.4 Distance Between Vertices

Not only do we use distances between the trees themselves, but we also make use of a couple of different distances between vertices of a given merge tree for our implementation. Such distances impose a metric-space view of input trees and are useful both when handling merge trees with partial or no agreement (Sec. 4.2), and in helping to define consistency of vertices in Sec. 5.

Assume we are given a labeled merge tree ${\mathcal{T}}=(T,f,\omega)$. The first distance is an intrinsic distance on the merge tree $T$ induced by the function $f$. Specifically, the intrinsic tree distance between a pair of vertices $x,y\in V$ is defined to be $d_{T}(x,y)=|f(x)-f(a(x,y))|+|f(a(x,y))-f(y)|$. Note that this is exactly the path length between the vertices if we give every edge a weight equal to the difference in function values of its endpoints.

Now suppose, additionally, that ${\mathcal{T}}$ has an embedding $\iota$ in ${\mathbb{R}}^{d}$, $\iota:|T|\to{\mathbb{R}}^{d}$ (in our experiments, $d=2$ or $3$). The second distance, the Euclidean distance between a pair of vertices $x,y\in V$, is the $L_{2}$ distance between their embeddings, $d_{E}(x,y)=||\iota(x)-\iota(y)||_{2}$.

4 Computing 1-Centers of Labeled Merge Trees

Moving from theory to practice, we now discuss implementation details for computing a 1-center of leaf-labeled merge trees. We compute a structural average under three different scenarios: full agreement, partial agreement, and disagreement. For simplicity of explanation, we focus on leaf-labeled merge trees. Our algorithms and uncertainty encodings (Sec. 5) can be easily adapted to handle general merge trees with labeled internal vertices (Definition 3.2).

4.1 Full Agreement

We start with the simplest case: given an ensemble of leaf-labeled merge trees in full agreement, we compute its 1-center as a structural average. As specified by Theorem 3.1, the main idea is to compute an element-wise 1-center of their induced ultra matrices and convert the resulting valid matrix into a new merge tree.

We start with an ensemble of $k$ leaf-labeled merge trees in full agreement, ${\mathcal{T}}^{1},\cdots,{\mathcal{T}}^{k}$, i.e., they all share the same label set $S\subseteq[n]$, with $|S|=s$. On a high level, our algorithm has three simple steps:

1. F1.

Represent each ${\mathcal{T}}^{i}$ by its induced ultra matrix ${\mathcal{D}}^{i}$ for $1\leq i\leq k$. 2. F2.

Compute the element-wise 1-center ${\mathcal{D}}$ of ${\mathcal{D}}^{1},\cdots,{\mathcal{D}}^{k}$. 3. F3.

Turn ${\mathcal{D}}$ back into a merge tree ${\mathcal{T}}={\rm MergeTree\,}({\mathcal{D}})$.

An example for two leaf-labeled merge trees ${\mathcal{T}}^{1}$ and ${\mathcal{T}}^{2}$ in full agreement is given in Fig. 3.

Assume each tree ${\mathcal{T}}^{i}=(T_{i},f_{i},\omega_{i})$ induces an ultra matrix ${\mathcal{D}}^{i}\in{\mathbb{R}}^{s\times s}$ indexed by the shared label set $S\subset[n]$. For step F2, we construct a choice of 1-center by computing the 1-center of each element,

[TABLE]

Intuitively, ${\mathcal{D}}_{ij}$ is the center of a minimum enclosing ball of points ${\mathcal{D}}^{1}_{ij},\cdots,{\mathcal{D}}^{k}_{ij}$ on a line, i.e., the midpoint between the smallest and the largest values along the line.

For Step F3, we turn ${\mathcal{D}}$ back into a new merge tree ${\mathcal{T}}={\rm MergeTree\,}({\mathcal{D}})$. Despite the fact that the matrices ${\mathcal{D}}^{\ell}$ are ultra matrices, the construction of Eq. (1) is not guaranteed to be ultra. However, it will be a valid matrix, and thus it encodes a function $f$ on the complete graph $K$ among $n$ labels as vertices, $f:K\to{\mathbb{R}}$. Specifically, each vertex $v_{i}\in K$ has value $f(v_{i})={\mathcal{D}}_{ii}$; while each edge $e_{ij}=(v_{i},v_{j})\in K$ has function value $f(e_{ij})={\mathcal{D}}_{ij}$. That ${\mathcal{D}}$ being a valid matrix guarantees that the function value of an edge is larger than or equal to that of each of its endpoint. The returned merge tree follows the standard merge tree construction described below.

Denote the sublevel set of $K$ for $a\in{\mathbb{R}}$ by $K_{a}:=f^{-1}(-\infty,a]$. The merge tree of $f$ is defined on the vertex set of $K$ and keeps track of the connected components in $K_{a}$. As $a$ increases from $-\infty$ to $\infty$, vertices in $K$ creates new components in the tree, and edges in $K$ either connect two vertices already from the same components, or merge existing components. We adapt Kruskal’s algorithm that runs in time $O(|E|a(|V|))$ ($a$ denotes the inverse of the Ackermann function), processes vertices/edges in a sorted order, and maintains connected components in a disjoint set data structure [29, 28] that supports fast component identification and merging [68].

By Theorem 3.1, ${\mathcal{T}}$ is a 1-center of the leaf-labeled merge trees. Such a 1-center is not necessarily unique; nevertheless it serves as a justifiable structural average as it minimizes the maximum distance to any other tree in the set under $d_{I}$. Note that we allow multiple labels on the same leaf to ensure that this definition is well defined. See an example from Fig. 5 generated from our visualization system.

4.2 Partial Agreement

We now discuss strategies to turn incomplete information in terms of labeling into complete information so that the algorithm of Sec. 4.1 can be utilized. Given an ensemble of trees whose labels do not fully agree, finding the best ways to label the remaining vertices boils down to finding the best correspondences under the interleaving distance, which is unfortunately NP-hard [1]. We thus aim to develop a heuristic approach that is efficient and effective in practice for both the partial agreement and disagreement cases.

Assume we are given an ensemble of leaf-labeled merge trees ${\mathcal{T}}_{1},\cdots,{\mathcal{T}}_{k}$ in partial agreement. If $S_{i}$ is the label set for tree ${\mathcal{T}}_{i}$, let $S=\bigcap_{i=1}^{k}S_{i}$ be the shared set of labels. For simplicity, we assume leaves do not have multiple labels for the input trees. On a high level, our algorithm is as follows:

1. P1.

Select a pivot tree ${\mathcal{T}}^{p}=(T_{p},f_{p},\omega_{p})$ with the largest number of leaves among the input trees. Let $S_{p}$ be its label set. 2. P2.

Convert each ensemble member ${\mathcal{T}}^{i}=(T_{i},f_{i},\omega_{i})$ to a labeled tree ${\mathcal{T}}_{i}^{\prime}=(T^{\prime}_{i},f_{i},\omega^{\prime}_{i})$ by updating its labeling using the label set $S_{p}$ combined with minimum weight matching. 3. P3.

Compute a $1$-center of the trees ${\mathcal{T}}_{1^{\prime}},\cdots,{\mathcal{T}}_{k^{\prime}}$ using Sec. 4.1.

The key step is P2, for which we first give a pictorial toy example in Fig. 4 (top). The main idea is to study the structural similarities between unmatched leaves by comparing their distances (a linear combination of $d_{T}$ and $d_{E}$) to the matched leaves and solving a minimum weight matching problem. We also give an example in Fig. A Structural Average of Labeled Merge Trees for Uncertainty Visualization generated from our visualization system.

Algorithmic details. Recall that a matching in a bipartite graph is a set of the edges chosen in such a way that no two edges share an endpoint. A vertex is matched if it is an endpoint of one of the edges in the matching. Otherwise it is unmatched. A maximum matching is a matching of a maximum number of edges. An assignment (or a minimum weight matching) problem, in our setting, is the problem of finding, in a weighted bipartite graph, a maximum matching in which the sum of weights of the edges is as small as possible.

We describe our algorithm with the toy example given in Fig. 4. Given a pivot tree ${\mathcal{T}}^{p}$ with a label set $S_{p}=\{1,2,3,4\}$, we update the labeling for an ensemble member ${\mathcal{T}}^{i}$ using $S_{p}$. The matched (shared) label set between the two trees is $S=\{1,2\}$, and the unmatched label sets in ${\mathcal{T}}^{p}$ and ${\mathcal{T}}^{i}$ are $U_{p}=\{3,4\}$ and $U_{i}=\{5\}$, respectively. Our goal is to assign new labels to $U_{i}$ from the set $U_{p}$ as follows.

First, build $D_{p}$ to be a pairwise distance matrix with rows corresponding to unmatched labels $U_{p}$ and columns corresponding to matched labels $S$. For $x\in U_{p}$ and $y\in S$, $D_{p}(x,y)$ is the distance between leaves $\omega_{p}(x)$ and $\omega_{p}(y)$. The matrix $D_{i}$ is built similarly for tree ${\mathcal{T}}_{i}$. Note that both $D_{p}$ and $D_{i}$ have the same number of columns, but potentially a different number of rows. In our example, using the tree distance $d_{T}$, we have $D_{p}=\begin{pmatrix}6&6\\ 5&5\end{pmatrix}$ and $D_{i}=\begin{pmatrix}6&6\end{pmatrix}.$

Second, construct a complete, weighted bipartite graph with vertex sets $U_{i}$ and $U_{p}$ where the weight $c_{xy}$ between a label $x\in U_{i}$ and $y\in U_{p}$ is given by the $L_{2}$ distance between the rows from $D_{i}$ and $D_{p}$, respectively. We find a minimum weight matching in this bipartite graph that gives an assignment of the rows of $D_{i}$ (unmatched labels in an ensemble member) to the rows of $D_{p}$ (matched labels in the pivot tree).

Formally, let $b$ be a Boolean matrix where $b_{xy}=1$ if and only if a leaf $x\in U_{i}$ is assigned to a leaf $y\in U_{p}$. Then the optimal assignment has a cost: $\min\sum_{x}\sum_{y}c_{xy}b_{xy}.$ We then use the SciPy Python library to find a minimum cost matching, which employs the Hungarian algorithm [40]. Since ${\mathcal{T}}^{p}$ was chosen to have the maximum number of leaves over all trees, $|U_{i}|\leq|U_{p}|$, and thus an optimal assignment will saturate all vertices in $U_{i}$. Thus, the output is a complete assignment $\eta:U_{i}\to U_{p}$ of minimal cost. We then define $\omega^{\prime}_{i}(x)=\eta(x)$ for $x\in U_{i}$, and $\omega^{\prime}_{i}(x)=\omega_{i}(x)$ otherwise.

At this point, we might still have unmatched labels $U^{\prime}_{p}$ in the pivot tree ${\mathcal{T}}^{p}$. We use a greedy algorithm to assign each such label to a leaf in the input tree based on its local structure similarity. In the example, we compute an updated matrix $D^{\prime}_{p}$ between the remaining unmatched label $U^{\prime}_{p}=\{4\}$ and the matched labels $S^{\prime}=\{1,2,3\}$, obtaining $D^{\prime}_{p}=\begin{pmatrix}5&5&3\end{pmatrix}.$ We then compute the pairwise distance matrix between all matched labels for ${\mathcal{T}}^{i}$ as $D^{\prime}_{i}=\begin{pmatrix}0&2&6\\ 2&0&6\\ 6&6&0\end{pmatrix}.$ The weight $c^{\prime}_{xy}$ between a label $x\in S^{\prime}_{i}$ and a label $y\in U^{\prime}_{p}$ is again given by the $L_{2}$ distance between the rows from $D^{\prime}_{i}$ and $D^{\prime}_{p}$, respectively. The leaf with the label $x$ now obtains an additional label $y$ when $c^{\prime}_{xy}$ achieves its minimum. In the toy example, the leaf in ${\mathcal{T}}^{i}$ with a label 3 obtains an additional label 4. In other words, the labeling $\omega^{\prime}$ is further updated by including the label $4$ in its domain.

4.3 Disagreement

To compute a 1-center for an ensemble of leaf-labeled trees in disagreement, we again employ a labeling strategy that converts the trees to leaf-labeled trees in full agreement, and then apply the algorithm in Sec. 4.1. To find the labels, however, we now assume each tree ${\mathcal{T}}_{i}=(T_{i},f_{i},\omega_{i})$ comes with a geometric embedding $\iota_{i}:|T_{i}|\to{\mathbb{R}}^{d}$. Our algorithm below is very similar to the partial agreement case; see Fig. 6 for an example.

• D1.

Select a pivot tree ${\mathcal{T}}^{p}$ with the largest number of leaves. Let $S_{p}$ be its label set.

• D2.

Update the initial labeling of each ensemble member ${\mathcal{T}}^{i}$ by creating a new labeling using the label set $S_{p}$ and a minimum weight matching. The updated tree is denoted as ${\mathcal{T}}^{i^{\prime}}$.

• D3.

Compute a $1$-center of the trees ${\mathcal{T}}^{1^{\prime}},\cdots,{\mathcal{T}}^{k^{\prime}}$ following Sec. 4.1.

In Step D2, for each ensemble member ${\mathcal{T}}^{i}$, we assume $S_{i}\cap S_{p}=\emptyset$ (otherwise, we follow the identical algorithm in Sec. 4.2). We create a weighted, complete bipartite graph between the label sets $S_{i}$ and $S_{p}$, where the weight $c_{xy}$ between a label $x\in S_{i}$ and a label $y\in S_{p}$ is their Euclidean distance in the embedded space, $c_{xy}=d_{E}(\iota_{i}(x),\iota_{p}(y))$. We again solve a minimum weight matching problem. The output is a complete assignment $\eta:S_{i}\to S_{p}$ of minimal cost. We then define $\omega^{\prime}_{i}(x)=\eta(x)$ for $x\in S_{i}$. Since $|S_{i}|\leq|S_{p}|$, for any unmatched label $y\in S_{p}$, we follow a similar strategy as in Sec. 4.2, and $\omega^{\prime}_{i}$ is updated accordingly.

5 Encoding Uncertainty

Given an ensemble of labeled merge trees ${\mathcal{T}}^{1},\cdots,{\mathcal{T}}^{k}$ and their 1-center ${\mathcal{T}}$, we work toward a visualization that highlights the structural consistency between each member ${\mathcal{T}}^{i}$ and ${\mathcal{T}}$. To this end, we develop a novel measure of uncertainty via a metric space view of trees in the ensemble. This measure is also flexible, allowing a local-global tradeoff in understanding structure variations. In particular, we compute and visualize vertex consistency following a strategy based on Gaussian-weighted cosine similarity. Our consistency measures apply to general labeled merge trees as in Definition 3.2, not just leaf-labeled ones.

5.1 Computing Consistency for a Pair of Trees

Cosine similarity and weighted cosine similarity. Cosine similarity is a measure of similarity between two nonzero vectors that measures the cosine of the angle between them. Let $A=[A_{1},\cdots,A_{m}]$ and $B=[B_{1},\cdots,B_{m}]$ be two nonzero vectors of length $m$. Their cosine similarity is $\mbox{sim}(A,B)=\frac{\sum_{i}A_{i}B_{i}}{\sqrt{\sum_{i}A^{2}_{i}}\sqrt{\sum_{i}B^{2}_{i}}}.$ With respect to the parameter $\delta$, we use a Gaussian-weighted cosine similarity given by

[TABLE]

Note that this similarity provides a “soft-threshold” for entries of $A$ and $B$, so that entries smaller than $O(\delta)$ play a more important role in the similarity measure. In general, smaller values of the $A_{i}$’s and $B_{i}$’s are more important. If we remove all exponential factors in Eq. (2), then it becomes the standard cosine similarity.

Vertex consistency. Given two labeled merge trees ${\mathcal{T}}^{1}=(T_{1},f_{1},\mu_{1})$ and ${\mathcal{T}}^{2}=(T_{2},f_{2},\mu_{2})$, we want to compute the consistency of vertices in ${\mathcal{T}}^{1}$ with respect to vertices in ${\mathcal{T}}^{2}$. For simplicity, we assume that $\mu_{1}$ and $\mu_{2}$ are bijective on the set of vertices $V_{1}$ and $V_{2}$, respectively (thus all vertices of ${\mathcal{T}}^{1}$ and ${\mathcal{T}}^{2}$ have unique labels). Let $|S_{1}|=|S_{2}|=s$ be the number of labels.

Let $V_{1}=\{v_{1},\ldots,v_{s}\}$ and $V_{2}=\{w_{1},\ldots,w_{s}\}$ be the labeled vertices for $T_{1}$ and $T_{2}$, respectively, where $v_{i}$ corresponds to $w_{i}$. Assume the chosen metrics between vertices in $T_{1}$ and $T_{2}$ are $d_{1}$ and $d_{2}$, respectively, and fix a label $l$. We wish to measure the “consistency” of node $v_{l}$ of $T_{1}$ with node $w_{l}$ of $T_{2}$. To do this, consider the two vectors $A=[d_{1}(v_{1},v_{l}),\ldots,d_{1}(v_{s},v_{l})]$ and $B=[d_{2}(w_{1},w_{l}),\ldots,d_{2}(w_{s},w_{l})]$. That is, $A$ (resp. $B$) is the vector of distances from $v_{l}$ (resp. $w_{l}$) to all other vertices (ordered by the labels). Intuitively, $A$ (resp. $B$) summarizes how all other vertices relate to $v_{l}$ (resp. to $w_{l}$) from a metric point of view. Hence, to measure the consistency between $v_{l}$ and $w_{l}$, we use the Gaussian-weighted cosine similarity between these two vectors; that is, the vertex consistency between $v_{l}$ and $w_{l}$ is $\mbox{sim}_{\delta}(v_{l},w_{l}):=\mbox{sim}_{\delta}(A,B)$. This consistency (similarity) value ranges from [math] to $1$, and it is $1$ if and only if $A=B$.

Intuitively, $\delta$ is a locality parameter: distances larger than, say, $3\delta$, will essentially be ignored, so this in effect is a soft thresholding where only nearby neighbors of $v_{l}$ and $w_{l}$ are being considered. By adjusting $\delta$, we can change the neighborhood size. Setting $\delta=\infty$, we recover the traditional cosine similarity. The larger $\mbox{sim}(v_{l},w_{l})$ is, the more consistent vertices $v_{l}$ and $w_{l}$ are with each other.

We define the vertex consistency of ${\mathcal{T}}^{1}$ (with respect to ${\mathcal{T}}^{2}$) as a function defined on the vertices of ${\mathcal{T}}^{1}$, $\alpha_{1}:V_{1}\to{\mathbb{R}}$. For a vertex with a label $l$, $\alpha_{1}(v_{l})=\mbox{sim}_{\delta}(v_{l},w_{l})$ for $v_{l}\in V_{1}$ and $w_{l}\in V_{2}$. $\alpha_{2}:V_{2}\to{\mathbb{R}}$ is defined similarly.

5.2 Visual Encoding of Consistency for an Ensemble

We describe visual encodings for vertex consistencies for an ensemble member, variational consistencies, and statistical consistencies for the 1-center tree.

We encode vertex consistency for an ensemble member ${\mathcal{T}}^{i}$ (with respect to the 1-center ${\mathcal{T}}$) using glyphs; see Fig. 8(left). Specifically, given a vertex consistency $\alpha_{i}:V_{i}\to{\mathbb{R}}$, the radius of each circular glyph at a vertex $v\in V_{i}$ scales proportional with $\alpha_{i}(v)$.

We encode variations in vertex consistencies for the 1-center tree ${\mathcal{T}}$ using visual primitives inspired by [65, 66]; see Fig. 8(middle). For the 1-center tree with vertex set $V$, multiple vertex consistency functions are defined with respect to $k$ ensemble members, $\alpha_{1},\cdots,\alpha_{k}:V\to{\mathbb{R}}$. Let $\bar{\alpha}$ be their mean value. Let $\alpha^{\prime}_{i}:=|\alpha_{i}-\bar{\alpha}|$, and we compute the sequence of variations $\{\alpha^{\prime}_{i},\dots,\alpha^{\prime}_{k}\}$ as deviations from the mean $\bar{\alpha}$. The radius $r_{i}$ of the $i$-th circular glyph is $r_{i}=\frac{g\alpha^{\prime}_{i}}{2\alpha^{\prime}}$ [66], where $g$ is the desired spacing between glyphs, and $\alpha^{\prime}$ is the maximum difference of any $\alpha_{i}$ to the mean of $\alpha$ in the entire ensemble. The smaller the glyphs are, the more consistent the ensemble members are with respect to the 1-center. A small core indicates few outliers whereas a wider core indicates more deviation within members [66]. In our system, variational consistencies are rendered in a sequential colormap using a single hue.

Inspired by box plots, we visualize the distribution of vertex consistencies at the 1-center ${\mathcal{T}}$. For $\alpha_{1},\cdots,\alpha_{k}$ defined at a vertex $v\in V$ of ${\mathcal{T}}$, we compute their minimum, first quartile, median, third quartile, and maximum and apply graduated glyphs, as shown in Fig. 8(right). In our system, statistical consistencies are rendered using a miscellaneous colormap. Finally, the vertex consistency can be extended to edge consistency, see Appx. B for details.

6 Interactive Visualization and Usage Scenarios

We provide an interactive visualization system that takes as input an ensemble of leaf-labeled merge trees and outputs a 1-center tree as their structural average. The system incorporates 1-center computation, animation and uncertainty visualization; see the supplementary video for a demo and Appx. A for implementation and Appx. C for design details. It is implemented using D3.js, Ajax, Flask, and Python.

Its user interface is shown in Fig. 7. The drawing panel allows the user to draw individual merge trees using node-link diagrams and assign initial labels to the vertices. Each tree is then added to the ensemble panel, where ensemble members can be selected, deleted and edited. The control panel provides various options in computing a 1-center tree, whereas an animated sequence between an input tree and the 1-center tree is provided within the animation panel. Various consistency measures are visualized in the consistency visualization panel; see Appx. C for design details.

We now describe how a user interacts with our visualization system under various usage scenarios. Thanks to consistency, a novel measure of uncertainty for vertices in a tree, our system helps the user perform tasks that were previously challenging. In particular, we can:

• •

Use the system as a structural calculator: it takes as input a set of leaf-labeled merge trees and outputs a 1-center tree as their structural average.

• •

Perform label diagnostics and correction to reduce data uncertainty and improve structural consistency.

• •

Understand structural similarities in a dynamic setting via animations from an ensemble member to the 1-center tree.

In addition, our system and its underlying algorithms allow us to study the tradeoff between local and global consistency measures in capturing structural similarities between ensemble members and their structural average, as well as to investigate heuristics in labeling strategies by exploring the tradeoff between intrinsic and extrinsic metrics (see Appx. D and Appx. E for examples).

6.1 Computing 1-Centers as Structural Averages

Suppose we have a numerical calculator. A typical usage scenario to obtain an average is to add a set of $k$ input numbers and divide the sum by $k$. We want to perform similar operations, not with numbers, but with complex structures such as merge trees.

As illustrated in Fig. A Structural Average of Labeled Merge Trees for Uncertainty Visualization, when a user provides as input an ensemble of six leaf-labeled merge trees in partial agreement (top row on the left), the system first applies a (re)labeling strategy to update unmatched labels among the ensemble members while preserving the matched labels (bottom row on the left). For instance, Tree 2 has three of its leaves relabeled based on their structural similarities to the pivot Tree 1. The labeling on the 1-center tree (a) shows leaf correspondences between the input and the output. The system incorporates uncertainty information on the 1-center tree: variations (b) and distributions (c) in vertex consistencies are encoded by graduated circular glyphs.

We explore the structural variations of the input ensemble via the summary plot (d), where all the ensemble members (in this particular input) have roughly the same interleaving distance to the 1-center (a). In the variational consistency plot (b), we see that there is a small variation in the vertex consistency measure around leaf 1 for the 1-center as indicated by a tiny blue circular glyph, which means that all six ensemble members are highly consistent in the local neighborhood of leaf 1. This is also captured by the statistical consistency plot (c) where the minimum, maximum, and medium consistency values coincide at leaf 1.

Using our visualization system, the user can perform computations and uncertainty visualization for trees in full agreement and disagreement in a similar fashion; see Fig. 5. For instance, the variational vertex consistency plot in Fig. 5(b) shows that all six input trees have almost no structural variation at leaves 1 and 4, whereas the distribution of vertex consistencies is much less concentrated at leaves 2 and 3 in the statistical consistency plot Fig. 5(c), which can be explained in the sense that leaf 1 and leaf 4 in each input tree all have a common lowest ancestor at the root with similar height values.

In summary, our system enables us to explore the structural variations between input trees and their 1-center by incorporating various means of consistency-based uncertainty visualization; see the supplementary video for a demo.

6.2 Label Diagnostics and Correction

Apart from the default functionality in computing a 1-center, perhaps more importantly, we could use our interactive tool to perform label diagnostics and correction to reduce data uncertainty among ensemble members and improve structural consistency.

We give an example in Fig. 9. The initial input provided by the user contains an ensemble of six leaf-labeled merge trees in partial agreement. Upon close inspection of the variational consistency plot, we notice that leaves $3$ and $4$ in the 1-center have high variations in their consistency (c). However, changing a (possibly inaccurate) label in Tree 4 from $3$ to $4$ greatly reduces the variational consistency of the 1-center at leaves $2$, $3$, and $4$, comparing (c) with (f). Meanwhile, such a correction also improves the statistical consistency, as shown in (g) where summary statistics (minimum, medium, etc.) coincide at these leaves; see the supplementary video for a demo. However, such a manual intervention is not practical for large merge trees. We believe the same strategy could be applied to a simplified merge tree on a coarser level. For larger trees, we leave it to future work to automatically identify outliers and suggest rules for modification.

6.3 Animation Along A Geodesic Path

Furthermore, we could understand structural similarities in a dynamic setting via animations. An animated sequence between an ensemble member and the 1-center shows how one deforms to the other via a geodesic (by Theorem 3.2), as well as the evolution of consistency measures at individual nodes through this process.

As shown in Fig. 10, a 10-step animation between an ensemble member (a) and a 1-center (b) with different leaf sizes showcases the structural changes between them; e.g., the creation of new internal vertices along the geodesic. We can also observe the increase in vertex consistencies (red means high and green means low consistency), in particular, for vertex $3$, along the same geodesic. See the supplementary video for a demo.

7 Application to Scalar Field Ensembles

Our framework can be applied to study the structural variation of an ensemble of scalar fields. We give two illustrative examples. The first example, Fig. 11, contains a pair of scalar fields that gives rise to a pair of merge trees very similar to Fig. 3 in Section 4.1. Each scalar field is visualized as a $150\times 150$ image in (a)-(b). We use the Topology ToolKit [72] to generate the augmented merge trees in (c)-(d). Noncritical points are ignored for the 1-center computation as we need only leaves and their lowest common ancestors to compute the ultra matrices. We employ the labeling strategy described in Section 4.3 to find correspondences between the leaves, by taking into consideration their geometric embeddings.

The second example in Fig. 12 begins with an ensemble of three merge trees that arise from scalar fields generated by mixtures of Gaussians. We again apply our algorithm in Section 4.3 to compute the 1-center tree. In this example, merge trees ${\mathcal{T}}_{1}$, ${\mathcal{T}}_{2}$, and ${\mathcal{T}}_{3}$ contain $3$, $4$, and $4$ leaves, respectively. According to Sec. 4.3, ${\mathcal{T}}_{2}$ (or ${\mathcal{T}}_{3}$) is selected as the pivot tree. We use the Euclidean distance between the geometric embeddings of leaves to assign labels. It is easy to verify that the computed 1-center tree ${\mathcal{T}}$ is indeed of equal distance to the ensemble members ${\mathcal{T}}_{1}$, ${\mathcal{T}}_{2}$, and ${\mathcal{T}}_{3}$, and therefore represents a structural average of the scalar field ensemble.

We now focus on uncertainty visualization using our encodings proposed in Sec. 5 and interactive visualization system in Sec. 6. As illustrated in Fig. 13, the vertex consistency plot (b) for ${\mathcal{T}}_{2}$ indicates that leaf $2$ has low consistency against the 1-center tree; similarly in the variational vertex consistency plot (d), leaf 2 in ${\mathcal{T}}$ has the highest variation whereas leaves 1, 3, and 4 have low variations across ensemble members. This can be explained as all three input trees share similar local structures surrounding leaves 1, 3, and 4.

In addition to our proposed uncertainty visualization, we could further investigate the scalar field that gives rise to a 1-center tree. Such a scalar field is certainly not unique, and we have reverse-engineered a candidate by carefully positioning the critical vertices on the 2D domain with radius basis functions, as shown in Fig. 11(h) and Fig. 12(k), respectively. It is part of our on-going work to reverse-engineer good scalar fields that give rise to a given 1-center tree using optimization techniques with various constraints.

8 Conclusion and Discussion

We provide an interactive visualization system that computes and visualizes a structural average of an ensemble of leaf-labeled merge trees. We develop a novel measure of uncertainty, referred to as consistency, via a metric space view of the input trees. This measure is flexible in allowing a local-global tradeoff in understanding structure variations. Our results are the first steps toward statistical analysis of as well as uncertainty visualization for an ensemble of complex topological descriptors such as merge trees.

There are many future directions. From an algorithmic perspective, we are interested in computing a 1-center that is robust to outliers, or an effective algorithm to compute 1-mean/1-median. We also want to have a systematic investigation of various heuristic labeling algorithms. We are investigating ways to extend our framework to compute 1-center contour trees; as a contour tree of a function $f$ can be constructed by carefully combining merge trees of $f$ and $-f$. From a visualization perspective, we will evaluate the effectiveness of various visual encodings for consistency measures, as well as the visualization of 1-center trees at scale. We will also explore other applications of the animation between merge trees, e.g., in studying shape morphologies in computer graphs.

Finally, we hope that our visualization framework could help enhance topology- and geometry-based modern tools (e.g., [43, 38]) in neuron morphology analysis for biologists; see Appx. F for an example. We are also working on helping simulation scientists to take advantage of our framework in detecting abnormalities and outliers within simulation ensembles.

Acknowledgements.

YW was partially supported by NSF CCF-1740761, RI-1815697, DMS-1547357, and NIH R01EB022899. EM was partially supported by NSF CCF-1907591 and CMMI-1562012. LY and BW were partially supported by NSF DBI-1661375, IIS-1513616 and NIH 1R01EB022876. We thank participants of Dagstuhl Seminar 17292: Topology, Computation and Data Analysis in July 2017 for stimulating discussions on Reeb graphs. We are grateful to the Institute for Computational and Experimental Research in Mathematics (ICERM) for supporting us through the Collaborate@ICERM program in August 2018. Youjia Zhou created the reverse-engineered scalar fields in Figs. 12 and 13.

Appendix A From Leaf-Labeled to Labeled Merge Trees

As consequences of the algorithms in Section 4, we arrive at an ensemble of (updated) leaf-labeled merge trees together with their 1-center, which are in full agreement with respect to a shared leaf label set $S$. For visual embeddings and animations (Sec. 6), we need to further infer a 1-to-1 correspondence between internal vertices between ${\mathcal{T}}^{i}$ and ${\mathcal{T}}$ for each $i$. That is, we infer a complete labeling for internal vertices. Our algorithm is as follows:

• S1.

Transform ${\mathcal{T}}$ into a pivot tree ${\mathcal{T}}^{p}$. Let $S_{p}$ be its label set.

• S2.

For each element ${\mathcal{T}}^{i}$, update its labeling using $S_{p}$.

We give a toy example in Figure 14.

In Step S1, we select a tree ${\mathcal{T}}^{j}$ with the largest number of vertices. If ${\mathcal{T}}^{j}={\mathcal{T}}$, then ${\mathcal{T}}^{p}:={\mathcal{T}}$. Otherwise, add dummy vertices to $T$ with respect to $T^{j}$ so that it becomes a tree $T^{\prime}$ with the largest number of vertices, therefore transforming ${\mathcal{T}}=(T,f,\omega)$ into a pivot tree ${\mathcal{T}}^{p}=(T_{p},f_{p},\omega_{p})$, where $\omega_{p}:S_{p}\to V$ is an extension of $\omega:S\to L$ that is surjective on the vertices.

In Step S2, we run the algorithm for trees in partial agreement (Sec. 4.2) so that each ${\mathcal{T}}^{i}$ is updated to be ${\mathcal{T}}^{i^{\prime}}=(T_{i},f_{i},\omega^{\prime}_{i})$, where $\omega^{\prime}_{i}:S_{p}\to V_{i}$ is surjective on its vertices.

Appendix B Uncertainty Visualization: Edge Consistency

Edge consistency. The vertex consistency can be extended to edge consistency. For a vertex consistency function $\alpha:V\to{\mathbb{R}}$ defined on the vertex set $V$ of ${\mathcal{T}}$, it can be extended to be an edge consistency function using piecewise-linear (PL) $\beta^{PL}:|E|\to{\mathbb{R}}$ or piecewise-constant (PC) $\beta^{PC}:|E|\to{\mathbb{R}}$ interpolations in the usual way. For instance, the PC interpolation of $\alpha$ on an edge takes the minimum value of the two vertex consistencies.

Vertex and edge consistencies for an ensemble member. We encode edge consistency for an ensemble member ${\mathcal{T}}^{i}$ (with respect to the 1-center ${\mathcal{T}}$) using glyphs, as in Fig. 15.

The width of each line (resp. ribbon) glyph at a location $x\in e$ for $e\in E_{i}$ scales proportionally with the PC (resp. PL) edge consistency at $x$, $\beta^{PC}(x)$ (resp. $\beta^{PL}(x)$).

Variational consistencies for the 1-center tree. We encode variations in edge consistencies for the 1-center tree ${\mathcal{T}}$ using visual primitives inspired by [65, 66], as in Fig. 16, similarly to variations in vertex consistencies.

Statistical consistency for the 1-center tree. Inspired by box plots, we visualize the distribution of edge consistencies at the 1-center ${\mathcal{T}}$ similarly to the statistical vertex consistencies, see Fig. 17.

Appendix C Interactive Visualization System Design Details

We provide design details of our interactive visualization system. Its user interface is shown in Fig. 7.

Drawing Panel and Ensemble Panel. The drawing panel allows the user to draw individual merge trees using node-link diagrams and assign initial labels to the vertices. Each tree is created with an embedding onto the drawing panel, where each vertex $v$ is equipped with a coordinate $(v_{x},v_{y})$ and a height function value $f(v)$ according to the panel’s underlying grid structure. Using various hot keys (see for a user manual), an embedding can be geometrically reconfigured via insertion, deletion and movement of vertices and edges. At the moment, the system focuses on leaf-labeled merge trees, therefore only the labels on the leaves are used in the computation. Each tree is then added to the ensemble panel, where ensemble members can be selected, deleted and reconfigured/edited .

Control Panel and 1-center computation. With an input ensemble of leaf-labeled merge trees, we compute its 1-center using various options above the control panel. Using the Enforce label option, we compute a 1-center of trees in full or partial agreement, whereas the Ignore label option enables one to deal with trees in disagreement.

In terms of the parameter setting, we can choose between Tree distance $d_{T}$ and Euclidean distance $d_{E}$, or a linear combination of the two, using the $\bm{\lambda}$ parameter for our heuristic labeling strategies. $\bm{\delta}$ is the locality parameter in consistency measures and $\#\textbf{steps}$ indicates the number of steps used in the animation.

The control panel also visualizes the relation between the 1-center (denoted as a red node labeled AMT) and the ensemble members in a star-shaped summary plot, where the 1-center lies in the center of the star, and the color and length of each link scales proportionally with the interleaving distance between an input tree and the 1-center. By clicking on a link in the summary plot, we enable an animated sequence between an input tree and the 1-center.

Animation. We compute and visualize an animated sequence between an input tree (as the source) and the 1-center (as the target) using two strategies. The geodesic strategy follows Theorem 3.2, where intermediate trees follow a geodesic connecting the source and the target pair. The linear strategy linearly interpolates between geometric embeddings of the source and the target.

During the animation, the intermediate trees can be displayed with labels , which highlight correspondences between leaves. The intermediate trees can also use colored labels according to vertex consistencies, for which the animated sequence highlights the changes in vertex consistency as a source tree is moved towards a target tree. In summary, the animation highlights structural variations between an input tree and the 1-center, and the evolution in vertex consistency during such a process.

Consistency Visualization. We visualize various consistency measures in the rightmost panel. First, we visualize vertex and edge consistency for each ensemble member with respect to the 1-center, using circular , linear and ribbon glyphs . Second, we visualize variational consistencies for the 1-center using graduated glyphs with sequential colormap of a single hue. We use graduated circular glyphs for vertices, graduated lines and graduated ribbons for PC and PL edges, respectively. Finally, we highlight statistical consistencies for vertices , PC edges , and PL edges that capture the distribution of consistency measures across ensemble members. In addition, all trees can be visualized with labels to indicate leaf correspondences between input and output.

1-Center tree visualization. Since each input tree ${\mathcal{T}}^{i}$ is drawing with a geometric embedding $\iota_{i}:|T_{i}|\to{\mathbb{R}}^{2}$, we compute an embedding $\iota$ of the 1-center ${\mathcal{T}}$ using information from $\iota_{i}$ for all $1\leq i\leq k$. First we apply the algorithm in Sec. 4 and Appx. A to infer a complete correspondence between the internal vertices of ${\mathcal{T}}^{i}$ and ${\mathcal{T}}$ for each $i$. Then, for each vertex $v\in V$ with a label $l$, we compute its embedding $\iota(v)\mapsto(x_{v},y_{v})$. $y_{v}$ comes naturally as $y_{v}=f(v)$. $x_{v}$ is the 1-center of the x-coordinates of $\{\iota_{1}(\omega_{1}(l)),\cdots,\iota_{k}(\omega_{k}(l))\}$.

Appendix D Local-Global Tradeoff

We could also use our system to study the tradeoff between local and global consistency measures in capturing structural similarities between ensemble members and their structural average. As we increase the locality parameter $\delta$ in the Gaussian-weighted cosine similarity measure, we could observe the change in structural variations on vertices; see Fig. 18 for an example. Using the same input ensemble as Fig. 9, we see that as $\delta$ increases, the variational vertex consistency decreases (top) as we pay more attention to global structural similarities among the ensemble members. Meanwhile, the distribution of consistency measures becomes increasingly concentrated (bottom). See the supplementary video for a demo.

Appendix E Intrinsic-Extrinsic Tradeoff

The input merge trees can have natural (function-induced) intrinsic metrics associated to them. Sometimes, these trees are geometric (i.e., embedded in Euclidean spaces), and thus also have natural extrinsic (ambient) metrics defined on them, e.g., in the case of neuron trees modeling neuron cells. Our tool supports a combination of both metrics. See the supplementary video for a demo.

Fig. 19 shows that using purely Euclidean distance vs. purely tree distance gives different new labels for Tree 2 and Tree 3 and thus affects the resulting 1-center as well as its statistical consistency. The results using a linear combination of both Euclidean and tree distance for $\lambda=0.5$ are very similar to those based on pure tree distance, with minor differences visible for the 1-center trees and their statistical consistency plots.

Appendix F Applications in Neuron Morphology

Neuron cells have tree morphology, and a rapidly increasing amount of neuroanatomical data are now publicly available (e.g., NeuroMorpho.org and flycircuit.org). Our proposed consistency measure can be used to understand structural variations among an ensemble of neuron cell induced merge trees with respect to their 1-center.

As a case study, we use our proposed methodologies to help study differences/variations among different reconstructions of the same neuron cell. In particular, in the past 15 years, a large number of algorithms have been developed to reconstruct a tree structure for neuron cells (referred to as neuron trees) from 2D or 3D images (e.g., the dozens of methods incorporated in the visualization software Vaa3D [53]).

Input trees. We use one of the olfactory projection fibers datasets, referred to as ${\rm{\bf OP\_6}}$, from the DIADEM challenge [9]. We create a set of neuron trees reconstructed for ${\rm{\bf OP\_6}}$ using different reconstruction methods. Each neuron tree comes with a 3D embedding in the form of a 3D image. Given an image of a neuron tree, we extract its corresponding (unlabeled) merge tree representation as a pair ${\mathcal{T}}^{i}=(T_{i},f_{i})$. First, the vertex set $V_{i}$ is obtained by extracting the leaves and branching points from the 3D image; each vertex is equipped with a geometric location via the 3D embedding of the neuron tree. The function $f_{i}:V_{i}\to{\mathbb{R}}$ is the geodesic distance of a vertex $x\in V_{i}$ to a base point $o\in V_{i}$ (chosen as the physical root of the neuron cell). This extracted merge tree is referred to as the neuron cell induced merge tree.

Analysis. Fig. 20 shows three neuron cell induced merge trees for dataset ${\rm{\bf OP\_6}}$ via reconstruction algorithms APP2 [79] (h), SmartTracing [18] (f) and NeuroGPS-Tree [63] (c), as well as their 1-center tree (a). The vertices for each input tree are colored by their consistencies. The input trees are reasonably similar; thus, to see the structural variation, we use a relatively small $\delta=0.05$ value when computing consistency.

Meanwhile, each vertex of the 1-center tree is visualized with a variational consistency using graduated circular glyphs; see Fig. 20 (c,f,h). It is therefore easy to spot which vertices in the 1-center tree have high variance. Upon close inspection, each high variance vertex in the 1-center tree indeed corresponds to locally different reconstructions in input trees (e,g,i). Similarly, from each individual input tree, it is easy to see how each vertex deviates from the 1-center tree locally. For example, vertices from the region in the black rectangle of NeuroGPS-Tree have low consistency (white to green colors) with respect to the 1-center tree (e). Indeed, as the inset zoomed-in view shows (e), NeuroGPS-Tree produces a different local tree configuration (one with a severely bended branch) as the output of APP2 (i) and SmartTracing (g). We also remark that as we increase the $\delta$ value, the consistency measures similarity at a more global level and thus the structural variation becomes less visible. Finally, we can also show consistency along edges of input trees, which could help to make low-consistency regions more prominent to spot than the vertex consistency visualization. See Fig. 20(d) for an example. A detailed methodological development for neuron trees is left for future work.