Searching edges in the overlap of two plane graphs

TL;DR

This paper introduces an efficient O(n log n) preprocessing technique for pairs of plane graphs with red and blue edges, enabling fast intersection searches and solving several geometric problems with improved algorithms.

Contribution

The paper presents a novel O(n log n)-time preprocessing method for red-blue plane graph pairs, enabling efficient geometric computations and improving existing algorithms.

Findings

Efficient intersection search among red-blue edges in O(n log n) time.

New algorithms for maximum vertical distance between 3D terrains and Hausdorff Voronoi diagrams.

Improved solutions for the farthest-color Voronoi diagram and stabbing circle problems.

Abstract

Consider a pair of plane straight-line graphs, whose edges are colored red and blue, respectively, and let n be the total complexity of both graphs. We present a O(n log n)-time O(n)-space technique to preprocess such pair of graphs, that enables efficient searches among the red-blue intersections along edges of one of the graphs. Our technique has a number of applications to geometric problems. This includes: (1) a solution to the batched red-blue search problem [Dehne et al. 2006] in O(n log n) queries to the oracle; (2) an algorithm to compute the maximum vertical distance between a pair of 3D polyhedral terrains one of which is convex in O(n log n) time, where n is the total complexity of both terrains; (3) an algorithm to construct the Hausdorff Voronoi diagram of a family of point clusters in the plane in O((n+m) log^3 n) time and O(n+m) space, where n is the total number of points in all clusters and m is the number of crossings between all clusters; (4) an algorithm to construct the farthest-color Voronoi diagram of the corners of n axis-aligned rectangles in O(n log^2 n) time; (5) an algorithm to solve the stabbing circle problem for n parallel line segments in the plane in optimal O(n log n) time. All these results are new or improve on the best known algorithms.

Full text

1 Introduction

Many geometric algorithms have subroutines that involve investigating intersections between two plane graphs, often assumed being colored red and blue respectively. Such subroutines differ in the questions that are asked about the red-blue intersections. The most well-studied questions are to report all red-blue intersections or to count them. It is shown how to report all the intersections in optimal $O(n\log{n}+k)$ time and $O(n)$ space [3, 4, 15, 16, 19], where $n$ is the total complexity of both graphs, and $k$ is the size of the output. Note that $k$ may be $\Omega(n^{2})$. Counting the red-blue intersections can be carried out in $O(n\log{n})$ time and $O(n)$ space [4, 16].

In this paper, we consider the situation where one wants to search the red-blue intersections, though avoiding to compute all of them. Problems of this type appear as building blocks in diverse geometric algorithms. The latter include: distance measurement between polyhedral terrains [4], motion planning [12], construction of various generalized Voronoi diagrams (divide-and-conquer [9, 6] or randomized incremental [5] construction). Therefore solving such problems efficiently is of high importance.

Often it is guaranteed that each red edge contains at most one sought red-blue intersection, and an oracle is provided, that, given a red-blue intersection, is able to quickly determine to which side of that intersection the sought intersection lies along the same red edge (see Section 3.1 for more details on this setting). A particular case, when the red graph consists of a unique edge, appeared under the name of segment query in the randomized incremental construction algorithm for the Hausdorff Voronoi diagram [5], and under the name of find-change query in an algorithm to solve the stabbing circle problem for a set of line segments [8]. If the blue graph is a tree, it can be preprocessed in $O(n\log{n})$ time using the centroid decomposition [2, 5]. Centroid decomposition supports segment (or find-change) queries for arbitrary line segments, requiring only $O(\log n)$ queries to the oracle [5, 7]. If the blue graph is not a tree, then in $O(n\log{n})$ time it can be preprocessed for point location, and a nested point location along the red edge is performed, which requires $O(\log^{2}n)$ queries to the oracle [6, 8]. For two general plane straight-line graphs (where the red graph is not necessarily one edge) the problem is called batched red-blue intersection problem (see Problem 2). It was formulated in Dehne et al. [9], and solved in $O(n\log^{3}{n})$ time and $O(n\log^{2}{n})$ space [9] using hereditary segment trees [4]. However, this is optimal in neither time nor space.

We present a data structure that provides a clear interface for efficient searches for red-blue intersections along a red edge. Our data structure can be used to improve the above result [9] (see Section 3.1), which includes an improvement on segment (or find-change) queries in plane straight-line graphs. Our data structure can also handle more general search problems, e.g., a setting when a red edge may have more than one sought red-blue intersection on it. Below we state our result and its applications.

1.1 Our result

Let $R$, $B$ be a pair of plane straight-line111Our technique can be trivially generalized to apply to $x$-monotone pseudoline arcs in place of straight-line edges of the graphs. graphs. We address the following problem.

Problem 1 (RB-Preprocessing problem)

Given graphs $R,B$, construct a data structure that for each edge $e$ of $R$ stores implicitly the intersections between $e$ and the edges of $B$ sorted according to the order, in which these intersections appear along $e$. Let $T_{e}$ be a perfectly balanced binary search tree built on the sorted sequence of intersections along $e$. The data structure should answer efficiently the following navigation queries in $T_{e}$:

• •

Return the root of $T_{e}$;

• •

Given a non-root node of $T_{e}$, return the parent of this node;

• •

Given a non-leaf node of $T_{e}$, return the left (or the right) child of this node.

We provide a solution to the RB-Preprocessing problem, where each of the navigation queries can be answered in $O(1)$ time, and constructing the data structure requires $O(n\log n)$ time and $O(n)$ space, where $n$ is the total number of vertices and edges in both $R$ and $B$ (see Section 2).

The resulting data structure allows for fast searches for interesting intersections between edges of $R$ and the ones of $B$. We note that the notion of interesting is external to the data structure: It is not known at the time of preprocessing, but rather guides the searches on the data structure after it is built. In particular, for the input graphs $R$ and $B$, the data structure is always the same, while interesting intersections can be defined in several ways, which of course implies that the searches may have different outputs.

Our preprocessing technique can be applied to a number of geometric problems. We provide a list of applications, which is not exhaustive. For each application, we show how to reduce the initial problem to searching for interesting red-blue intersections, and how to navigate the searches, that is, how to decide, which subtree(s) of the current node of the (implicit) tree to search. Using our technique we are able to make the contributions listed below, and we expect it to be applicable to many more problems.

The batched red-blue search problem [9] for a pair of segment sets can be solved in $O(n)$ space and $O(n\log{n})$ queries to the oracle, where $n$ is the total number of segments in both sets (see Section 3.1). The problem is as follows. Given are: (1) two sets of line segments in the plane (colored red and blue, respectively), where no two segments in the same set intersect; and (2) an oracle that, given a point $p$ of intersection between a red segment $r$ and a blue segment $b$, determines to which side of segment $r$ with respect to point $p$ the interesting red-blue intersection lies. It is assumed that each segment contains at most one interesting intersection. The batched red-blue search problem is to find all interesting red-blue intersections. Our solution is an improvement on the one of Dehne et al. [9] which requires $O(n\log^{2}{n})$ space and $O(n\log^{3}{n})$ queries to the oracle. 2. 2.

The maximum vertical distance between a pair of polyhedral terrains, one of which is convex, can be computed in $O(n\log{n})$ time and $O(n)$ space (see Section 3.2). Previously, a related notion of the minimum vertical distance between a pair of non-intersecting polyhedral terrains was considered, and it was shown how to find it in $O(n^{4/3+\epsilon})$ time and space for a pair of general polyhedral terrains [4], in $O(n\log{n})$ time for one convex and one general terrain [24], and in $O(n)$ time for two convex terrains [24]. Our technique yields an alternative solution for the second case within the same time bound as in [24]. The maximum distance for non-intersecting polyhedra can be found by the above methods [4, 24], however it is different from the minimum distance for intersecting polyhedra: asking about the former is still interesting, while the latter is trivially zero. 3. 3.

