Approximate Discontinuous Trajectory Hotspots

TL;DR

This paper introduces an efficient algorithm to find approximate hotspots in polygonal trajectories, significantly reducing computation time while maintaining near-optimal accuracy in identifying regions of maximum entity presence.

Contribution

The paper presents a novel $(1 + ext{epsilon})$-approximate hotspot algorithm with improved time complexity for polygonal trajectories.

Findings

Algorithm achieves $O({n o ext{ratio of average edge length to } s} imes rac{1}{ ext{epsilon}} imes ext{log}({n o ext{ratio of average edge length to } s} imes rac{1}{ ext{epsilon}}))$ time complexity.

Provides a practical method for approximate hotspot detection with theoretical guarantees.

Reduces computational complexity compared to exact hotspot algorithms.

Abstract

A hotspot is an axis-aligned square of fixed side length $s$, the duration of the presence of an entity moving in the plane in which is maximised. An exact hotspot of a polygonal trajectory with $n$ edges can be found in $O(n^2)$. Defining a $c$-approximate hotspot as an axis-aligned square of side length $cs$, in which the duration of the entity's presence is no less than that of an exact hotspot, in this paper we present an algorithm to find a $(1 + \epsilon)$-approximate hotspot of a polygonal trajectory with the time complexity $O({n\phi \over \epsilon} \log {n\phi \over \epsilon})$, where $\phi$ is the ratio of average trajectory edge length to $s$.

Full text

Keywords: Computational geometry, geometric algorithms, trajectory analysis, trajectory hotspots.

2010 Mathematics subject classification: 68U05.

1 Introduction

Many objects on earth move and huge collections of trajectory data have been collected by tracking some of them with technologies like GPS devices. In the analysis of these trajectories, many interesting geometric problems arise, such as simplification [1], segmentation [2], grouping [3], classification [4], and finding the interesting regions like where objects spend a significant amount of time [5, 6, 7, 8].

Few results have been published to present exact geometric algorithms for the identification of regions that are frequently visited, called hotspots in the rest of this paper (several heuristic algorithms have been published though, such as [7]). The movement of an entity (its trajectory) is commonly represented as a polygonal curve. A set of vertices show the location of the entity at specific points in time, and line segments (as edges) connect contiguous vertices. For multiple entities, Benkert et al. [5] defined a hotspot as an axis-aligned square, which is visited by the maximum number of distinct entities. They presented an $O(n\log n)$ time sweep-line algorithm, where $n$ is the number of trajectory vertices, when only the inclusion of a trajectory vertex is considered a visit. For the case where the inclusion of any portion of a trajectory edge is a visit, they presented an $O(n^{2})$ algorithm, which subdivides the plane to find a hotspots. They showed in both cases that their algorithm is optimal.

In a more recent paper, Gudmundsson et al. [6] examined different definitions of trajectory hotspots, in which the duration of the entity’s presence is significant. In this paper, we focus on one of their definitions, as follows: a hotspot is an axis-aligned square of some pre-specified side length, in which the entity (or entities) spends the maximum possible duration and the presence of the entity in the region can be discontinuous. For this problem and for a trajectory with $n$ edges, they presented an exact $O(n^{2})$ algorithm, which subdivides the plane based on the breakpoints of the function that maps the location of a square of the specified side length to the duration of the presence of the entities in that square.

When $s$ is the side length of exact hotspots, a $c$-approximate hotspot, where $c>1$, is an axis-aligned square of side length $cs$, in which the duration of the entity’s presence is no less than that of an exact hotspot. In this paper we present an algorithm to find $(1+\epsilon)$-approximate hotspots of a trajectory in the plane. The algorithm first subdivides each edge to small segments and then finds the square that contains the maximum number of such segments. The time complexity of the algorithm, which shall be presented in the rest of this paper, is $O({n\phi\over\epsilon}\log{n\phi\over\epsilon})$, where $\phi$ is the ratio of average length of trajectory edges to $s$. We then use this algorithm to find a duration-approximate hotspot of a trajectory $T$ with approximation ratio $1/4$, i.e. a square of side length $s$, in which the entity is present at least $1/4$ of the time it is present in the exact hotspot.

This paper is organized as follows. The algorithm and its analysis are presented in Section 3, after introducing the notation and defining some of the concepts discussed in this paper in Section 2.

2 Preliminaries

A trajectory describes the movement of an entity and is represented as a sequence of vertices in the plane with timestamps that specify the location of the entity at different points in time. The entity is assumed to move from one vertex to the next in a straight line and with constant speed.

Definition 2.1**.**

The weight of a square $r$ with respect to a trajectory $T$, denoted as $w(r)$ is the total duration in which the entity spends inside it. Also, $w(u)$ for any sub-trajectory (or edge) $u$ of $T$, indicates the duration of $u$ (the difference between the timestamps of its endpoints).

