On Practical Nearest Sub-Trajectory Queries under the Fréchet Distance

TL;DR

This work tackles exact sub-trajectory nearest-neighbor queries under the continuous Fréchet distance for large input trajectories. It introduces a Greedy Decider, a Hierarchical Simplification Tree, and an integrative Algorithm 3 that combines pruning with multi-resolution clustering to achieve scalable, exact results using linear-space preprocessing. The paper demonstrates that these methods substantially outperform baselines in construction and query efficiency on real and synthetic data, thanks to pruning and batch processing that exploit trajectory structure. Collectively, the approach provides a practical framework for exact sub-trajectory proximity search under $CF$, enabling efficient analysis of massive trajectory collections in domains such as mobility, sports analytics, and transportation.

Abstract

We study the problem of sub-trajectory nearest-neighbor queries on polygonal curves under the continuous Fréchet distance. Given an $n$ vertex trajectory $P$ and an $m$ vertex query trajectory $Q$, we seek to report a vertex-aligned sub-trajectory $P'$ of $P$ that is closest to $Q$, i.e. $P'$ must start and end on contiguous vertices of $P$. Since in real data $P$ typically contains a very large number of vertices, we focus on answering queries, without restrictions on $P$ or $Q$, using only precomputed structures of ${\mathcal{O}}(n)$ size. We use three baseline algorithms from straightforward extensions of known work, however they have impractical performance on realistic inputs. Therefore, we propose a new Hierarchical Simplification Tree data structure and an adaptive clustering based query algorithm that efficiently explores relevant parts of $P$. The core of our query methods is a novel greedy-backtracking algorithm that solves the Fréchet decision problem using ${\cal O}(n+m)$ space and ${\cal O}(nm)$ time in the worst case. Experiments on real and synthetic data show that our heuristic effectively prunes the search space and greatly reduces computations compared to baseline approaches.

Figures (13)

• Figure 1: Examples of realistic inputs that lead to high query times in baseline methods $1$, $2$, and $3$.
• Figure 2: Freespace diagram example showing a trajectory $P$ ($|P|=41$) and query $Q$ ($|Q|=19$) from the Pigeon pigeon16 data set. In this example, point $(q_m,p_j)$ is reachable from point $(q_1,p_i)$ via the canonical path (green). Also shown are stopper points (red), trigger points (green), emission points (blue), and the reachable space in green (see Section \ref{['ssec:algo1']}). Note that for simplicity, freespace cell plots show straight edges (technically they are ellipses).
• Figure 3: Clockwise monotone and non-monotone boundary traversal (a), and examples for the definitions of trigger (b, c, d), stopper in the presence of a ceiling (e), stopper in the absence of a ceiling (h), and emission points (f, g).
• Figure 4: Greedy decider traversal example. Begin in state 1. Start at point 1, go up to 2, then to stopper 3. Switch to state 2. Go to trigger 4, then shoot ray 5 which hits a boundary, so push trigger 4 onto the stack. Go to trigger 6, then shoot ray 7 which hits a boundary, so push trigger 6 onto stack. Go to 8, pop trigger 6 off stack. Go to trigger 9, shoot ray 10 which reaches 9. Switch to state 1. Go to 11, pop trigger 4 off stack. Go to 12, and 13, and return $true$. The shaded blue area shows freespace that is pruned when trigger $4$ is encountered.
• Figure 5: An example of two methods that attempt to reach trigger points, for a given row $i$ that has cascading non-freespace blockages. The top shows the horizontal ray shooting approach (left-to-right), that starts at point 1, then cascading trigger points to the right of 1 are reached with ray shoots, until it attempts to reach point 2 which is blocked, then it goes to point 3. The bottom shows the sweep approach (left-to-right) that tracks the vertical reachable space interval (blue dotted line) and starts at point 1, then cascading trigger points to the right of 1 are reached by looking at the previous cell's blue interval, until it attempts to reach point 2 which has an empty reachable space interval, so it backtracks cell-by-cell (right-to-left sweeping) to point 3 which is the first reachable point that is at the bottom of the row and blocked to the right.