The Hausdorff Voronoi diagram of a family of point clusters in the plane can be constructed in $O((n+m)\log^{3}{n})$ time, where $m$ is the total number of pairwise crossings of the clusters (see Sections 3.3 and 4). Parameter $m$ can be $\Theta(n^{2})$, but is small in practice [21, 20]. There is a deterministic algorithm to compute the diagram in $O(n^{2})$ time [11]. All other known deterministic algorithms [20, 21] have a running time that depends on parameters of the input, that cannot be bounded by a function of $m$.222 The algorithms have time complexity respectively $O(M+n\log^{2}n+(m+K)\log n)$ and $O(M^{\prime}+(n+m+K^{\prime})\log n)$, where parameters $M,M^{\prime},K,K^{\prime}$ reflect the number of pairs of clusters such that one is enclosed in a certain type of enclosing circle of the other. Each of them may take $\Omega(n^{2})$ time even if $m=0$. There is a recent randomized algorithm with expected time complexity $O((m+n\log n)\log n))$ [14]. For a simpler case of non-crossing clusters ($m=0$), the diagram can be computed in deterministic $O(n\log^{5}{n})$ time333The time complexity claimed in [9] is $O(n\log^{4}{n})$. See the discussion in Section 3.3. [9], or in expected $O(n\log^{2}{n})$ time [5, 14]. Thus our algorithm is the best deterministic algorithm for the case of small number of crossings. The time complexity of our algorithm is subquadratic in $n$ and $m$ and depends only on them, unlike any previous deterministic algorithm. 4. 4.

The farthest-color Voronoi diagram for a family of $n$ point clusters, where each cluster is all the corners of an axis-aligned rectangle,444A cluster is either the four corners of a non-degenerate axis-aligned rectangle, or the two endpoints of a horizontal/vertical segment, or a single point. and these rectangles are pairwise disjoint, can be computed in $O(n\log^{2}{n})$ time and $O(n)$ space (see Section 3.4). Previous results on the topic are as follows. For arbitrary point clusters, the diagram may have complexity $\Theta(n^{2})$ and can be computed in $O(n^{2})$ time and space [1, 11], where $n$ is the total number of points in all clusters. When clusters are pairs of endpoints of $n$ parallel line segments, the diagram has $O(n)$ complexity and can be constructed in $O(n\log{n})$ time and $O(n)$ space [8]. In this paper, we broaden the class of inputs, for which the diagram can be constructed in subquadratic time. We also show that the complexity of the diagram for such inputs is $O(n)$. 5. 5.

The stabbing circle problem for line segments in the plane can be solved in time $O(\mathcal{T}_{\textup{{HVD}}(S)}+\mathcal{T}_{\textup{{FCVD}}(S)}+(|\textup{{HVD}}(S)|+|\textup{{FCVD}}(S)|+m)\log n)$, where $|\textup{{HVD}}(S)|$ and $|\textup{{FCVD}}(S)|$ denote respectively the complexity of the Hausdorff and the farthest-color Voronoi diagram of the pairs of endpoints of segments in $S$, $\mathcal{T}_{\textup{{HVD}}(S)}$ and $\mathcal{T}_{\textup{{FCVD}}(S)}$ denote the time to compute these diagrams, and $m$ is a parameter reflecting the number of “bad” pairs of segments in $S$555See Section 3.5 for the definition of $m$. (See Section 3.5). If all segments in $S$ are parallel to each other, the stabbing circle problem can be solved in optimal $O(n\log{n})$ time and $O(n)$ space. This is an improvement over the recent $O(\mathcal{T}_{\textup{{HVD}}(S)}+\mathcal{T}_{\textup{{FCVD}}(S)}+(|\textup{{HVD}}(S)|+|\textup{{FCVD}}(S)|+m)\log^{2}n)$ time technique for general segments, which yielded an $O(n\log^{2}{n})$ time algorithm for parallel segments [8].

2 The technique to preprocess a pair of graphs

Suppose we are given two plane straight-line graphs $R$ and $B$, and let $n$ be the total number of vertices and edges in both $R,B$. We assume that no two vertices of the graphs have the same $x$ coordinate. In this section, it is more convenient to treat $R$ and $B$ as two sets of line segments in the plane, where the segments in $R$ are colored red, and the ones in $B$ are colored blue. No two segments of the same color intersect, although they may share an endpoint.

Our preprocessing technique consists of three phases. In the first phase, we invoke an algorithm that finds the intersections between the edges of the two graphs (see Section 2.1). After that, in the second phase, we build a linearized life table for the red segments (see Section 2.2). Finally we sweep the life table with a line, which provides us the resulting data structure (see Section 2.3).

2.1 Finding red-blue intersections

For the sets $R$ (red) and $B$ (blue), we need to find all the intersections between segments of different color, i.e., all the red-blue intersections.

It is known how to count the red-blue intersections in optimal $O(n\log{n})$ time [4, 16, 19], or report them in optimal $O(n\log{n}+k)$ time [3, 4, 15, 16, 19], where $k$ is the total number of the intersections. The space requirement of each of these algorithms is $O(n)$. The algorithm by Mantler and Snoeyink [16] processes the red-blue intersections in batches (called bundle-bundle intersections). In $O(n\log{n})$ time and $O(n)$ space it can implicitly discover all the red-blue intersections, without reporting every one of them individually. The latter feature is useful for our technique, therefore we invoke the Mantler-Snoeyink algorithm in its first phase. We summarize the algorithm below.

To describe the algorithm, we need to define the following key notions: the witness of a (bichromatic) segment intersection, a pseudoline at time $i$, and a (monochromatic) bundle of segments at time $i$.

Given a red segment $r$ that intersects a blue segment $b$, the witness of their intersection is the leftmost of the endpoints of segments in $S$ that are contained in the closed right wedge formed by $r$ and $b$. The closed right wedge formed by $r$ and $b$ is the intersection of two closed right halfplanes: the one bounded by the line through $r$, and the one bounded by the line through $b$, see the shaded area in Figure 1. Note that the witness always exists: it may be an endpoint of a segment different from $r$ or $b$ (as in Figure 1), or it may be an endpoint of either $r$ or $b$.

Let $n^{\prime}$ be the total number of distinct endpoints of the segments in $R$ and $B$. Let $p_{1},p_{2},\ldots,p_{n^{\prime}}$ denote the sequence of these endpoints in the order of increasing $x$ coordinate. The basis of the Mantler-Snoeyink algorithm can be formulated as follows.

Lemma 1

For each $i,1\leq i\leq n^{\prime}$ there is a $y$-monotone curve $\ell_{i}$ that passes through point $p_{i}$, and subdivides the plane into two open regions (the left and the right one), such that all the points $p_{j},j<i$, and all the red-blue intersections witnessed by the points $p_{j},j\leq i$ are contained in the left region, and all the points $p_{k},k>i$ together with the intersections witnessed by them are contained in the right region, and $\ell_{i}$ intersects each segment in $R$ or in $B$ at most once.

We call such curve $\ell_{i}$ a pseudoline at time $i$. Figure 2 shows a pseudoline at time 7, i.e., $\ell_{7}$, in dashed black lines. Note that $\ell_{7}$ cannot be replaced by a vertical straight line, because it must pass through the point 7, and to the left of the intersection point between the segments $r_{4}$ and $b_{4}$, and the latter point lies to the left of the former one.

A blue bundle at time $i$ is a maximal contiguous sequence of blue segments that intersect the pseudoline $\ell_{i}$.666This definition can be seen as a generalization of the one of single-edge bundles in Mount [18]. See Figure 2, right. A red bundle is defined analogously.

The algorithm can be seen as a topological sweep with a pseudoline, where the only events are the endpoints $p_{1},\ldots,p_{n^{\prime}}$ of the segments in $R$ and $B$. The sweepline at each moment $i$ is a pseudoline $\ell_{i}$ such as defined in Lemma 1. The sweepline status structure maintains all the red and blue bundles that intersect the current sweepline. The sweepline status consists of (1) a balanced binary tree for each bundle, supporting insertion, deletion of segments, and a query for the topmost and the bottommost segment in the bundle, (2) a doubly-linked list for all the bundles intersecting the sweepline (bundles alternate colors), supporting insertion, deletion of the bundles, and sequential search, and (3) two balanced binary trees (one per color) storing all the red and blue bundles in order, and supporting splitting and merging of bundles.