The input to the problem studied in this paper is a trajectory $T$ and the value of $s$. The goal is to find a hotspot of $T$ (Definition 2.2). Unless explicitly mentioned otherwise, every square discussed in this paper is axis-aligned and has side length $s$.

Definition 2.2**.**

A hotspot of trajectory $T$ in $R^{2}$ is a placement of a square of side length $s$ in the plane with the maximum weight (the duration of the presence the entity in the square is maximised).

A hotspot of a trajectory with $n$ edges can be found with the time complexity $O(n^{2})$ [6]. Our goal in this paper is finding approximate hotspots of a trajectory more efficiently (Definition 2.3).

Definition 2.3**.**

A $c$-size-approximate (or $c$-approximate for brevity) hotspot is a square whose weight is at least the weight of an exact hotspot and its side length is $c$ times $s$.

In Definition 2.3, hotspots are enlarged. A more natural definition may be squares with the same size as the exact ones, but with smaller weights (Definition 2.4).

Definition 2.4**.**

A $c$-duration-approximate hotspot is a square of side length $s$, whose weight is at least $c$ times the weight of an exact hotspot.

3 The Approximation Algorithm

For a trajectory $T$ in $R^{2}$ and some constant $\epsilon$, where $\epsilon>0$, in this section we present an algorithm to find a $(1+\epsilon)$-approximate hotspot and use it to find a $1/4$-duration-approximate hotspot.

We first subdivide each edge of the trajectory into segments of height and width at most $\epsilon s$; we do so by covering each edge by non-overlapping axis-aligned squares of side length $\epsilon s/2$. For each such tile, we add a point at its centre. Let the weight of this point be the duration of the portion of the edge that is inside its tile. For every resulting point $p$, we use $p_{t}$ to denote its corresponding tile and $p_{g}$ to denote the corresponding segment (Figure 1). Note that the tiles of different edges may overlap.

Definition 3.1**.**

The point-weight of a square $r$ with respect to a trajectory $T$, denoted as $w^{\prime}(r)$, is the total weight of the points inside $r$. Also, $w^{\prime}(p)$ for point $p$ denotes the weight of point $p$.

Lemma 3.2**.**

Let $r$ be a square of side length $s$ and let $r^{\prime}$ be a square of side length $s+\epsilon s/2$, with the same centre of gravity. We have $w(r)\leq w^{\prime}(r^{\prime})$.

Proof.

Every point in the sub-trajectory inside $r$ belongs to some segment $p_{g}$ corresponding to tile $p_{t}$ and point $p$. Let $P$ be the set of all points, whose segments are intersected by $r$. Since $r$ contains all or some part of any segment corresponding to these points, $w(r)\leq\sum_{p\in P}w(p)$. Since $r^{\prime}$ is $\epsilon s/4$ longer than $r$ at each side, when $r$ intersects $p_{t}$, the centre of $p_{t}$, $p$, is contained in $r^{\prime}$. Therefore, $\sum_{p\in P}w(p)\leq w^{\prime}(r^{\prime})$, which implies that $w(r)\leq w^{\prime}(r^{\prime})$. ∎

Lemma 3.3**.**

Let $r$ be a square of side length $s+\epsilon s/2$ and let $r^{\prime}$ be a square of side length $s+\epsilon s$, with the same centre of gravity. We have $w^{\prime}(r)\leq w(r^{\prime})$.

Proof.

Let $P$ denote the set of points inside $r$; the point-weight of square $r$ is the sum of the weights of the points in $P$. Suppose $p$ is a member of $P$. Since $p$ is the centre of $p_{t}$ and $p$ is inside $r$, the whole of $p_{t}$ is contained in $r^{\prime}$, because $r^{\prime}$ is $\epsilon s/4$ longer than $r$ at each side. This implies that the whole of $p_{g}$ is inside $r^{\prime}$. Therefore, $\sum_{p\in P}w^{\prime}(p)=\sum_{p\in P}w(p_{g})\leq w(r^{\prime})$, as required. ∎

In Theorem 3.4, we use a data structure for storing $m$ numbers that supports obtaining their maximum in $O(1)$ and increasing the numbers in any continguous interval of the numbers by a value in $O(\log m)$. This can be implemented by augmenting Range Minimum Query (RMQ) data structures, like the Fenwick tree [9], and by storing changes to the leaves of subtrees at internal nodes, instead of updating the value of every node in that subtree.

Theorem 3.4**.**

Given a trajectory $T$ in $R^{2}$ and the value of $s$, after tiling, a square of side length $s+\epsilon s/2$ and with the maximum point-weight can be found with the time complexity $O(m\log m)$, where $m$ is the number of points.

