DOTSSA: Directed Acyclic Graph-Based Online Trajectory Simplification with Stay Areas

Abstract

Devices equipped with the Global Positioning System (GPS) generate massive volumes of trajectory data on a daily basis, imposing substantial computational, network, and storage burdens. Online trajectory simplification reduces redundant points in a streaming manner while preserving essential spatial and temporal characteristics. A representative method in this line of research is Directed acyclic graph-based Online Trajectory Simplification (DOTS). However, DOTS does not preserve stay-related information and can incur high computational cost. To address these limitations, we propose Directed acyclic graph-based Online Trajectory Simplification with Stay Areas (DOTSSA), a fast online simplification method that integrates DOTS with an online stay area detection algorithm (SA). In DOTSSA, SA continuously monitors movement patterns to detect stay areas and segments the incoming trajectory accordingly, after which DOTS is applied to the extracted segments. This approach ensures the preservation of stay areas while reducing computational overhead through localized DAG construction. Experimental evaluations on a real-world dataset show that, compared with DOTS, DOTSSA can reduce compression time, while achieving comparable compression ratios and preserving key trajectory features.

1. Introduction

The widespread use of Global Positioning System (GPS)-equipped devices, including smartphones, drones, and vehicles, has led to the daily generation of massive volumes of trajectory data. In many real-world applications, such trajectories are continuously collected and retained for retrospective analytics, auditing, and model updating. However, storing and transmitting high-rate GPS streams at scale can become cost-prohibitive. If such data are collected every 10 s, a simple estimation indicates that approximately 100 MB of storage is required to store the trajectories of just over 400 objects for a single day [1]. According to statistics released by the U.S. Department of Transportation, motor vehicles in the United States traveled a total of $2.95\times {10}^{12}$ miles in 2011 for longer-distance trajectories [2]. Assuming a speed of 60 miles per hour and a GPS sampling rate of 1/60 Hz, this would generate approximately 53 TB of GPS trajectory data in that year [3].

These data are indispensable for applications such as advanced location-based services such as next location prediction [4,5], travel route recommendation [6,7], and mobility analysis [8,9]. However, their accumulation increases network transmission and storage costs, complicating efficient data processing. Real-world trajectories also contain numerous redundant points that do not contribute to changes in movement direction or speed, resulting in unnecessary computational overhead when stored or analyzed. Trajectory simplification (trajectory compression) addresses these issues by removing redundant points while preserving the spatial and temporal characteristics of the original trajectory, thereby reducing data size and improving processing efficiency.

The existing trajectory simplification algorithms can be categorized as either batch or online approaches. Batch approaches such as Douglas–Peucker (DP) [10], Top-Down Time Ratio (TDTR) [1], and Multiresolution Polygonal Approximation Algorithm (MRPA) [11] assume that a complete trajectory is available and simplify it while controlling the approximation error. Online approaches, including Opening Window (OW) [12], Opening Window Time Ratio (OWTR) [1], Dead Reckoning [13], Spatial QUalIty Simplification Heuristic (SQUISH) [14], Spatial QUalIty Simplification Heuristic-Extended($\mu$)(SQUISH-E($\mu$)) [15], and Directed acyclic graph-based Online Trajectory Simplification (DOTS) [16], simplify trajectories in a streaming manner as new points arrive. The batch approaches typically achieve higher-quality simplification because they utilize the entire trajectory, whereas online approaches support incremental processing suitable for real-time applications.

Although these algorithms effectively preserve the spatial and temporal characteristics of a trajectory, they often fail to retain stay-related information, such as stay areas where users remain for a specified duration. Given the importance of stay areas for understanding traffic congestion [17,18] and user behavior [19,20], it is essential that simplified trajectories preserve this information.

A stay point is detected when a user remains within a specific region for longer than a predefined duration. A stay area is a consecutive sequence of such stay points representing a region where the user has stayed. Figure 1 shows a sample trajectory, where the black points represent the location points, the dashed blue circle denotes the stay area, and the red points indicate the stay points. Within a stay area, GPS points are densely clustered and fluctuate irregularly within a limited spatial region due to the user remaining stationary. As a result, many of these points do not contribute meaningful information to trajectory representation.

To capture the temporal and spatial information of a stay area, retaining only the first and last stay points in each stay area is sufficient. All other stay points within the stay area were therefore regarded as redundant in the current study. Existing trajectory simplification algorithms struggle to achieve high compression rates while preserving stay areas. Although many methods allow parameter tuning to reach a target simplification rate, setting a low rate increases the chance that the start and end points of the stay areas remain but also preserves many redundant points, reducing efficiency. Conversely, setting a high simplification rate removes many points, thereby increasing the likelihood that important stay area points will be discarded.

To address these limitations, this study proposes Directed acyclic graph-based Online Trajectory Simplification with Stay Areas (DOTSSA), an extension of DOTS. DOTSSA integrates SA, an online adaptation of the stay area detection method proposed in [21], with DOTS. DOTS approximates a solution to the min-$\epsilon$ problem, which aims to identify a minimal subset of points that preserves the trajectory while minimizing the simplification error, and it is highly effective for online trajectory simplification [22]. However, DOTS suffers from two limitations: the directed acyclic graph (DAG) optimization is computationally expensive and the stay points are not preserved. DOTSSA applies DOTS to each sub-trajectory segmented by the stay areas extracted by the SA. Consequently, the compression time that DOTSSA achieves is reduced, and the compression rate is high, while ensuring that the stay area in the trajectory data is preserved.