At the event point $p_{i}$ the algorithm processes the intersections witnessed by $p_{i}$, updates the sweepline from $\ell_{i-1}$ to $\ell_{i}$, and makes the necessary changes to bundles (i.e., splits or merges them). By proceeding this way, the algorithm maintains the invariant that all the red-blue intersections whose witness is to the left of the current event point $p_{i}$ are already encountered. We summarize the result in the following.

Theorem 2.1 ([16])

The Mantler-Snoeyink algorithm runs in $O(n\log{n})$ time, requires $O(n)$ space, and encounters $O(n)$ bundle-bundle intersections in total.

2.2 Building the life table

In this section we describe our algorithm to build the life table for the sets $R$ and $B$. Figure 2 illustrates the execution of the algorithm for a simple example.

Before we start our description, recall [10] that every pointer-based data structure with constant in-degree can be transformed into a partially persistent one. Such a persistent data structure allows accessing in constant time the data structure at any moment in the past, and performing pointer operations on it (but not modifying it); the total time and space required to make a data structure partially persistent is linear in the number of structural changes it underwent.

To build the life table for $R$ and $B$, we first perform the Mantler-Snoeyink plane sweep algorithm (see Section 2.1), making the sweepline status structure partially persistent. This ensures that each blue bundle that has appeared during the algorithm, can afterwards be retrieved from the version of the sweepline status at the corresponding moment in the past. In particular, we are interested in the blue bundles that intersect red bundles. We assign each such blue bundle $B_{i}$ a timestamp $t_{i}$ reflecting the moment when the first bundle-bundle intersection involving $B_{i}$ was witnessed. In order to distinguish between two different bundle-bundle intersections discovered at the same moment $t_{k}$ (i.e., witnessed by the same point), we assign the moment $t_{k}+\epsilon$ to the intersection that has smaller $y$ coordinate. Figure 2, right, lists all such blue bundles for the given example.

Observe that the plane sweep algorithm induces a partial order among the red segments: At any moment, the red segments crossed by the sweepline can be ordered from bottom to top. Since the red segments are pairwise non-intersecting, no two segments may swap their relative position. Let $r_{1},\ldots,r_{n}$ be a total order consistent with the partial order along the sweepline at each moment. In Figure 2, the red segments are named according to such an order.

We now build the life table of red segments and blue bundles, see Figure 2, bottom. The life table is a graph defined as follows. On its $y$ axis it has integers from [math] to $n_{R}$, where $n_{R}$ is the number of red segments; the $x$ axis of the life table coincides with the $x$ axis of the original setting, i.e., of the plane $\mathbb{R}^{2}$. Each red segment $r_{i}$ is represented by a horizontal line segment whose $y$ coordinate equals $i$ and whose endpoints’ $x$ coordinates coincide with the $x$ coordinates of the endpoints of $r_{i}$. Each blue bundle $B_{j}$, that has participated in at least one bundle-bundle intersection, is retrieved from the version of the sweepline status at the moment $t_{j}$ when the first such intersection has been witnessed; $t_{j}$ is the timestamp of $B_{j}$. In the table, $B_{j}$ is represented by a vertical line segment (that could possibly be a point), whose $x$ coordinate is $t_{j}$. This vertical segment intersects exactly the segments representing all red segments intersected by bundle $B_{j}$ (i.e., the segments of the red bundle(s) participating in the bundle-bundle intersection(s) with $B_{j}$). In particular, the bottom and the top endpoints of this segment lie respectively on the two red segments that represent the first and the last segment in $R$ intersected by bundle $B_{j}$, according to the topological ordering of the red segments. If $B_{j}$ intersects only one red segment, then in the life table $B_{j}$ is represented by a point. In Figure 2 all the blue bundles except $B_{5}$ are represented by a point, but in a more complicated example many bundles might be represented by line segments. Note that instead of storing the segment list of each blue bundle explicitly, we just maintain a pointer to that bundle as it appears in (the corresponding version of) the sweepline status structure.

2.3 The resulting data structure

After the life table is built, we sweep it with a horizontal straight line from bottom to top, again making the sweepline status partially persistent. The events now correspond to red segments, and the version of the sweepline status at a time moment $i$ contains all blue bundles crossing the horizontal line $y=i$, sorted by $x$ coordinate and stored in a balanced binary tree.

Our ultimate data structure is the persistent sweepline status of the above (second) plane sweep. We are able, in $O(1)$ time, to retrieve the version of the sweepline status structure at any moment $i$. The sweepline status at the moment $i$ is a tree storing the blue bundles whose beginning was witnessed before the moment $i$ and whose end was witnessed after that moment (in other words, those blue bundles that intersect the horizontal line $y=i$ in the life table). See Figure 2. Since each single bundle is stored in a balanced binary tree, the tree of bundles is also a balanced binary tree. Therefore it has height $O(\log{n})$. Moreover, it can be accessed in the same way as a standard binary tree: any navigation query in it (see Problem 1) can be performed in $O(1)$ time.

Now suppose we wish to perform a search on (a portion of) a red segment $r_{i}$ among the blue segments that cross it. We are required to be able to quickly determine where the interesting intersection(s) lie with respect to $p$, for any point $p$ of intersection between $r_{i}$ and a blue segment. The search in our data structure is then done as follows. We retrieve the version of the sweepline status (of the second plane sweep) at the moment $i$. This sweepline status is an implicit balanced binary tree, as explained above. We locate the endpoints of $r_{i}$ in that tree. Then we search in the portion of the tree between $r_{i}$’s endpoints. The decisions during the search are made based on our knowledge about the interesting intersections.

We conclude with the following.

Theorem 2.2

Given a pair $R,B$ of plane straight-line graphs with $n$ edges and vertices in total in both graphs, the RB-Preprocessing problem for $R$ and $B$ can be solved in $O(n\log{n})$ time and $O(n)$ space, such that the resulting data structure answers each of the navigation queries in $O(1)$ time.

Proof

The first phase of our procedure to build the data structure is an execution of the Mantler-Snoeyink algorithm, with the only difference that the bundle trees from the sweepline status are made partially persistent. The latter can be performed with amortized $O(1)$ time and space overhead per update step and a worst-case time cost of $O(1)$ per access step [10]. The total number of updates made to the sweepline status during the course of the Mantler-Snoeyink algorithm is $O(n)$ [16]. Thus, after the first phase is completed, we have the order of red segments and the persistent sweepline status. With this information, the life table can be built in $O(n)$ time and space: we fill the table with the horizontal red segments, and we access sequentially all the versions of the sweepline, retrieving the blue bundles and the information on their intersections with the red bundles, and drawing the vertical segments of the life table. Sweeping the life table with a horizontal line, and making the sweepline status partially persistent again costs $O(n\log{n})$ time and $O(n)$ space.

For an edge $e=r_{i}$ of $R$, the version of the sweepline status structure at time $i$ provides a balanced binary search tree $T_{e}$, required by the RB-Preprocessing problem, such that $T_{e}$ can be navigated (but not modified) in the same way and with the same time complexity as the standard balanced binary search tree. Hence the navigation queries of the RB-Preprocessing problem can be answered in $O(1)$ each.

3 Applications

We proceed with more detail on the applications of our technique, which are listed in Section 1.

3.1 The red-blue batched search problem

Consider two sets, $R$ (red) and $B$ (blue), of line segments in $\mathbb{R}^{2}$, such that the segments in each set are pairwise interior-disjoint, and suppose that some of the red-blue intersections are interesting, and there is at most one interesting red-blue intersection per each segment. Let ${\mathcal{O}}$ be an oracle that, given an intersection point $p$ of a red segment $r$ and a blue segment $b$, determines to which side of $p$ the interesting intersection on $r$ lies.

Problem 2 (Red-blue batched search problem [9])

Given sets $R,B$ and oracle ${\mathcal{O}}$, find all interesting intersections between the segments in $R$ and the ones in $B$.

Dehne et al. [9] showed how to solve the red-blue batched search problem by using an augmentation of the hereditary segment tree data structure of Chazelle et al. [4]. Their solution requires $O(n\log^{2}{n})$ space and $O(n\log^{3}{n})$ queries to the oracle.