Proof.

To find a square with the maximum weight, it suffices to search among the squares that have a point on each of their lower and left sides (any square with the maximum weight can be moved up and right without changing its point-weight, until their lower and left sides meet a point).

Let $\sigma$ be the sequence of points in $P$, ordered by their $y$-coordinate. We sweep the plane horizontally using two parallel sweep lines with distance $s+\epsilon s/2$ as follows. During the sweep line algorithm, we maintain the point-weight of $m$ squares in the data structure $W$, such that the $i$-th number in $W$ denotes the point-weight of the square whose lower side has the same height as the $i$-th point and its left and right sides are on the sweep lines; we use $r_{i}$ to refer to this square.

In the sweep line algorithm, we process the following events: when the left or the right sweep line intersects a point $p$. We process an event for point $p$ as follows. Let $p$ be the $i$-th item of $\sigma$ and let $j$ be the index of the lowest point in $\sigma$ such that the difference between the height of $p$ and the $j$-th point of $\sigma$ is at most $s+\epsilon s/2$; the value of $j$ can be found using binary search on $\sigma$. When $p$ meets the right sweep line, we increase the weight of every square $r_{k}$ such that $j\leq k\leq i$ by $w^{\prime}(p)$, because every such square contains $p$. Similarly, when $p$ meets the left sweep line, we decrease the weight of every square $r_{k}$ such that $j\leq k\leq i$ by $w^{\prime}(p)$. During the sweep line algorithm, we record the square with the maximum weight in $W$. At the end of the algorithm, it denotes a square with the maximum point-weight among all squares with a vertex on their lower and left sides.

The complexity of sorting $m$ points based on their $y$-coordinate and handling $m$ events, each with complexity $O(\log m)$ is $O(m\log m)$. ∎

In Theorem 3.5, we present and analyse the main algorithm.

Theorem 3.5**.**

Given a trajectory $T$ in $R^{2}$ and the value of $s$, there is an algorithm that finds a $(1+\epsilon)$-approximate hotspot of trajectory $T$ with the time complexity $O({n\phi\over\epsilon}\log{n\phi\over\epsilon})$, in which $\phi$ is the ratio of average length of trajectory edges to $s$.

Proof.

After tiling, as described in the beginning of this section, an edge of length $d$ is subdivided into at most $\lceil{d\over{\epsilon s}}\rceil$ segments. Therefore, if the total length of the edges of $T$ is $a$, the number of resulting segments is at most ${a\over{\epsilon s}}+n$, which is equal to $O({n\phi\over\epsilon})$ asymptotically. Theorem 3.4 shows how the square with the maximum point-weight, $r$, can be found in $O(m\log m)$. Let $r^{\prime}$ be the square with the same centre of gravity as $r$ but of side length $s+\epsilon s$. Also, let $h$ denote the weight of an exact hotspot of $T$. We show that $r^{\prime}$ is a $(1+\epsilon)$-approximate hotspot.

Lemma 3.2 implies that there is at least one square with side length $s+\epsilon s/2$ whose point-weight is equal to $h$, the weight of an exact hotspot of $T$ (of side length $s$). Since, $r$ is the square with the maximum point-weight among squares of side length $s+\epsilon s/2$, its point-weight is at least $h$. Furthermore, Lemma 3.3 shows that the weight of $r^{\prime}$ is at least the point-weight of $r$ (at least $h$). Therefore, the algorithm finds a square of side length $s+\epsilon s$ and with weight at least $h$; a $(1+\epsilon)$-approximate hotspot by Definition 2.3. ∎

We now use the algorithm presented in Theorem 3.5 to find a duration-approximate hotspot of a trajectory in the plane. For that, we need Observation 3.6, which can be shown by placing the smaller squares at the corners of a hotspot.

Observation 3.6**.**

Let $h$ be the weight of an exact hotspot of a trajectory $T$ in the plane. There exists a square of side length $cs$ and weight at least $h/4$, provided that $c\geq 1/2$.

Corollary 3.7**.**

Given a trajectory $T$ in $R^{2}$ and the value of $s$, there is an algorithm that finds a $1/4$-duration-approximate hotspot of trajectory $T$ with the time complexity $O({n\phi}\log{n\phi})$, in which $\phi$ is the ratio of average length of trajectory edges to $s$.

Proof.

Theorem 3.5 for hotspot side length $s^{\prime}=s/2$ and $\epsilon=1$ yields a square $r$ of weight $h$ and side length $s$. Since $h$ is the maximum weight of the squares with side length $s/2$, Observation 3.6 implies that the weight of an exact hotspot of side length $s$ of $T$ cannot be greater than $4h$. Therefore, $r$ is a $1/4$-duration-approximate hotspot of $T$. ∎