The contributions of this research are summarized as follows.

• We propose DOTSSA, a semantics-aware online trajectory simplification framework that integrates online stay area detection with DOTS and reliably preserves stay areas by applying DOTS to the sub-trajectories segmented at detected stay regions.
• We conduct experiments on a large-scale real-world dataset, demonstrating that DOTSSA substantially reduces compression time compared with DOTS while achieving competitive compression ratios and error metrics against multiple baselines.

The remainder of this article proceeds as follows. Section 2 introduces the definitions and error-based quality metrics used in trajectory simplification. Section 3 presents the proposed DOTSSA method in detail, including the stay area detection algorithm and its integration with DOTS. Section 4 reports the experimental results and performance comparisons with existing methods. Finally, Section 5 concludes this paper and discusses directions for future work.

2. Definitions

2.1. Trajectory

In this study, a trajectory is defined as an ordered sequence of GPS points

$$T=\{p_1,p_2,\dots ,p_N\}$$

(1)

where each point $p_i=(x_i,y_i,t_i)$ consists of longitude $x_i$, latitude $y_i$, and timestamp $t_i$.

For two points $p_s$ and $p_e$$(1\le s<e\le N)$, the line segment $\overline{p_s{p}_e}$ denotes the anchor segment used to approximate the intermediate points, and the points within this interval are represented as $\{p_k\mid s<k<e\}$.

The simplified trajectory is denoted by

$$T^{\prime }=\{p_1^{\prime },p_2^{\prime },\dots ,p_M^{\prime }\}$$

(2)

which is a subsequence of T consisting of points retained during simplification, where M is expected to be much smaller than N.

2.2. Error-Based Quality Metrics

This subsection outlines four widely used error metrics commonly employed to evaluate trajectory simplification. Additionally, DOTS utilizes two error metrics tailored to its unique method. These metrics quantify how well the simplified trajectory preserves the original movement behavior and assess errors from complementary perspectives, because a single metric is often insufficient to capture different types of information loss. Specifically, PED evaluates geometric deviation, SED measures spatio-temporal deviation, DAD quantifies directional changes, and SAD reflects variations in speed-related dynamics. Additionally, DOTS introduces two SED-based metrics, LISSED and ISSED, to support procedures for selecting compression points. The geometric definitions of these metrics are illustrated in Figure 2.

2.2.1. Perpendicular Distance Error (PED)

PED measures the shortest distance from a point $p_k$ to the anchor segment $\overline{p_s{p}_e}$ and is defined as follows:

$$\mathrm{PED}(p_s,p_k,p_e)={\displaystyle \frac{\left|(y_e-y_s)x_k-(x_e-x_s)y_k+x_e{y}_s-y_e{x}_s\right|}{\sqrt{{(y_e-y_s)}^2+{(x_e-x_s)}^2}}}$$

(3)

2.2.2. Synchronized Euclidean Distance (SED)

SED extends PED by incorporating temporal information, evaluating the Euclidean distance between a point and its synchronized point on the anchor segment. This metric evaluates the Euclidean distance between the actual point $p_k$ and its synchronized point, $p_k^{\ast }$, which is defined on the anchor segment $\overline{p_s{p}_e}$ at corresponding time $t_k$. SED is defined as follows:

$$\begin{array}{c}\hfill \begin{array}{cc}\hfill \mathrm{SED}(p_s,p_k,p_e)& =\sqrt{{(x_k-x_k^{\ast })}^2+{(y_k-y_k^{\ast })}^2}\hfill \\ \hfill x_k^{\ast }& =x_s+{\displaystyle \frac{t_k-t_s}{t_e-t_s}}(x_e-x_s)\hfill \\ \hfill y_k^{\ast }& =y_s+{\displaystyle \frac{t_k-t_s}{t_e-t_s}}(y_e-y_s)\hfill \end{array}\end{array}$$

(4)

2.2.3. Direction-Aware Distance (DAD)

DAD quantifies the directional deviation between the anchor segment $\overline{p_s{p}_e}$ and the segment $\overline{p_s{p}_k}$ based on their azimuth angles. Considering the periodicity of the angles, DAD is defined as follows:

$$\begin{array}{c}\hfill \begin{array}{cc}\hfill \mathrm{DAD}(p_s,p_k,p_e)& =min(\left|\theta (p_s,p_e)-\theta (p_s,p_k)\right|,2\pi -\left|\theta (p_s,p_e)-\theta (p_s,p_k)\right|)\hfill \\ \hfill \theta (p_s,p_e)& =\mathrm{atan}2(y_e-y_s,x_e-x_s)\hfill \\ \hfill \theta (p_s,p_k)& =\mathrm{atan}2(y_k-y_s,x_k-x_s)\hfill \end{array}\end{array}$$