Our technique presented in Section 2.2 can be directly applied to solve the red-blue batched search problem with better time and space: We preprocess the sets $R$ and $B$; after that for each red segment $r$ we perform a binary search in the (implicit) tree storing the red-blue intersections along $r$. The search is guided by the oracle ${\mathcal{O}}$, and thus it requires $O(\log{n})$ queries to the oracle. Since the number of red segments is $O(n)$, the total number of queries to the oracle required for searching all red edges is $O(n\log{n})$. Theorem 2.2 implies the following.

Theorem 3.1

The red-blue batched search problem for the sets $R,B$ and the oracle ${\mathcal{O}}$ can be solved using $O(n)$ space and $O(n\log{n})$ queries to the oracle, where $n$ is the total number of segments in $R$ and $B$.

3.2 Vertical distance for a pair of 3D polyhedral terrains, one of which is convex

Let $R$ and $B$ be two polyhedral terrains of complexity $n_{R}$ and $n_{B}$ respectively, where terrain $B$ is convex (that is, $B$ is the upper envelope of a set of $n_{B}$ planes in $\mathbb{R}^{3}$). Let $n=n_{R}+n_{B}$. We wish to determine the maximum vertical distance between $R$ and $B$, i.e., the length of the longest vertical line segment connecting a point in $R$ and a point in $B$.777It may happen, that the distance keeps increasing as we move along some direction towards infinity. Then we say that the maximum vertical distance between $R$ and $B$ is $+\infty$. As an illustration, the reader may imagine a (convex) approximate model of a mountain, and a need to compare it with the real mountain (of course, not necessarily convex) in order to estimate the quality of the approximation.

Since both surfaces $R$ and $B$ are composed of planar patches, the vertical distance between $R$ and $B$ is the vertical distance between these patches. The maximum vertical distance between $R$ and $B$ is thus attained either between a vertex of $R$ and a facet of $B$ (or vice versa), at infinity along an unbounded edge of one of the surfaces, or between an edge of $R$ and an edge of $B$. In the second case the distance between $R$ and $B$ is $+\infty$. Both the first and the second case can be easily processed by point location queries of a (possibly infinite) vertex of one surface into the other one, which requires $O(n\log{n})$ time in total. To deal with the last case one can preprocess the vertical projections of $R$ and $B$ following our technique, and perform the binary searches along each edge $e$ of $R$ for the intersection with an edge of $B$ maximizing the vertical distance. Consider the cross-section of $B$ by the vertical plane containing $e$. This is a convex monotone polygonal line. The sequence $h_{B}$ of heights of its breakpoints is unimodal, and since all points of $e$ lie on the same line, if we subtract from each member of $h_{B}$ the height of the point in $e$ lying on the same vertical line, the resulting sequence will still have one maximum. It then follows that given a point $p\in e$ vertically above/below an edge of $B$, in constant time we can find out in which direction this maximum lies, and this is exactly what the oracle for the binary search along $e$ should do. Using Theorem 2.2, we conclude.

Theorem 3.2

Given a pair of polyhedral terrains in 3D, where one of the terrains is convex, the maximum vertical distance between the terrains can be found in $O(n\log{n})$ time and $O(n)$ space, where $n$ is the total complexity of both terrains.

Notice that by slightly changing the algorithm, we could be answering the minimum vertical distance, instead of the maximum one. In particular this gives an alternative $O(n\log{n})$ algorithm to solve the shortest watchtower problem [23, 24].

3.3 Construction of the Hausdorff Voronoi diagram

Given a set of $n$ distinct points in the plane, we partition this set, resulting in a family $S$ of point clusters, where no two clusters share a point. Let the distance from a point $t\in\mathbb{R}^{2}$ to a cluster $P\in S$, denoted as $\textup{{d}}_{\textup{{f}}}(t,P)$, be the maximum Euclidean distance from $t$ to any point in $P$. The Hausdorff Voronoi diagram of $S$, denoted as $\textup{{HVD}}(S)$, is a subdivision of $\mathbb{R}^{2}$ into maximal regions such that every point within one region has the same nearest cluster according to distance $\textup{{d}}_{\textup{{f}}}(\cdot,\cdot)$.

The diagram has worst-case combinatorial complexity $\Theta(n^{2})$, and it can be constructed in optimal $O(n^{2})$ time [11]. However, these bounds can be refined according to certain parameters of the family $S$. Two clusters are called non-crossing if their convex hulls intersect at most twice (i.e., their convex hulls are pseudocircles), and crossing otherwise. Below we consider separately the (simpler) case of non-crossing clusters, and the one of crossing clusters. The latter case subsumes the former one.

Non-crossing clusters.

If all clusters in $S$ are pairwise non-crossing, the complexity of $\textup{{HVD}}(S)$ is $O(n)$. In this case the diagram can be constructed in expected $O(n\log^{2}{n})$ time and expected $O(n)$ space [5, 14]. The best deterministic algorithm to date requires $O(n\log^{5}{n})$ time and $O(n\log^{2}{n})$ space [9].888The time complexity claimed in Dehne et al. is $O(n\log^{4}{n})$, however we believe that in reality the described algorithm requires $O(n\log^{5}{n})$ time.

The latter algorithm follows the divide-and-conquer strategy. To merge two recursively computed diagrams, a bottleneck procedure is formulated as a red-blue batched segment search problem (see Section 3.1), where the two segment sets are the sets of edges of the two diagrams. The latter problem is then solved in $O(n\log^{2}{n})$ space and $O(n\log^{3}n)$ queries to the oracle. The authors define an oracle to perform this search, which they assume can be implemented in $O(1)$ time. We were unable to reconstruct the claimed constant-time oracle, however we know how to implement it in $O(\log{n})$ time per query. Theorem 3.1 implies an algorithm to construct the Hausdorff Voronoi diagram of a family of non-crossing clusters in $O(n\log^{3}n)$ time and $O(n)$ space.999Note that if it was possible to implement the oracle in $O(1)$ time, our algorithm would instantly be improved by a $O(\log{n})$ factor. Thus in all cases our algorithm is faster than the previous one by a factor of $O(\log^{2}n)$. This result is subsumed by the one for arbitrary clusters, which is strictly more general (for a family of non-crossing clusters $m=0$).

Arbitrary clusters.

Consider the Hausdorff Voronoi diagram of a family $S$ of arbitrary clusters, that could possibly cross. The essential parameter used to refine the quadratic bounds related to the diagram in that case, is the number of crossings,101010See [20, 21] for the formal definition of the number of crossings. denoted by $m$. The parameter $m$ is bounded from above by half the number of intersections between the convex hulls of all pairs of crossing clusters. In the worst case $m=\Theta(n^{2})$, however it is small in known practical applications, e.g., in VLSI CAD [20, 21]. The combinatorial complexity of the Hausdorff Voronoi diagram is shown to be $O(n+m)$ [20]. Apart from the $O(n^{2})$ time algorithm mentioned above, there is a plane sweep [20] and a divide-and-conquer [21] algorithm to construct the diagram. Both of them are sensitive to the parameter $m$, however their time complexity depends as well on some other parameters, which are unrelated to $m$. In particular, these algorithms may have $\Omega(n^{2})$ time complexity even when clusters are non-crossing.

Our technique can be applied to reduce the time complexity of the divide-and-conquer construction of the Hausdorff Voronoi diagram of arbitrary clusters [21]. The resulting algorithm is the fastest to date deterministic algorithm for certain input families, where clusters may cross, but the number of crossings is small. Since the description of our algorithm requires a lot of additional definitions and details, we defer it to Section 4.

3.4 Construction of the farthest-color Voronoi diagram

