Approximating the Directed Hausdorff Distance

TL;DR

The paper addresses the problem of computing the directed Hausdorff distance between finite point sets in metric spaces with bounded doubling dimension, where naïve approaches are quadratic. It introduces preprocessing of each input set into greedy trees, enabling a $(1+\varepsilon)$-approximation of $\mathbf{d}_h(A,B)$ in time $\left(2+\frac{1}{\varepsilon}\right)^{O(d)}\,n$ after an $O(n\log Δ)$ preprocessing, with $Δ$ the spread and $d$ the doubling dimension. The framework extends to all $k$-partial directed Hausdorff distances $\mathbf{d}_h^{(k)}(A,B)$ with the same preprocessing and linear postprocessing, and provides a linear-time method to output the entire distance sequence for all $k$. An application to metric multidimensional scaling demonstrates amortizing the preprocessing over many distance computations, yielding practical speedups over traditional nearest-neighbor-based approaches. Overall, the work delivers a principled, preprocessing-based pipeline for fast approximate directed Hausdorff computations in doubling metrics, with concrete time bounds and extensions to outlier-robust variants.

Abstract

The Hausdorff distance is a metric commonly used to compute the set similarity of geometric sets. For sets containing a total of $n$ points, the exact distance can be computed naïvely in $O(n^2)$ time. In this paper, we show how to preprocess point sets individually so that the Hausdorff distance of any pair can then be approximated in linear time. We assume that the metric is doubling. The preprocessing time for each set is $O(n\log Δ)$ where $Δ$ is the ratio of the largest to smallest pairwise distances of the input. In theory, this can be reduced to $O(n\log n)$ time using a much more complicated algorithm. We compute $(1+\varepsilon)$-approximate Hausdorff distance in $(2 + \frac{1}{\varepsilon})^{O(d)}n$ time in a metric space with doubling dimension $d$. The $k$-partial Hausdorff distance ignores $k$ outliers to increase stability. Additionally, we give a linear-time algorithm to compute directed $k$-partial Hausdorff distance for all values of $k$ at once with no change to the preprocessing.

Figures (11)

• Figure 1: In this figure we compute the greedy permutation and predecessor mapping on a finite metric space $(\{a,b,c,d\}, \mathbf{d})$ with seed $a$ and $\alpha=2$. The dotted lines indicate parents. The darker dotted line highlights the point furthest from its parent. The solid lines indicate predecessors. Initially only $a$ is inserted and it is the parent of every uninserted point. When $c$ is inserted, it becomes the new parent of $d$ because $\alpha\mathbf{d}(c,d) < \mathbf{d}(a,d)$. The parent of $b$ is still $a$ even though $c$ is closer. Then, the insertion of $b$ does not change the parent of $d$ because $c$ is still an $\alpha$-approximate nearest neighbor. The completed permutation is $(a,c,b,d)$ and the predecessor map is $b \mapsto a, c \mapsto a, d \mapsto c$.
• Figure 2: In this figure, a ball tree is computed for a given permutation and predecessor pairing. The permutation $(a,b,c,d,e,f)$ is depicted with arrows representing a predecessor mapping at the top. The tree is constructed incrementally in the middle. Each new point creates two new nodes. The centers of newly inserted nodes are show below the nodes. The completed tree is shown at the bottom. The center of each node is depicted below it. There may be multiple nodes with the same center.
• Figure 3: This figure shows a greedy tree and the first four iterations of its radius-order traversal. The center of every node is shown below the node in the first figure. In this tree $\mathsf{ctr}(u_0) = \mathsf{ctr}(u_1) = \mathsf{ctr}(u_2)$ but $\mathsf{rad}(u_0) \ne \mathsf{rad}(u_1) \ne \mathsf{rad}(u_2)$. Also, $\mathsf{pts}(u_0) = \{a,b,c,d,e,f\}$ while $\mathsf{pts}(u_1) = \{a,d\}$ and $\mathsf{pts}(v) = \{b,c,e,f\}$. The heap is initialized with $u_0$. In each iteration, the node with the largest radius is replaced by its children. The complete order of traversal is $u_0, v_0, u_1, v_1, w_0$.
• Figure 4: The the nodes $y_2$ and $y_3$ are too far away to contain the nearest neighbor of any point in $x$, so edges $(x,y_2)$ and $(x,y_3)$ can be pruned from the viability graph. The pruning condition respects the neighbor invariant and does not prune edge $(x,y_4)$.
• Figure 5: This figure illustrates pruning in an iteration of Hausdorff. At the top, the node ${x_0}$ is connected to nodes ${y_1}, {y_2}, {y_3}$, and ${y_4}$. When ${x_0}$ is split and replaced by its children (middle image), edges are added between the new node ${x_1}$ and the neighbors of its parent. Then, at the bottom, the edges that are too long are pruned using the pruning condition. In this case, $({x_1}, {y_3})$ and $({x_1}, {y_4})$ are pruned.

Theorems & Definitions (8)

• Lemma 1: Standard Packing Lemma
• Theorem 1
• Lemma 2
• Lemma 3
• Theorem 4
• Lemma 7
• Lemma 8
• Theorem 9