(5)

2.2.4. Speed-Aware Distance (SAD)

SAD measures the deviation between the actual speed from $p_k$ to $p_{k+1}$ and the estimated speed between the synchronized points $p_k^{\ast }$ and $p_{k+1}^{\ast }$ on the anchor segment. SAD is defined as follows:

$$\mathrm{SAD}(p_s,p_k,p_e)=\left|{\displaystyle \frac{d(p_k,p_{k+1})}{t_{k+1}-t_k}}-{\displaystyle \frac{d(p_k^{\ast },p_{k+1}^{\ast })}{t_{k+1}-t_k}}\right|$$

(6)

where $d(·,·)$ denotes the Euclidean distance between two points and $p_k^{\ast }$ and $p_{k+1}^{\ast }$ are defined in the same manner as in SED.

2.2.5. Integral Squared Synchronized Euclidean Distance (ISSED)

ISSED evaluates the overall approximation error of a simplified trajectory $T^{\prime }$ by accumulating the squared SED values over all anchor segments induced by $T^{\prime }$. ISSED is defined as follows:

$$\mathrm{ISSED}\left(T^{\prime }\right)=\sum _{k=1}^{M-1}\mathrm{LISSED}(k,k+1)$$

(7)

Here, the Local Integral Squared Synchronized Euclidean Distance (LISSED), denoted by $\mathrm{LISSED}(s,e)$, is defined for the sub-trajectory between the anchor points $p_s$ and $p_e$ as the sum of the squared SED values over all points $p_k$ in that interval:

$$\begin{array}{cc}\hfill \mathrm{LISSED}(s,e)& =\sum _{s<k<e}\mathrm{SED}{(p_s,p_k,p_e)}^2\hfill \\ \hfill & =(c_1^2+c_3^2)(e-s-1)+(c_2^2+c_4^2)(S_{t^2}^{e-1}-S_{t^2}^s)\hfill \\ \hfill & +2(c_1{c}_2+c_3{c}_4)(S_t^{e-1}-S_t^s)\hfill \\ \hfill & +(S_{x^2}^{e-1}+S_{x^2}^s)+(S_{y^2}^{e-1}+S_{y^2}^s)-2c_1(S_x^{e-1}+S_x^s)\hfill \\ \hfill & +2c_3(S_y^{e-1}+S_y^s)-2c_2(S_{xt}^{e-1}+S_{xt}^s)+2c_4(S_{yt}^{e-1}+S_{yt}^k)\hfill \end{array}$$

(8)

where

$$\begin{array}{cc}\hfill c_1& ={\displaystyle \frac{x_s{t}_e-x_e{t}_s}{t_e-t_s}},c_2={\displaystyle \frac{x_e-x_s}{t_e-t_s}},c_3={\displaystyle \frac{y_s{t}_e-y_e{t}_s}{t_e-t_s}},c_4={\displaystyle \frac{y_e-y_s}{t_e-t_s}}\hfill \\ \hfill S_x^i& =\sum _{j=1}^i{x}_j,S_y^i=\sum _{j=1}^i{y}_j,S_t^i=\sum _{j=1}^i{t}_j,S_{x^2}^i=\sum _{j=1}^i{x}_j^2\hfill \\ \hfill S_{y^2}^i& =\sum _{j=1}^i{y}_j^2,S_{t^2}^i=\sum _{j=1}^i{t}_j^2,S_{xt}^i=\sum _{j=1}^i{t}_j{x}_j,S_{yt}^i=\sum _{j=1}^i{t}_j{y}_j\hfill \end{array}$$

(9)

3. Proposed Method

This section presents DOTSSA, the proposed trajectory simplification method that integrates DOTS with the stay area detection procedure SA. An overview of DOTSSA is shown in Figure 3. We first describe SA and DOTS separately and then explain how DOTSSA combines them to perform efficient simplification while preserving stay areas.

3.1. SA

As illustrated in Figure 1, SA defines stay points as points satisfying distance and time thresholds within the dashed blue stay area and defines a stay area as the consecutive sequence of such stay points in the trajectory data that satisfies all of the following conditions:

$$\begin{array}{cc}\hfill a& <i\hfill \\ \hfill d(p_a,p_{i-1})& \le T_{\mathrm{distance}}\hfill \\ \hfill d(p_a,p_i)& >T_{\mathrm{distance}}\hfill \\ \hfill \Delta t_{i-1,a}& \ge T_{\mathrm{time}}\hfill \end{array}$$

(10)

$d(·,·)$ is the Euclidean distance between two points. $T_{\mathrm{distance}}$ is the distance threshold between two points. $T_{\mathrm{time}}$ is the threshold of the difference in the timestamps between the two points. $\Delta t_{·,·}$ is the time difference between two points.

In (10), the condition $d(p_a,p_{i-1})\le T_{\mathrm{distance}}$ indicates that the trajectory remains within a spatial neighborhood centered at the candidate start point $p_a$ up to point $p_{i-1}$. The subsequent condition $d(p_a,p_i)>T_{\mathrm{distance}}$ means that the newly arrived point $p_i$ lies outside this neighborhood; i.e., the object has just left the stay vicinity, and thus the stay interval ends at $p_{i-1}$. Finally, $\Delta t_{i-1,a}\ge T_{\mathrm{time}}$ requires that the residence time within the neighborhood is at least $T_{\mathrm{time}}$, filtering out short stops (e.g., brief pauses) and ensuring that the detected interval corresponds to a meaningful stay.