Let $S$ be a family of clusters of points in the plane, induced by partitioning a set of $n$ points in the plane – the same setting as in the previous section. Here we consider the farthest-color Voronoi diagram [13, 1] of $S$, a generalized cluster Voronoi diagram, which is in some sense the opposite to the Hausdorff Voronoi diagram. It is defined as a subdivision of the plane into maximal regions, such that for any point in the region $\textup{{fcreg}}(P)$, $P\in S$, the cluster $P$ is the farthest cluster in $S$. The distance from a point $t\in\mathbb{R}^{2}$ to a cluster $P\in S$ is the minimum distance from $t$ to a point in $P$. In $\textup{{FCVD}}(S)$, each $\textup{{fcreg}}(P)$ is subdivided into finer regions of the points of $P$ by the nearest-neighbor Voronoi diagram of the points of that cluster, $\textup{{VD}}(P)$. The edges of this additional subdivision are called internal edges.

The farthest-color Voronoi diagram is much less understood than the Hausdorff diagram. Its combinatorial complexity is $O(nk)$, and a matching lower bound is known for $k\leq n/2$ [1], where $k$ is the number of clusters in $S$. An $O(n^{2})$ time construction algorithm is implied by the result of Edelsbrunner et al. [11]. Since the diagram is not an instance of farthest abstract Voronoi diagrams [17], studying particular families of clusters (proving better bounds on the complexity of the diagram, and finding faster construction algorithms) is a non-trivial task. Recently it was shown that if the clusters in $S$ are pairs of endpoints of disjoint segments parallel to each other, $\textup{{FCVD}}(S)$ has $O(n)$ complexity and can be computed in optimal $O(n\log{n})$ time [8].

Applying our technique, we are able to claim near-optimal time complexity for a larger class of input families, where each cluster in a family is a quadruple of points that are corners of an axis-aligned rectangle, and the corresponding rectangles are pairwise disjoint. We first need to show that the farthest-color Voronoi diagram of such an input has linear combinatorial complexity, see Proposition 1 below. To prove this, we make use of the following.

Lemma 2

Let $f$ be a bounded face of $\textup{{FCVD}}(S)$. Then $f$ is incident to an internal edge of $\textup{{FCVD}}(S)$.

Proof

The following proof is a simple generalization of one of the arguments used to prove [8, Lemma 3]. Face $f$ is a face of $\textup{{fcreg}}(p)$ for some point $p\in P,P\in S$. Let $t$ be a point in $f$, and let $r$ be the ray originating at $t$ and having direction $\overrightarrow{pt}$. See Figure 3. Consider the closed disk $D_{y}$ centered at a point $y\in r$ and passing through $p$. Since $t\in\textup{{fcreg}}(p)$, $D_{t}$ intersects all the clusters in $S$. As $y$ moves along $r$, the disk grows and it still intersects all clusters in $S$. Until $y$ hits an edge of $\textup{{VD}}(P)$, the minimum distance from $y$ to $P$ is attained by $p$, and since $D_{y}$ intersects all clusters in $S$, $y$ lies in $\textup{{fcreg}}(p)$. Thus either the whole ray $r$ is contained in $f$, or the first intersection between $r$ and the boundary of $f$ lies on an internal edge of $\textup{{FCVD}}(S)$. Since we assumed $f$ to be bounded, the latter must hold.

Proposition 1

For a family $S$ of $n$ clusters, where each cluster is all the corners of an axis-aligned rectangle, and these rectangles are pairwise disjoint, the combinatorial complexity of $\textup{{FCVD}}(S)$ is $O(n)$.

Proof

$\textup{{FCVD}}(S)$ is a plane graph, whose each vertex has degree at least three. Thus by Euler’s formula it is enough to show that the number of faces of $\textup{{FCVD}}(S)$ is $O(n)$. We will treat separately its bounded and unbounded faces. We assume that each cluster has four distinct points, as otherwise (when it has two or one point) the situation becomes simpler.

We first show that the total number of bounded faces of $\textup{{FCVD}}(S)$ is $O(n)$. By Lemma 2, any bounded face $f$ of $\textup{{FCVD}}(S)$ is incident to an internal edge of $\textup{{FCVD}}(S)$. Recall that each internal edge of $\textup{{FCVD}}(S)$ is a portion of an edge of $\textup{{VD}}(P)$, that lies in $\textup{{fcreg}}(P)$, for some cluster $P\in S$. In other words, an edge of $\textup{{VD}}(P)$ intersects $\textup{{fcreg}}(P)$ in several connected components (line segments or rays), and each such connected component is an internal edge of $\textup{{FCVD}}(S)$. In the next paragraph, we will show that each edge of $\textup{{VD}}(P)$ of any cluster $P\in S$ contributes at most two internal edges to $\textup{{FCVD}}(S)$. This will imply that the total number of internal edges in $\textup{{FCVD}}(S)$ is $O(n)$: Since each cluster $P\in S$ is a quadruple of points that are the corners of an axis-aligned rectangle, $\textup{{VD}}(P)$ has four edges (see Figure 4a), and therefore the total number of edges in the nearest-neighbor Voronoi diagrams of all clusters in $S$ is $O(n)$.

Let $e$ be an edge of $\textup{{VD}}(P)$, and let $p,p^{\prime}\in P$ be the points that induce $e$, i.e., $e$ is a ray contained in the bisector of $p,p^{\prime}$. See Figure 4b. The segment $pp^{\prime}$ breaks $e$ into two portions; consider one of them, $e_{r}$; the other part is treated analogously. Suppose for the sake of contradiction that $e_{r}$ intersects $\textup{{fcreg}}(P)$ in at least two connected components. Consider the circle passing through points $p,p^{\prime}$ and whose center $y$ moves along $e_{r}$ in the direction of growing radius of the circle. When $y$ stops being in $\textup{{fcreg}}(P)$, the circle stops containing a point of every cluster in $S$. That is, some cluster $Q$ starts to be outside the circle. Since the circle is growing, there is no way for $Q$ to restart intersecting the circle, unless the convex hull of $Q$ intersects the segment $pp^{\prime}$ (see the dark-blue rectangles in Figure 4b), which would contradict the disjointness of the convex hulls of the clusters in $S$.

Now we estimate the number of unbounded faces of $\textup{{FCVD}}(S)$. Consider the arrangement of all edges of the nearest-neighbor Voronoi diagrams of clusters in $S$. This is a grid made of $n$ vertical and $n$ horizontal lines. Within one cell of that grid, $\textup{{FCVD}}(S)$ coincides with the farthest Voronoi diagram of $n$ points (one point per cluster). The number of unbounded regions of $\textup{{FCVD}}(S)$ equals the number of unbounded edges of $\textup{{FCVD}}(S)$. That number is comprised of the total number of unbounded internal edges (it is $O(n)$ since each of them is a portion of a line forming the grid) and the total number of the unbounded edges of $\textup{{FCVD}}(S)$ within the unbounded cells of the grid. Now we observe that such cells are $O(n)$ half-strips and four quarter-planes. At infinity, the total number of distinct directions that all the half-strips correspond to is only four, thus at most four additional unbounded edges of $\textup{{FCVD}}(S)$ may lie within these strips. At each quarter-plane, we have the farthest-point Voronoi diagram of $n$ points, which has $O(n)$ unbounded edges. Therefore the total number of unbounded edges of $\textup{{FCVD}}(S)$ is $O(n)$, and the same bound holds for the total number of unbounded faces of $\textup{{FCVD}}(S)$.

We proceed with the main result of this section.

Theorem 3.3

For a family $S$ of $n$ clusters, that are corners of pairwise disjoint axis-aligned rectangles, $\textup{{FCVD}}(S)$ has complexity $O(n)$ and it can be constructed in $O(n\log^{2}{n})$ time.

Proof

The complexity of $\textup{{FCVD}}(S)$ is $O(n)$ due to the above Proposition 1.

To construct $\textup{{FCVD}}(S)$, we employ the divide-and-conquer strategy. We are not able to apply the divide-and-conquer algorithm from [8, Lemma 24], since the merge curve is not necessarily connected, and may have cycles. Suppose that for two subsets $S_{\ell}$, $S_{r}$ of $S$, the farthest-color Voronoi diagram is already computed. To merge two diagrams, we preprocess them using our technique from Section 2.2, and obtain the implicit search trees for the edges of $\textup{{FCVD}}(S_{r})$. Then we can search each internal edge of $\textup{{FCVD}}(S_{r})$, to determine all its portions that appear in the merged diagram. If we subdivide the edge by the segment through its generator points, the two halves will have at most one such connected component each, see the proof of Proposition 1. Thus we search them separately. To navigate the search along such a portion $e_{r}$, given a point $p$ of intersection between $e_{r}$ and an edge $e^{\prime}$ of $\textup{{FCVD}}(S_{\ell})$, we obtain the cluster $Q$ that is farthest from $p$ among the clusters in $S_{\ell}$. We construct the bisector between $P$ and $Q$, and this shows to which side of $p$ there lies the portion of $e$ that is farther from $P$ that from $Q$. That portion is the only one to which we should continue.