Algorithm 1 shows SA satisfying the above condition, with SA being an online algorithm for extracting stay areas. In SA, whenever a new point $p_i$ arrives, the algorithm computes the distance $d(p_a,p_i)$ between $p_i$ and the current monitoring start point, $p_a$. If this distance remains below the distance threshold $T_{\mathrm{distance}}$, the user is likely to remain within the same local region and the monitoring process continues. Conversely, when $\mathrm{d}(p_a,p_i)$ exceeds the threshold, the previous point $p_{i-1}$ is treated as a candidate end point of the stay interval, and the algorithm checks whether the duration of stay, computed as $t_{i-1}-t_a$, meets or exceeds the time threshold, $T_{\mathrm{time}}$. After processing the candidate interval, SA resets the monitoring start point to the current point $p_i$ and continues the same procedure for subsequent points.

Algorithm 1 SA ($\mathrm{d}(·,·)$ denotes the Euclidean distance).

Require: Point stream $\left\{p_i\right\}$, distance threshold $T_{\mathrm{distance}}$, time threshold $T_{\mathrm{time}}$ Ensure: Start point and end point of each stay area   1: $a\leftarrow 1$   2: for each newly arrived point $p_i$ do   3:       if $\mathrm{d}(p_a,p_i)\le T_{\mathrm{distance}}$ then   4:           continue   5:       else   6:             if $t_{i-1}-t_a\ge T_{\mathrm{time}}$ then   7:                  output $(p_a,p_{i-1})$   8:             $a\leftarrow i$   9: if $t_i-t_a\ge T_{\mathrm{time}}$ then           ▹ Flush pending stay interval at stream end 10:       output $(p_a,p_i)$

3.2. DOTS

DOTS is an online trajectory simplification method that incrementally determines an approximately optimal simplified trajectory by constructing a DAG. An overview of the DOTS is presented in Algorithm 2. In DOTS, each location point in the original trajectory is treated as a node, and a directed edge is added between two nodes only when the approximation error representing the segment with a straight line is below a predefined threshold, $\epsilon$.

Algorithm 2 DOTS.

Require: Point stream $\left\{p_i\right\}$, threshold $\epsilon$, factor $\eta$, k = 1 Ensure: Simplified trajectory $T^{\prime }$   1: Initialize $V_1=\left\{p_1\right\}$, $k=1$, $\alpha \left(p_1\right)=0$, $d=1$   2: while a new point $p_j$ arrives do   3:       for each $p_i\in V_k$ do   4:             if $p_i\in Ter{m}_k$ then continue   5:             else if $\mathrm{LISSED}(p_i,p_j)<\epsilon$ then   6:                  $V_{k+1}\leftarrow V_{k+1}\cup \left\{p_j\right\}$   7:                  add edge $(p_i,p_j)$   8:                  break   9:             else if $\mathrm{LISSED}(p_i,p_j)>\eta \epsilon$ then 10:                  $Ter{m}_k\leftarrow Ter{m}_k\cup \left\{p_i\right\}$ 11:       if $Ter{m}_k=V_k$ then 12:             Choose $Paren{t}^{\ast }\left(p_j\right)$ via Equation (15) 13:             Update $\alpha \left(p_j\right)$ 14:             $k\leftarrow k+1$ 15:             $V_k\leftarrow \left\{p_j\right\}$ 16:             continue 17:       while $V_d$ has exactly one alive node q do 18:             $T^{\prime }\leftarrow T^{\prime }\cup q$ 19:             $d\leftarrow d+1$ 20: Backtrack remaining alive nodes and append the final path to $T^{\prime }$

A DAG is made up of two sets: the node set V and the edges set E. V contains all the points of T. For any pair of location points $(p_i,p_j)$ with $i<j$, a directed edge $(p_i\to p_j)$ is added if $\mathrm{LISSED}(i,j)$, computed over the interval $(i,j)$, is smaller than $\epsilon$.

$$E=\left\{(p_i\to p_j)|i<j,\mathrm{LISSED}(i,j)<\epsilon \right\}$$

(11)

As a result, a DAG is constructed from the trajectory, as illustrated in Figure 4.

For each node $p_j$, the layer number is updated by

$$L_{\epsilon }\left(p_j\right)=\underset{i<j,\mathrm{LISSED}(i,j)<\epsilon }{min}\left(L_{\epsilon }\left(p_i\right)+1\right)$$

(12)

and the set of nodes belonging to the kth layer is defined as

$$V_k=\{p_j\mid L_{\epsilon }\left(p_j\right)=k\}$$

(13)

Through this layer construction, the DAG is incrementally extended as new points arrive.

The cumulative error of a node $p_j$ is computed using its parent node, $Parent\left(p_j\right)$, as follows:

$${\alpha }_{p_j}={\alpha }_{Parent\left(p_j\right)}+\mathrm{LISSED}(Parent\left(p_j\right),j).$$

(14)

The optimal parent of $p_j$ is then selected from the candidate nodes in the same layer by minimizing the cumulative error:

$$Paren{t}^{\ast }\left(p_j\right)=\underset{p_i\in V_k,\mathrm{LISSED}(i,j)<\epsilon }{arg\; min}\left({\alpha }_{p_i}+\mathrm{LISSED}(i,j)\right)$$

(15)

This process yields a locally optimal parent selection while maintaining the desired number of simplified points.

In the DAG, the nodes that remain reachable from subsequent layers are referred to as alive nodes. An alive node is defined as a point that retains the possibility of being included in the final simplified trajectory and whose parent–child relationships have not been pruned. When a layer contains a single alive node, that node is guaranteed to appear in the simplified trajectory. DOTS immediately outputs such a node as a confirmed simplified point, enabling online processing without waiting for the entire trajectory to be received. DOTS excludes nodes whose cumulative error exceeds $\eta \epsilon$, thereby reducing any unnecessary edge generation and improving the efficiency of DAG construction. Using this mechanism, DOTS achieves practical computational performance while maintaining near-optimality guarantees.

3.3. DOTSSA

The overall procedure is presented in Algorithm 3. For each incoming point $p_i$, the SA performs online stay area detection. When a stay area is detected, its starting point is used as a segmentation boundary to finalize the current buffered segment. DOTS is then applied to this segment to produce a locally simplified sub-trajectory; the resulting representative points are appended to the global simplified trajectory.

Algorithm 3 DOTSSA.

Require: Point stream $\left\{p_i\right\}$, error threshold $\epsilon$, stay thresholds $(T_{\mathrm{distance}},T_{\mathrm{time}})$ Ensure: Simplified trajectory $T^{\prime }$ 1: $T^{\prime }\leftarrow \varnothing$, $B\leftarrow \varnothing$ 2: for each new point $p_i$ in the stream do 3:       $B\leftarrow B\cup \left\{p_i\right\}$ 4:       $(p_{\mathrm{start}},p_{\mathrm{end}})\leftarrow \mathrm{SA}\left(p_i\right)$ 5:       if a stay area is detected then 6:             Extract S from B consisting of points from the head of B to $p_{\mathrm{start}}$ 7:             $T^{\prime }\leftarrow T^{\prime }\cup \mathrm{DOTS}\left(S\right)$        ▹$\mathrm{DOTS}\left(S\right)$ applies DOTS to all points contained in S 8:             Clear B 9:             $B\leftarrow \left\{p_{\mathrm{end}}\right\}$

By repeating this process iteratively, DOTSSA achieves online trajectory simplification that preserves stay areas while incorporating the shape approximation provided by DOTS. DOTSSA effectively balances stay region preservation with geometric accuracy, enabling high-quality and computationally efficient trajectory simplification.

3.4. Time Complexity

This subsection provides an analysis of the time complexity of DOTSSA.

First, the SA performs a constant-time distance and dwell-time threshold check for each incoming point $p_i$, and the cost of this check is $\mathcal{O}\left(1\right)$. Therefore, if the number of input points is N, the computational complexity of SA is $\mathcal{O}\left(N\right)$.

The computational complexity of DOTS is $\mathcal{O}\left({\displaystyle \frac{N^2}{L}}\right)$, where N denotes the number of points contained in the target segment and L represents the number of DAG layers. The worst-case complexity of DOTS is $\mathcal{O}\left(N^2\right)$, which occurs when $\epsilon$ is small and most points remain in the upper layers (e.g., most points remain in $V_2$), resulting in dense edge tests. On the other hand, the best-case complexity of DOTS is $\mathcal{O}\left(N\right)$, which happens when $\epsilon$ is sufficiently large such that each layer contains only one node, making the processing nearly linear.

If DOTSSA detects S stay areas in the input trajectory, the overall computational complexity is expressed as follows:

$$\mathcal{O}\left(N\right)+\sum _{i=1}^S\mathcal{O}\left({\displaystyle \frac{N_i^2}{L_i}}\right),\mathrm{where}\sum _{i=1}^S{N}_i=N$$

(16)

Here, $N_i$ denotes the number of points contained in the i-th trajectory segment to which DOTS is applied and $L_i$ represents the number of layers in the corresponding DAG. Thus, the computational cost of DOTSSA is influenced by how the trajectory is segmented by stay area detection. As the number of detected stay areas S increases, the trajectory is divided into many smaller segments, effectively reducing each $N_i$. In particular, in mobility trajectories where users tend to make frequent stops, such as at intersections, shops, and public transport stations, multiple stay areas are commonly observed. As a result, DOTSSA improves its efficiency significantly by processing each segment independently with a smaller computation size.

In the worst case, no stay area is detected and DOTS is executed only once over the entire trajectory. In other words, aside from the SA checks, DOTS is applied to the whole trajectory. In this case, $S=1$ and $N_1=N$, and therefore the computational complexity of DOTSSA becomes identical to that of DOTS:

$$\mathcal{O}\left({\displaystyle \frac{N^2}{L}}\right)$$

(17)

On the other hand, if the trajectory is split into many small segments due to frequent stay area detections, the size of each segment becomes close to a constant. In this scenario, the complexity of DOTSSA becomes linear:

$$\mathcal{O}\left(N\right)+\mathcal{O}\left({\displaystyle \frac{N}{L}}\right)=\mathcal{O}\left(N\right)$$

(18)

In summary, the computational complexity of DOTSSA depends on the number of stay areas contained in the trajectory, while its upper bound remains the same as that of DOTS. For real-world trajectories that often include multiple stay areas, DOTSSA frequently achieves near-linear time performance by dividing the trajectory into smaller sub-trajectories and performing efficient localized DAG construction.

4. Evaluation

Two experiments were conducted to evaluate the effectiveness of DOTSSA.

• An evaluation under fixed error thresholds $\epsilon$, focusing on a comparison with DOTS.
• A comparison under controlled compression rates, in which the parameters of each method were tuned to achieve predefined rates and compared with multiple baseline methods.

4.1. Evaluation Conditions

All the experiments were conducted using the Microsoft GeoLife dataset [23,24,25], which covers various transportation modes, such as walking, driving, and trains. Trajectories were segmented whenever the interval between consecutive points exceeded 5 min; segments containing fewer than 100 points were removed from the dataset. After preprocessing, 39,162 trajectories remained. The average trajectory length was approximately 638 points and the median was 371 points; the average sampling interval was 3.1 s and the median was 2.0 s.

The stay area detection thresholds used in SA followed the batch-based method in [21]: the distance threshold $T_{\mathrm{distance}}$ was set to 15 m and the time threshold $T_{\mathrm{time}}$ to 30 s.

Simplification performance was evaluated using six metrics: PED error, SED error, SAD error, DAD error, compression rate, and compression time. The PED, SED, SAD, and DAD errors are computed as the average values of their respective error functions. The PED error is defined as follows:

$$\mathrm{PED}\mathrm{Error}={\displaystyle \frac{1}{\left|T\right|}}\sum _{i=1}^{\left|T\right|}{\displaystyle \frac{1}{R_i}}\sum _{j=1}^{R_i}\mathrm{PED}\left(pc\left(r_{ij}\right),r_{ij},sc\left(r_{ij}\right)\right)$$

(19)

where $\left|T\right|$ is the number of trajectories, $R_i$ is the number of redundant points removed from the ith trajectory, and $r_{ij}$ is the jth redundant point. The functions, $pc\left(r_{ij}\right)$ and $sc\left(r_{ij}\right)$, denote the first compressed points found by searching forward and backward from $r_{ij}$, respectively. The other error metrics were defined analogously using their corresponding functions.

Because GPS points within stay areas (Figure 1) are often clustered densely and exhibit irregular fluctuations, including them in the error calculations can cause disproportionate distortion. To ensure a fair comparison, stay area intervals were excluded when computing the error metrics.

4.2. Comparison Result Under Fixed $\epsilon$

DOTSSA and DOTS were compared while varying the error threshold $\epsilon$ within the range $\epsilon \in \{1.0,5.0\}\times \{{10}^{-7},{10}^{-6},{10}^{-5},{10}^{-4}\}$.

4.2.1. Compression Time

As shown in Figure 5, DOTSSA consistently achieved a shorter compression time than DOTS across all settings, with the largest reduction (approximately 75%) observed at $\epsilon =5\times {10}^{-4}$.

When $\epsilon$ is small (e.g., $\epsilon =1.0\times {10}^{-7}$), the compression time of DOTSSA is almost the same as that of DOTS. Under such strict error constraints, DOTS generates many layers, each containing only a few points, resulting in fewer LISSED computations within each layer. This keeps the computational cost low and reduces the compression time. Because DOTSSA also applies DOTS to the trajectory segments, its compression time remains similarly low, leading to comparable performance between the two methods.

In contrast, when $\epsilon$ becomes large (e.g., $\epsilon =1.0\times {10}^{-4}$), the compression time gap between DOTS and DOTSSA increases significantly. DOTS incorporates many points into a single layer, which increases the number of LISSED computations and thereby the overall compression time. On the other hand, DOTSSA segments the trajectory according to stay areas, reducing the number of points processed by each DOTS instance and enabling the construction of smaller DAGs. These results confirm that stay area-based segmentation and localized DAG construction allow DOTSSA to achieve higher computational efficiency than DOTS, particularly when the error tolerance is large.

In summary, DOTSSA achieves fast online trajectory simplification by effectively controlling the DAG size through stay area-based segmentation, allowing it to consistently outperform DOTS in computational efficiency across a wide range of error tolerance settings.

4.2.2. Compression Rate

In Figure 6, when $\epsilon$ is small, very few points can be removed under such a strict error bound, resulting in a low compression rate in DOTS, although the compression time remains small. Under such conditions, DOTSSA exhibits a slightly lower compression rate than DOTS. This is because DOTSSA always retains the points extracted by SA, as well as the start and end points of each segment. In addition, because DOTSSA applies DOTS separately to each segment, it tends to preserve more representative points overall. Consequently, DOTSSA may retain points that DOTS considers redundant, leading to a slightly lower compression rate.