The merging step overall takes $O(n\log n)$ time and $O(n)$ space to preprocess the diagrams, and $O(\log{n})$-time search per each of $O(n)$ internal edges of $\textup{{FCVD}}(S_{\ell})$. The claimed time and space complexity follows.

3.5 The stabbing circle problem

Given a set $S$ of $n$ line segments in the plane, a circle $c$ is called a stabbing circle for $S$ if every segment in $S$ has exactly one endpoint in the exterior of the disk induced by $c$. Two stabbing circles $c_{1},c_{2}$ are combinatorially different if they classify the endpoints of $S$ differently.

The stabbing circle problem for $S$ consists of computing (a representation of) all the combinatorially different stabbing circles for $S$ (if they exist); and finding stabbing circles with the minimum and maximum radius. Although the stabbing circle problem can be solved in a worst-case optimal $O(n^{2})$ time and space by applying a technique by Edelsbrunner et al. [11] (see [8] for the explanation), the problem can be solved much faster if the input set of segments is of some particular form [8]. The method to do so is based on the Hausdorff and the farthest-color Voronoi diagram (see Section 3.3 and  3.4 for the definitions), and its time complexity depends on the parameters of these diagrams and of the input segment set; we will detail it in the next paragraph. For the segments parallel to each other, it works in $O(n\log^{2}n)$ time. The technique presented in Section 2.2 helps to improve the time complexity of this alternative method by a $O(\log n)$ factor. This automatically reduces the time required to solve the stabbing circle problem for parallel segments from $O(n\log^{2}{n})$ to $O(n\log{n})$, which now matches the lower bound given in [7].

Let $\textup{{HVD}}(S)$ and $\textup{{FCVD}}(S)$ denote respectively the Hausdorff and the farthest-color Voronoi diagram, whose sites are pairs of endpoints of the segments in $S$. Let $\mathcal{T}_{\textup{{HVD}}(S)}$ and $\mathcal{T}_{\textup{{FCVD}}(S)}$ denote the time required to compute these two diagrams, and let $|\textup{{HVD}}(S)|$ and $|\textup{{FCVD}}(S)|$ respectively denote their combinatorial complexity. Additionally, we let $m$ be a parameter reflecting interaction between the segments in $S$.111111 $m$ denotes the number of pairs formed by a segment $aa^{\prime}\in S$ and a pure edge $uv$ of $\textup{{HVD}}(S)$ such that $a\in D(u)\setminus D(v)$ and $a^{\prime}\in D(v)\setminus D(u)$. $D(u)$ (resp., $D(v)$) is the disk centered at $u$ (resp., at $v$) with the radius $\textup{{d}}_{\textup{{f}}}(u,P)$ (resp., $\textup{{d}}_{\textup{{f}}}(v,P)$), where $P$ is the cluster in $S$ such that $e$ is incident to $\textup{{hreg}}(P)$. We are ready to state the new result for the stabbing circle problem for $S$ that improves on [8, Lemma 17; Corollary 3, Theorem 4].

Theorem 3.4

Given a set $S$ of $n$ segments in the plane in general position, the stabbing circle problem for $S$ can be solved in time $O(\mathcal{T}_{\textup{{HVD}}(S)}+\mathcal{T}_{\textup{{FCVD}}(S)}+(|\textup{{HVD}}(S)|+|\textup{{FCVD}}(S)|+m)\log n)$. If the segments in $S$ are parallel to each other, the stabbing circle problem for $S$ can be solved in optimal $O(n\log{n})$ time and $O(n)$ space.

Proof (sketch)

The only substantial change to the algorithm in [8] is an alternative procedure for the find-change query. In particular, [8, Lemma 17] gives a procedure to perform this query in $O(\log^{2}{n})$ time by a nested point location in $\textup{{FCVD}}(S)$. By using the technique presented in Section 3, we replace the nested point location by a binary search on $e$ among the intersections with the edges of $\textup{{FCVD}}(S)$. The oracle for our search works in $O(1)$ time: Given a point $p$ on the intersection of an edge $e$ of $\textup{{HVD}}(S)$ and $g$ of $\textup{{FCVD}}(S)$, the “owners” of $p$ in both diagrams are available automatically. Once the owners of $p$ are known, determining the type of $p$ is a constant-time operation. Using Theorem 2.2, we improve the result of [8, Lemma 17] by a factor of $O(\log{n})$. The claim follows by plugging the improved result into [8, Theorem 1].

4 A Divide and Conquer Algorithm for the Hausdorff Voronoi Diagram

Let $S$ be a family of point clusters in the plane, such that no two clusters have a common point. Let $n$ be the total number of points in $S$. We follow a general position assumption that no four points lie on the same circle. We also assume that no cluster encloses another in its convex hull, as the outer cluster would have empty region in the Hausdorff Voronoi diagram.

Definition 1

Two clusters $P$ and $Q$ are called non-crossing, if the convex hull of $P\cup Q$ admits at most two supporting segments with one endpoint in $P$ and one endpoint in $Q$. If the convex hull of $P\cup Q$ admits more than two such supporting segments, then $P$ and $Q$ are called crossing.

The farthest Voronoi diagram of a cluster $C$, denoted as $\textup{{FVD}}(C)$, is a partitioning of the plane into regions where the farthest Voronoi region of a point $c\in C$ is $\textup{{freg}}_{C}(c)=\{p\mid\forall c^{\prime}\in C\setminus\{c\}\colon d(p,c)>d(p,c^{\prime})\}.$ The graph structure of $\textup{{FVD}}(C)$ is a tree ${\mathcal{T}}(C)=\mathbb{R}^{2}\setminus\bigcup_{c\in C}\textup{{freg}}_{C}(c)$.

Given a cluster $C\in S$ and a point $p\in\mathbb{R}^{2}$, we let $\textup{{d}}_{\textup{{f}}}(p,C)$ denote the maximum distance between $p$ and the points of the cluster $C$, i.e., $\textup{{d}}_{\textup{{f}}}(p,C)=\max_{c\in C}{d(p,c)}$, where $d(\cdot,\cdot)$ denotes the Euclidean distance between two points.

The Hausdorff Voronoi diagram of $S$, denoted as $\textup{{HVD}}(S)$, is a partitioning of the plane into regions, where the Hausdorff Voronoi region of a cluster $C\in S$ is $\textup{{hreg}}_{S}(C)=\{p\mid\forall C^{\prime}\in S\setminus\{C\}\colon\textup{{d}}_{\textup{{f}}}(p,C)<\textup{{d}}_{\textup{{f}}}(p,C^{\prime})\}.$ The Hausdorff Voronoi region of a point $c\in C$ is $\textup{{hreg}}_{S}(c)=\textup{{hreg}}_{S}(C)\cap\textup{{freg}}_{C}(c).$ If clear from the context, we do not write subscripts for $\textup{{hreg}}(){}$ and $\textup{{freg}}(){}$.

For two clusters $P,Q\in S$, their Hausdorff bisector $\textup{{b}}_{\textup{{h}}}(P,Q)=\{y\mid\textup{{d}}_{\textup{{f}}}(y,P)=\textup{{d}}_{\textup{{f}}}(y,Q)\}$ consists of one (if $P,Q$ are non-crossing) or more (if $P,Q$ are crossing) unbounded polygonal chains [20, 21]. Each vertex of $\textup{{b}}_{\textup{{h}}}(P,Q)$ is the center of a circle passing through two points of one cluster and one point of another that entirely encloses $P$ and $Q$. The vertices of $\textup{{b}}_{\textup{{h}}}(P,Q)$ are called mixed vertices.