In contrast, when $\epsilon$ becomes large, the compression rates of both DOTS and DOTSSA increase, since a larger $\epsilon$ allows more points to be omitted from the simplified trajectory. However, this also significantly increases the compression time of DOTS, as shown in Figure 6. By contrast, DOTSSA effectively suppresses this increase in execution time because stay area-based segmentation limits the number of points processed in each localized DAG construction.

Therefore, this outcome reflects a trade-off: while DOTSSA preserves stay area semantics at the expense of a slightly reduced compression rate, it nevertheless achieves faster execution than DOTS, demonstrating superior computational efficiency.

4.2.3. Error Metrics

As shown in Figure 7a–c, the difference between DOTS and DOTSSA in the spatial and temporal error metrics becomes more pronounced as $\epsilon$ increases, with DOTSSA exhibiting smaller errors. Although the compression rate decreases for larger $\epsilon$ values, as indicated in Figure 6, DOTSSA retains the boundary points of each stay area, which helps maintain slightly higher spatial fidelity than DOTS. Conversely, when $\epsilon$ is small, the compression rates of both methods are low, and thus the spatial and temporal characteristics of the trajectory are well preserved in both cases. These results reflect the trade-off between compression rate and the preservation of stay area information discussed earlier.

In contrast, DOTSSA yielded a larger DAD error (Figure 7d). Because stay areas contain many small directional fluctuations but SA preserves only their boundary points, the approximating segment can deviate from the true heading. As DAD is sensitive to directional changes, this omission may lead to an increased error.

Overall, DOTSSA substantially reduced computation time while maintaining competitive spatial and temporal accuracy relative to DOTS in most parameter settings. Although DOTSSA may yield slightly larger directional or speed-related deviations in certain cases, it consistently preserves stay area semantics and provides a practical balance between computational efficiency and trajectory fidelity under fixed $\epsilon$.

4.3. Comparison Under Fixed Compression Rates

4.3.1. Compression Rate

This experiment compared DOTSSA with DOTS, OW, OWTR, and SQUISH-E($\mu$) at fixed compression ratios of 0.1, 0.3, 0.5, 0.7, and 0.9. Because each method must be tuned to achieve the target rate, the parameter search was computationally expensive; thus, 1000 trajectories were randomly sampled for evaluation. DOTSSA and DOTS tuned the error threshold, $\epsilon$; OW tuned its PED threshold; and OWTR and SQUISH-E($\mu$) tuned their SED thresholds.

DOTSSA outperformed DOTS in terms of compression time, particularly when the compression rate was high (Figure 8). Under such high-compression settings, the DAG construction cost in DOTS increases rapidly, whereas DOTSSA effectively suppresses the DAG size by segmenting the trajectory based on stay areas, leading to a significant performance advantage. This result indicates that the proposed method preserves the computational benefits of DOTS while greatly reducing the overhead associated with DAG expansion when strong compression is required.

OW and SQUISH-E($\mu$) were consistently faster than DOTSSA across all compression rate settings. OW achieves its speed by recursively simplifying the trajectory using PED, which is computationally inexpensive. SQUISH-E($\mu$) also offers fast processing because it simplifies trajectories using a queue-based heuristic and requires only local error checks, resulting in a low computational overhead. In contrast, OWTR is fast when the compression rate is low but becomes the slowest method when stronger compression is applied. This is likely due to OWTR recursively simplifying the trajectory while computing SED, which incurs a higher computational cost. However, none of these methods preserve stay area semantics, and they are not optimized for SED, which may lead to the loss of important semantic information in the trajectory.

Overall, the results in Figure 8 confirm that DOTSSA is a practical and efficient method that preserves stay area semantics while achieving superior compression speed compared with DOTS. The strong advantage under high-compression settings is particularly valuable for real-time applications and large-scale trajectory data processing.

4.3.2. Error Metrics

Figure 9a,b indicate that DOTSSA yields slightly smaller PED and SED errors than DOTS when the compression rate is below 0.7. For example, at a compression rate of 0.7, DOTSSA improves the PED and SED errors by approximately 13%. Moreover, DOTSSA achieves the smallest spatial errors among all the evaluated methods in this range. These results demonstrate that DOTSSA preserves stay area semantics while maintaining high spatial fidelity during trajectory simplification.

In contrast, at a compression rate of 0.9, DOTS produces lower PED and SED errors than DOTSSA, indicating that DOTS yields a more accurate approximation in this extreme compression regime. When the compression rate is 0.9, DOTSSA exhibits approximately 18% higher PED error and 21% higher SED error than DOTS. Because DOTS optimizes over the entire trajectory, including points within stay areas, it can freely select a very small set of representative points to minimize global error. DOTSSA, on the other hand, must always retain stay area boundary points and respect segment boundaries. Under a fixed high compression rate, these constraints force DOTSSA to discard more non-stay points and restrict its choice of anchor segments, resulting in larger overall approximation errors than DOTS. This observation shows that segmentation-based processing can make DOTSSA suboptimal when the compression rate is extremely high and only a few representative points are allowed.