Definition 2

A mixed vertex on the bisector $\textup{{b}}_{\textup{{h}}}(P,Q)$, induced by two points $p_{i},p_{j}\in P$ and a point $q_{l}\in Q$ is called crossing, if there is a diagonal $q_{l}q_{r}$ of $Q$ that crosses the diagonal $p_{i}p_{j}$ of $P$, and all points $p_{i},p_{j},q_{l},q_{r}$ are on the convex hull of $P\cup Q$. The total number of crossing vertices along the bisectors of all pairs of clusters is the number of crossings and is denoted by $m$.

Edges of the Hausdorff Voronoi diagram are of two types: pure edges, and internal edges, that are portions of edges of ${\mathcal{T}}(C)$ inside $\textup{{hreg}}(C)$. Each pure edge separates the Hausdorff Voronoi regions of two different clusters, and each internal edge separates the Hausdorff Voronoi regions of two different point in one cluster. Another way to see it is the following. Any edge of the Hausdorff Voronoi diagram is a portion of a bisector between two points. If these points are of the same cluster than the edge is a pure edge, otherwise it is an internal edge.

Property 1 ([20])

Each face of a region $\textup{{hreg}}(C)$ intersects ${\mathcal{T}}(C)$ in one non-empty connected component.

Given a family $S$ of point clusters, its Hausdorff Voronoi diagram can be computed in $O(M+n\log^{2}{n}+(m+K)\log{n})$121212 $m=\sum_{(P,Q)}m(P,Q)$, where $m(P,Q)$ is the number of crossing mixed vertices on the bisector between $P$ and $Q$, for any pair of crossing clusters $P,Q$. $K=\sum_{P\in S}{K(P)}$, $M=\sum_{P\in S}{M(P)}$, where $K(P)$ is the number of clusters enclosed in the minimum enclosing circle of $P$, and $M(P)$ is the number of convex hull points $q\in Q$ that are interacting with $P$, that is, $q$ is enclosed in the minimum enclosing circle of $P$ and either $Q$ is entirely enclosed in the minimum enclosing circle of $P$ or $Q$ is crossing with $P$. using the divide-and-conquer strategy [21]. We show how to reduce this to $O((n+m)\log^{3}{n})$ time and $O(n+m)$ space (Theorem 4.1) by using the data structure described in Section 2.2.

Let the input set $S$ be subdivided into two sets $S_{\ell}$ and $S_{r}$ by a vertical line $\ell$, such that the leftmost point of each cluster in $S_{\ell}$ and in $S_{r}$ is respectively to the left and to the right of $\ell$. Let the diagrams $\textup{{HVD}}(S_{\ell})$ and $\textup{{HVD}}(S_{r})$ be recursively computed. The nontrivial part of merging $\textup{{HVD}}(S_{\ell})$ and $\textup{{HVD}}(S_{r})$ is to find the merge curve $\sigma$. The main complication, that distinguishes this case from the well-known divide-and-conquer algorithm for the Voronoi diagram of points, is that $\sigma$ is not a Jordan curve, in particular, it has several unbounded components and several cycles [21]. The unbounded components, as well as the cycles that enclose at least one vertex of $\textup{{HVD}}(S_{\ell})$ or of $\textup{{HVD}}(S_{r})$, can be found efficiently [21]. The cycles that enclose no vertices of $\textup{{HVD}}(S_{\ell})$ or $\textup{{HVD}}(S_{r})$ must contain a portion of an internal edge of one of the diagrams (which follows from Property 1). Thus to identify them, we need to perform searches along the internal edges of $\textup{{HVD}}(S_{\ell})$, and the ones of $\textup{{HVD}}(S_{r})$. Below we will concentrate on the former case; the latter one is analogous.

We perform these searches by means of the data structure developed in Section 2.2. For any internal edge of $\textup{{HVD}}(S_{\ell})$, the data structure provides a (implicit) tree storing all the intersections of this edge with the edges of $\textup{{HVD}}(S_{r})$. We search this tree, that is, at each accessed node we need to decide which subtree we should continue with. Sometimes we should continue to both subtrees, but we are able to charge this branching to crossing mixed vertices induced by $p_{1}$ and $p_{2}$. Each vertex is charged at most once, and their overall number is $m$, which gives us the claimed time complexity. We proceed with a more detailed description.

The following lemmas are the basis of our decision procedure. Let $uv$ be a connected portion of an internal edge of $\textup{{HVD}}(S_{\ell})$ induced by points $p_{1},p_{2}$ of cluster $P\in S_{\ell}$, i.e., $uv$ is a portion of the Euclidean bisector of $p_{1}$ and $p_{2}$.

Lemma 3

For any cluster $Q$ in $S_{r}$: (i) the locus of points in $uv$ that are closer to $Q$ than to $P$ is connected. (ii) the locus of points in $uv$ that are closer to $P$ than to $Q$ may have up to two connected components. If it has two connected components, then there is a pair of crossing mixed vertex induced by $p_{1},p_{2}$ and a point in $Q$.

Proof

(i). Suppose for the sake of contradiction that the locus of points in $uv$ that are closer to $Q$ than to $P$ is not connected. Then there are points $x,y,z\in uv$ such that $y$ is between $x$ and $z$, and $\textup{{d}}_{\textup{{f}}}(x,Q)<\textup{{d}}_{\textup{{f}}}(x,P)$, $\textup{{d}}_{\textup{{f}}}(x,Q)>\textup{{d}}_{\textup{{f}}}(x,P)$, and $\textup{{d}}_{\textup{{f}}}(x,Q)<\textup{{d}}_{\textup{{f}}}(x,P)$. Let $D_{x},D_{y},D_{z}$ be the disks centered at respectively $x,y$ and $z$, and each passing through points $p_{1},p_{2}$. See Figure 5. Note that since $uv$ is a portion of an internal edge of $\textup{{HVD}}(S_{\ell})$, for each point $q\in uv$, $\textup{{d}}_{\textup{{f}}}(q,P)=d(q,p_{1})$. Thus, $Q\subset D_{x}$, $Q\not\subset D_{y}$, and $Q\subset D_{z}$. But $D_{x}\cap D_{z}\subset D_{y}$. We obtain a contradiction.

(ii). The first part of the statement follows directly from item (i) since the locus of points in $uv$ closer to $P$ than to $Q$ is the complement of the locus of points considered in (i). Now suppose the locus of points in $uv$ that are closer to $P$ than to $Q$ has two connected components. Thus, for the segment $v_{1}v_{2}\subset uv$ in-between these two components, every point in $v_{1}v_{2}$ is closer to $Q$ than to $P$. Consider the two disks $D_{v_{1}}$ and $D_{v_{2}}$ centered respectively at $v_{1}$ and $v_{2}$, and each passing through $p_{1},p_{2}$. See Figure 6. By construction, $D_{v_{1}}$ and $D_{v_{2}}$ contain respectively a point $q_{1}\in Q$ and a point $q_{2}\in Q$ on their boundaries, and these points are to the opposite sides of $p_{1}p_{2}$, and both $P$ and $Q$ are contained in each of $D_{v_{1}}$ and $D_{v_{2}}$. Thus the chord $q_{1}q_{2}$ crosses the chord $p_{1}p_{2}$, and all four points appear on the convex hull of $P\cup Q$. Thus $v_{1}$ and $v_{2}$ both are crossing mixed vertices of $\textup{{b}}_{\textup{{h}}}(P,Q)$ induced respectively by $p_{1},p_{2},q_{1}$ and by $p_{1},p_{2},q_{2}$. The claim follows.

Lemma 4

Let $x$ be a point in $uv$, and let $Q$ be a cluster in $S_{r}$ such that $\textup{{d}}_{\textup{{f}}}(x,Q)\leq\textup{{d}}_{\textup{{f}}}(x,Q^{\prime})$ for any $Q^{\prime}\in S_{r}$. If $\textup{{d}}_{\textup{{f}}}(x,Q)<\textup{{d}}_{\textup{{f}}}(x,P)$, then in $O(\log{n})$ time it is possible to check whether $xv$ contains points closer to $P$ than to $Q$.

Proof

We check whether $xv$ contains points closer to $P$ than to $Q$ as follows. We locate point $v$ in $\textup{{FVD}}(Q)$, which gives us $\textup{{d}}_{\textup{{f}}}(v,Q)$. Recall that $\textup{{d}}_{\textup{{f}}}(v,P)=d(v,p_{1})$, and this is available immediately. If $\textup{{d}}_{\textup{{f}}}(v,Q)\geq\textup{{d}}_{\textup{{f}}}(v,P)$, we return the positive answer. If $\textup{{d}}_{\textup{{f}}}(v,Q)<\textup{{d}}_{\textup{{f}}}(v,P)$, then by Lemma 3i all the points in $xv$ are closer to $Q$ than to $P$, and the answer to our query is negative.

Now we are ready to state the main result of this section.

Theorem 4.1

Given a family $S$ of point clusters in the plane, The Hausdorff Voronoi diagram of $S$ can be computed in $O((n+m)\log^{3}{n})$ time and $O(m+n)$ space, where $n$ is the total number of points in all clusters in $S$, and $m$ is the number of crossings for the clusters in $S$.

Proof

The algorithm is a divide-and-conquer algorithm, that follows the one of Papadopoulou and Lee [21], except for finding a point on each cycle of the merge curve in the merging step.

Let the input family $S$ be subdivided into two subfamilies $S_{\ell}$ and $S_{r}$ by a vertical line $\ell$ (using the location of the leftmost point in each cluster), and let the diagrams $\textup{{HVD}}(S_{\ell})$ and $\textup{{HVD}}(S_{r})$ be recursively computed. The main difference from the well-known divide-and-conquer algorithm for the Voronoi diagram of points [22] is that the merge curve $\sigma$ for $\textup{{HVD}}(S_{\ell})$ and $\textup{{HVD}}(S_{r})$ may have several unbounded components and several cycles [21]. Merging $\textup{{HVD}}(S_{\ell})$ and $\textup{{HVD}}(S_{r})$ then consists of (1) finding a point on each component of the merge curve, (2) tracing the merge curve and stitching the relevant parts of $\textup{{HVD}}(S_{\ell})$ and $\textup{{HVD}}(S_{r})$ together. It is known how to perform task (2) such that the overall time required for this task during the course of the algorithm is $O(n\log n+m)$ [21]. Task (1) for the unbounded components can be done in time $O(n)$, where $n$ is the total number of points in the clusters in $S_{\ell}$ and $S_{r}$ [21]. Each cycle of $\sigma$ that encloses at least one vertex of $\textup{{HVD}}(S_{\ell})$ or of $\textup{{HVD}}(S_{r})$, can be found in $O(n\log{n})$ time [21].

We describe how to find a point on each cycle that encloses no vertices of $\textup{{HVD}}(S_{\ell})$ or $\textup{{HVD}}(S_{r})$. We make use of the fact that such cycles enclose a portion of an internal edge of one of the diagrams (which follows from Property 1). We preprocess $\textup{{HVD}}(S_{\ell})$ and $\textup{{HVD}}(S_{r})$ as shown in Section 2.2, resulting in a data structure, that for every edge of $\textup{{HVD}}(S_{\ell})$ provides a (implicit) tree storing all the intersections between that edge and the edges of $\textup{{HVD}}(S_{r})$.

For each internal edge of $\textup{{HVD}}(S_{\ell})$, we examine its portions that are outside any merge curve identified so far. Let $uv$ be such a portion of an internal edge induced by $p1,p2\in P,P\in S_{\ell}$. That is, $uv$ is a portion of the bisector of $p_{1}$ and $p_{2}$, and both $u,v$ are closer to some cluster in $S_{r}$ than to $P$. We must find all the portions of $uv$ that are closer to $P$ than to any cluster in $S_{r}$, or report that they do not exist.

We search the tree that stores the intersections between $uv$ and the edges of $\textup{{HVD}}(S_{r})$. As we navigate in the tree we keep track of the portion of $uv$ that corresponds to the current node: the root of the tree corresponds to $uv$, and each consecutive node $y$ on any root-to-leaf path subdivides the current portion into two, which are assigned to the two children of $y$. Observe that no two distinct nodes of the tree may be such that the portions corresponding to their left children intersect, and the ones of their right children intersect as well. Indeed, for two nodes $x$ and $y$, either $x$ is an ancestor of $y$, and then both intervals of $y$ are contained in one of the intervals of $x$, or $y$ is an ancestor of $x$ (a symmetric case), or $x$ and $y$ do not lie on one root-to-leaf path, and then the intervals of $x$ do not intersect the ones of $y$. This observation will be useful for estimating the time complexity of the algorithm.

Consider a tree node $x$, let $e$ be the edge of $\textup{{HVD}}(S_{r})$, such that $x$ is the intersection point between $uv$ and $e$, and let $u^{\prime}v^{\prime}$ be the portion of $uv$ that corresponds to $x$. We need to decide in which subtree of $x$ to continue the search. Suppose first that $e$ is an internal edge of $\textup{{HVD}}(S_{r})$. Let $Q$ be the cluster in $S_{r}$, such that $e$ belongs to $\textup{{hreg}}_{S_{r}}(Q)$. Employing Lemma 4, we determine if $u^{\prime}x$ and/or $xv^{\prime}$ contain points closer to $P$ than to $Q$. If $u^{\prime}x$ (resp., $xv^{\prime}$) does not contain such points, than it cannot intersect the merge curve, and the corresponding subtree should be ignored. Otherwise, the search continues in that subtree.

Suppose now that $e$ is a pure edge of $\textup{{HVD}}(S_{r})$, that separates the regions of some clusters $Q,Q^{\prime}\in S_{r}$. We perform the checks for both $Q$ and $Q^{\prime}$, and we continue to a subtree only if the corresponding portion of $u^{\prime}v^{\prime}$ contains points closer to $P$ that to $Q$ and points closer to $P$ than to $Q^{\prime}$.

We now analyze the time complexity of the merging procedure. Let $m_{\ell r}$ be the total number of crossings between pairs of clusters, one of which is in $S_{\ell}$ and the other is in $S_{r}$. All the unbounded components of the merge curve, as well as the cycles that contain Voronoi vertices, can be found in total time $((n+m_{\ell r})\log n)$ [21]. When the merge curve is fully determined, stitching the appropriate pieces of $\textup{{HVD}}(S_{\ell})$ and $\textup{{HVD}}(S_{r})$ together can be done within the same time bound [21]. Below we prove that our procedure to find all the cycles of the merge curve that do not contain Voronoi vertices, requires $O((n+m_{\ell r})\log^{2}n)$. The claimed overall time complexity to construct $\textup{{HVD}}(S)$ then will follow from the fact that for each pair of clusters in $P,Q\in S$, it happens at most once that $P$ is in $\textup{{HVD}}(S_{\ell})$ and $Q$ is in $\textup{{HVD}}(S_{r})$ or vice versa. Thus the total sum of the numbers $m_{\ell r}$ in all the merging steps is at most $m$.

To prove that finding all empty cycles of the merge curve requires $O((n+m_{\ell r})\log^{2}n)$ time, we note that if at a node $x$ the search has continued in both subtrees of $x$, we necessarily have that the cluster $Q\in S_{r}$ that is the closest to $x$, such that both $u^{\prime}x$ and $xv^{\prime}$ contain points closer to $P$ than to $Q$. By Lemma 3, there are two crossing mixed vertices induced by $p1,p2$ and $Q$. We charge the branching of our search at $x$ to that pair of vertices. Since no two nodes of the tree may have the portions of $uv$ that correspond to their left children and the ones corresponding to their right children, respectively, both intersecting (as observed above), a pair of crossing vertices can be charged at most once. Therefore, the total number of nodes of all the search trees where our search went both ways is $O(m_{\ell r})$. The claim follows, since the number of leaves reached by our search in one tree is $1+t$, where $t$ is the number of times the search was continued to both subtrees of a node. Since the height of any leaf is $O(\log{n})$, and the time spent in one node is $O(\log n)$, the total time for searching one tree is $O((1+t)\log^{2}{n})$.