Figure 9c shows that SQUISH-E($\mu$) achieves the smallest SAD error among all methods because its SED-based local simplification strategy directly incorporates velocity information. In contrast, OW exhibits the largest SAD error because it relies solely on PED and fails to preserve temporal dynamics. DOTSSA, on the other hand, consistently produces smaller SAD errors than DOTS across a wide range of compression rates, particularly below 0.7. This demonstrates that its stay-area-aware segmentation enables more accurate reconstruction of temporal movement characteristics while still achieving efficient compression.

Similarly, Figure 9d demonstrates that DOTSSA yields the smallest DAD error when the compression rate is below 0.7. Because DAD is highly sensitive to directional changes along the trajectory, this result suggests that segment-wise DAG optimization in DOTSSA effectively limits unnecessary heading deviations, thereby improving directional consistency. However, none of the evaluated methods, including DOTSSA, are explicitly designed to preserve directional information. Therefore, the observed advantages should be regarded as secondary effects inherent to the method rather than guaranteed directional optimality. The development of direction-aware optimization techniques and mechanisms for explicitly preserving directional features remains for future work.

Table 1. Compression time and four error metrics at a fixed compression rate of 0.9 with a fixed parameter $\epsilon$.

$\mathit{\epsilon }$	Method	Time [s]	PED [m]	SED [m]	SAD [km/h]	DAD [deg]
$1.0\times {10}^{-7}$	DOTS	0.010	3.224	5.963	2.875	0.132
	DOTSSA	0.007	3.184	5.986	2.835	0.139
$1.0\times {10}^{-6}$	DOTS	0.015	6.862	13.118	4.259	0.159
	DOTSSA	0.008	6.794	13.164	4.186	0.167
$1.0\times {10}^{-5}$	DOTS	0.021	14.395	28.780	5.924	0.194
	DOTSSA	0.009	14.257	28.856	5.764	0.205
$1.0\times {10}^{-4}$	DOTS	0.023	31.978	66.045	7.683	0.245
	DOTSSA	0.006	30.547	62.678	7.286	0.257

summarizes the execution time and error metrics obtained by compressing trajectories with a given $\epsilon$ and selecting the results with compression rate of 0.9.

Compared with DOTS, DOTSSA consistently reduces the execution time across all $\epsilon$ settings. The reduction is particularly pronounced for $\epsilon =1.0\times {10}^{-6}$ and $1.0\times {10}^{-5}$: DOTS requires 0.015 s and 0.021 s, respectively, whereas DOTSSA completes in 0.008 s and 0.009 s, corresponding to an approximate 40–60% reduction. Furthermore, for $\epsilon =1.0\times {10}^{-4}$, DOTSSA achieves 0.006 s compared with 0.023 s for DOTS, yielding a reduction of approximately 74%.

Regarding the error metrics, DOTSSA yields PED and SED values comparable to, or only marginally different from, those of DOTS, and SAD remains at a similar level overall. In particular, for $\epsilon =1.0\times {10}^{-7}$, PED slightly decreases from 3.224 to 3.184 and SAD decreases from 2.875 to 2.835, indicating that DOTSSA maintains spatial and speed fidelity while reducing computation time. By contrast, DAD increases slightly for all $\epsilon$ values; however, the absolute increase is small (approximately 0.007–0.012 deg), suggesting that the degradation in directional accuracy is a limited trade-off relative to the achieved time reduction.

Overall, DOTSSA provides an effective trade-off between computational efficiency and simplification accuracy. It preserves stay area semantics while achieving faster processing and competitive errors compared with existing methods. These results demonstrate the practicality of DOTSSA as a method for real-time trajectory simplification in mobility analysis and location-based applications.

5. Conclusions

This paper presented DOTSSA, an online trajectory simplification method that integrates online stay area detection with the segment-wise application of DOTS. By partitioning input trajectories according to detected stay areas and then applying DOTS independently within each segment, DOTSSA preserves essential stay-related semantics while maintaining efficient computational performance. This design effectively ensures that meaningful behavioral information is retained without sacrificing the benefits of data reduction.

The experimental results show that DOTSSA substantially reduces compression time compared to DOTS, while maintaining lower spatial and temporal errors across a wide range of parameters. These findings demonstrate that DOTSSA provides a good balance between accuracy, compression efficiency, and semantic preservation. Therefore, DOTSSA is well-suited for real-time mobility analysis and large-scale location-based services that require fast processing and behavioral interpretability.

Future work will explore further optimization of the DAG construction process in DOTS to improve scalability for massive trajectory streams. In addition, we plan to extend DOTSSA by incorporating road network constraints and contextual knowledge to enhance spatial accuracy and semantic consistency, particularly in complex urban environments.

Moreover, with the recent proliferation of flight-capable devices such as drones, trajectories that include altitude information in addition to latitude and longitude are becoming increasingly common. Extending our approach to support the simplification of such 3D trajectories is therefore an important direction for future work. Adaptive parameter tuning and applying DOTSSA to emerging trajectory applications, such as intelligent transportation systems and autonomous navigation, represent additional promising directions for future research.