A Grid Based Trajectory Indexing Method for
Moving Objects on Fixed Network
Menglong Huang1,2*, Peng Hu1 , Lanfang Xia3
1
School of Resource and Environment Science, Wuhan University, Wuhan 430072, China
2
Fujian Provincial Geomatics Center, Fuzhou 350003, China
3
Shanghai Surveying and Mapping Institute, Shanghai 200063, China
Corresponding author: longlong273@163.com
Abstract—The management of moving objects is an intensive
study area in recent years. Currently many researches focus on
objects freely moving on 2-dimensional space, and a lot of index
strategies have been proposed, while they are not applicable for
objects moving on fixed networks. As objects moving on fixed
networks are pervasive in real application, its study is of great
practical significance. As changing over time frequently is a main
characteristic of moving objects’ position, index strategies for
moving objects’ trajectories need to provide efficient dynamic
updating ability besides high query performance. In this paper,
we propose an efficient index strategy named Grid Partition R-
Tree (GPR-Tree), for indexing trajectories of moving objects on
fixed network. By dividing the network space into grids of
different size and indexing trajectories in each grid, GPR-Tree
provides efficient query as well as updating performance for
moving objects’ trajectories.
Keywords-GPR-Tree; Moving object; Index structure; Network
model;
I. INTRODUCTION
With the development of GPS, mobile computing and
wireless communication techniques, Vehicle Navigation
(VNS), Location Based Service (LBS), Intelligent
Transportation and other applications spring up. Real-time
tracking and recording moving objects’ position is becoming
more and more important. How to efficiently store, index and
query tremendous trajectory data of moving objects is a hot and
difficult problem of spatio-temporal GIS.
There are three types of object’s movement according to D.
Pfoser [1]: free movements, constrained movements and
movements on network. Currently many researches focus on
managing objects freely moving in 2-dimensional space and a
lot of index strategies have been proposed, including 3D R-
Tree [2], TPR-Tree [3], HR-Tree [4], MV3R-Tree [5], PPR-
Tree [6], etc. As many objects move on road network in real
application, network constrained movements are pervasive and
of great research significance. According to [7], index
strategies for moving objects can be categorized into three
types: index for historical trajectories of moving objects, index
for current trajectories and index for current and future
trajectories. This paper focuses on indexing historical
trajectories of moving objects and proposes an index strategy
named GPR-Tree (Grid Partition R-Tree).
The rest of this paper is organized as follows. In section 2
we introduce the related works, in section 3 we briefly
introduce common network models used in trajectory indexing
and the one that we use, and in section 4 we describes our
index strategy and associated algorithms. In section 5 we make
an analysis about the proposed index structure and an
experiment to evaluate its performance. We conclude the paper
in Section 6.
II. RELATED WORK AND MOTIVATION
Index strategies for trajectories of freely moving objects are
not completely applicable for network constrained moving
objects, as the movements of the latter show much
difference. Kollios et al. [8] held that, as road network can be
indexed with a traditional index, like R-Tree, network
constrained moving objects are moving in a 1.5 dimensional
space in fact. D. Pfoser et al. [9] pointed out that there are
difficulties using a 3-dimensional R-Tree to index network
contrained moving objects’ trajectories as it will introduce
large amounts of “dead space”, and proposed a mapping
algorithm to reduce trajectories’ dimensionality.
There are some index structures proposed for network
constrained moving objects’ trajectories recently. FNR-Tree
(Frentzos, 2003) [10], IMORS (Kyoung-Sook Kim et al. 2004)
[11] and MON-Tree (Almeida and Güting, 2005) [12] are three
main index structures for network contrained moving objects’
trajectories. Some other index structures were also proposed,
such as MON+-Tree [13], FNR+-Tree [14], TNR+-TREE [7],
MONC-Tree [15] etc. They made some modifications to FNR-
Tree or MON-Tree to improve their performance.
FNR-Tree (Fixed Network R-tree) was proposed by
Frentzos in 2003 to index trajectories of moving objects on
fixed network in 2-dimensional space. This index structure is
composed of a 2D R-Tree and a forest of 1D R-Trees. The 2D
R-Tree is used to index spatial road network. Each leaf of the
2D R-Tree points to a road segment and associates a 1D R-
Tree to index the time interval of each object’s movements
inside the road segment. As the basic index unit on the top 2D
R-Tree is a single line segment, there will be too much index
entries. FNR-Tree has to maintain a large number of 1D R-
Trees, which leads to a great amount of storage overhead.
Trajectories that reflect objects’ moving state change between
the start and end point of a line segment can not be indexed
with FNR-Tree, because only time intervals are stored in its 1D
R-Tree. MON-Tree overcomes some drawbacks of FNR-Tree.
It has the similar structure to FNR-Tree. The main difference is
that the basic index unit in the top 2D R-Tree is a route instead
of a line segment, which can greatly reduce the number of
index entries. By replacing the bottom 1D R-Tree with a 2D R-
Tree, MON-Tree can index trajectories recording objects
moving state change at any position of a route. As the size of
MBRs of routes is much larger than those of road segments,
they will result in much dead space and overlapping space in
the top 2D R-Tree and greatly affect query performance of
MON-Tree.
In this paper, we propose a grid partition based index
structure for network contrained moving objects’ trajectories,
named Grid Partition R-Tree (GPR-Tree). GPR-Tree divides
the 2-dimensional network space into grids (or subspaces) of
different size, and index objects’ trajectories in each grid. GPR-
Tree can improve query performance and updating efficiency
by improving index method.
III. ROAD NETWORK MODEL
There are mainly three network models used in indexing
network constrained moving objects’ trajectories: road segment
oriented [10], edge oriented and route oriented [12].
Intersection-Oriented network model also has been proposed
[16]. Road network can be described as a graph, a road
segment is a line ends with two nodes, an edge is a polyline
that ends with two intersections, and a route is composed of
some connected edges. The size of the basic index unit
increases in turn for the index strategies using the three
network models and trajectory update strategies differ too.
Route oriented road network model can reduce trajectory
entries, while it will dramatically decrease query efficiency.
We also notice that when objects moving on road network, the
change of edge is a main factor to trigger trajectory update,
especially on busy roads, as it tends to cause objects’ moving
state change, such as speed, moving direction, etc. Edge
oriented road network model can provide more flexibility for
moving objects related query, such as nearest neighbor query.
Edge oriented road network model is used in GPR-Tree taking
all these into consideration.
Edge oriented network model can be represented as a
collection of edges and intersections: G=(R, J). Here G
represents a graph; R represents a set of edges and J a set of
intersections. An edge can be defined as a polyline ends with
two intersections (not nodes), so edges will not intersect with
each other. We also stipulate that the direction of an edge is
defined by its start and end points, and two flags are used to
represent the direction: 0 means moving from start to end and 1
means from end to start.
In real application, objects’ moving state may change
between the start and end point of an edge. For example, a car
can turn into a car park or stop for more gas at a service station
on a road. In this paper we take into account these cases and
GPR-Tree can index trajectories that describe objects’ moving
state change between the start and end point of an edge.
Moving objects’ position on an edge can be defined as a
fraction between 0 and 1, where 0 means that the position is on
the start point of the edge and 1 means that the position is on
the end point of the edge. In order to distinguish moving
objects’ positions in different edges, we use the real position P
(between 0 and 1) on an edge plus the id of the edge to
represent moving objects’ position, thus moving objects’
position on a edge can be defined as P’ = eid + P, where eid is
the identifier, a integer, of the edge e.
IV. THE GPR-TREE
A. The GPR-Tree Structure
The basic idea of GPR-Tree is partition index. First, we
divide objects’ moving space, or road network space, into grids
of different size, put moving objects’ trajectories into different
grids, to reduce query extent, and then index trajectories in
each grid. GPR-Tree is composed of the top part and the
bottom part, as illustrated in figure 2. The top part is the static
road network index and the bottom part is the dynamic
trajectory index.
Figure 1. GPR-Tree index structure
The top part of GPR-Tree is composed of a 2D R*-Tree
and a hash table. With the 2D R*-Tree, we divide object’s
moving space, i.e. road network space, into grids of different
size. Differs from the top part road network index of FNT-Tree
or MON-Tree, the leaf node of the 2D R*-Tree in GPR-Tree
does not point to a route or a line segment object, but to a grid,
or subspace that should not be divided any more. Network
space is divided according the distribution of edges. We define
that the leaf the 2D R*-Tree can cover M edges at most and m
edges at least. If a node covers more than M nodes, it must be
split. The structure of the root and intermediate nodes of the 2D
R*-Tree is of the form (MBR, {pChild}), where MBR is a
minimum bounding box containing all MBRs of its children’s
MBRs, {pChild} represents pointers to its children. The leaf of
this 2D R*-Tree represents a grid covers edges, whose
structure is of the form (MBR, {e}, pChild), where MBR is the
minimum bounding box of the leaf node, {e} is the identifiers
(IDs) of edges, and pChild is a pointer to a bottom 2D R*-Tree,
which indexes objects’ trajectories fall in this grid. Note there
may be overlaps between grids, but the trajectories have no
overlaps as they are constrained inside an edge. The hash table
is used to improve trajectory updating efficiency. Its entry is of
the form (eid, pGrid), where eid represents the id of an edge
and pGrid points to a grid, or leaf node of the top 2D R*-Tree
(not to the bottom 2D R*-Tree). With this edge-grid hash table,
we can quickly find the grid that an edge falls.
The bottom part of GPR-Tree is a forest of 2D R*-Trees.
Each 2D R*-Tree indexes objects’ trajectories fall in the extent
of a grid. Because an edge oriented road network model is used
in GPR-Tree, each trajectory will fall in one grid and be
indexed only one time. The root and intermediate node
structure of the bottom 2D R*-Tree is in the form of (Ts, Te,
Ps, Pe, pChild), where Ts and Te represent the minimum and
maximum time of the node, Ps and Pe represent position extent
of the node, {pChildren} is a collection of pointers to its
children. The leaf node structure is in the form of (mid, Ts, Te,
Ps, Pe, v, d), where mid is the identifier of the moving object
of the trajectory, Ts and Te represent the start and end time, Ps
and Pe are start and end position, d is moving direction and v is
velocity. In order to indicate the edge where a trajectory falls
on, positions in each node of the bottom 2D R*-Tree is
calculated by the edge’s id plus the position on the edge, as is
described in 3.1. As each edge has a unique id, moving objects’
positions on different edges can be distinguished.
B. Trajectory Update Algrithm
As road network is static, its index can be generated and
network space can be divided beforehand. The difference
between GPR-Tree’s 2D R*-Tree road network index and
other 2D R*-Tree index is that its leaf is a grid contains several
edges instead of a single edge. Note an entry needs to be added
to the edge-grid hash table every time an edge is inserted in
road network index, or update the hash table when the position
of the entry’s edge in the index is changed. It’s not necessary to
take into account network index update while updating objects’
trajectories.
Arguments provided for trajectory update is in the form of
(mid, eid, ps, pe, ts, te), here mid indicates the identifier of
moving object, eid is the identifier of the edge, ps and pe is the
start and end position of trajectory on the edge identified by
eid, and ts and te represent the start and end time of the
trajectory.
Set ps2 = eid + ps and pe2 = eid + pe, then trajectory
update algorithm can be described as follows:
Step1 Using eid to get the grid G where eid falls through
the edge-grid hash table.
Step2 Check if there is a 2D R*-Tree associated with the
grid G, if not, allocate a 2D R*-Tree and associate it with the
grid G.
Step3 Insert the trajectory (mid, rid, ps2, pe2, ts, te) into the
2D R*-Tree using the 2D R*-Tree’s insertion algorithm.
C. Spatio-temporal Window Query Algorithm
The spatio-temporal window query operation of GPR-Tree
can be divided into two stages. First, determine the grids that
intersect with the query extent. Then filter out trajectories
through the bottom 2D R*-Tree associated with each grid.
Arguments provided for spatio-temporal window query is
defined as (xmin, xmax, ymin, ymax, tmin, tmax), and the query
operation is executed in the following steps:
Step1 Define GEOBOX as (xmin, xmax, ymin, ymax), and
TBOX as (tmin, tmax), using 2D R*-Tree’s search algorithm
with GEOBOX to get a collection of leaf nodes, or grids, that
intersect with GEOBOX, in the top 2D R*-Tree. Set the grid
collection as G = {Gi}.
For each grid Gi in the collection, execute Step2 to Step4.
Step2 Retrieve the edges’ Ids E = {Ei} in grid Gi, and the
bottom 2D R*-Tree Ri associated with Gi. For each Ei, follow
Step3 to Step4.
Step3 Retrieve the Edge with Identifier Ei and determine if
Ei intersects with GEOBOX, if so, calculate positions(Psi, Pei)
where GEOBOX intersects Ei, and then get the positions on
this edge (Psi’, Pei’), where Psi’= Psi+ Ei and Pei’= Pei + Ei.
Step4 Compose a query window (Psi’, Pei’, tmin, tmax)
using (Psi’, Pei’) and TBOX, execute 2D R*-Tree’s query
algorithm on the bottom 2D R*-Tree Ri, find a collection of
child nodes {(mid, rid, ps, pe, ts, te)}, then add the mids to the
query result set.
D. On Grid Size
GPR-Tree divides objects’ moving space into grids, or
subspace, through the top 2D R*-Tree. Each grid (a leaf node
of 2D R*-Tree) covers n edges, where m<n<M. When M is too
small, there will be too much 2D R*-Trees in the dynamic part
of GPR-Tree, which has an adverse effect on storage
management. On the other way, the bottom 2D R*-Tree’s size
will be too large when M is big, which will affect trajectory
query and updating efficiency, because R-Tree is a high
balance tree, trajectory insertion involves complex and time
consuming operations such as node splitting and merging. It is
necessary to determine grid size, or M value, as it will greatly
affect GRP-Tree’s performance.
An alternative way is to replace the bottom 2D R*-Trees
with 1D R*-Trees, which only index time interval, as was done
in FNR-Tree, and the leaf node structure remains the same.
Trajectory updating efficiency will be dramatically improved
as insertion operation on 1D R*-Tree is less complex, but
query efficiency will decrease. Its performance needs to be
further examined.
V. PERFORMANCE ANALYSIS AND EXPERIMENT
As each grid contains a number of edges, GRP-Tree has
much less R-Trees in the lower dynamic part than FNR-Tree.
GPR-Tree can index trajectories between start and end point of
an edge, which is a disadvantage of FNR-Tree. Compared to
MON-Tree, GPR-Tree using an edge oriented network modal,
thus has more index entries, but can provide more flexibility
for moving objects related query, such as nearest neighbors
query.
 GPR-Tree can limit the bottom 2D R*-Tree’s size in some
degree through space partition, which helps to improve
trajectory updating efficiency compared to MON-Tree.
Spatio-temporal window query using GPR-Tree needs two
steps. First determining the grids and edges intersecting with
given spatial extent through the top 2D R*-Tree. Then retrieve
trajectories through the bottom 2D R*-Tree with the query
windows formed by time range and each intersecting edge’s
position ranges. The experiment shows that the most time-
consuming part of query is calculating the intersecting
positions of spatial query window and edges. GPR-Tree
provides better query performance than MON-Tree, because it
uses 2D R*-Tree to index road network , and the edge oriented
network model, instead of the route oriented, is used for
network modeling, the latter will result in large “dead space”
and overlapping space.
A personal computer with an Intel Pentium 4 processor, 3
GHz, and 2 GB of RAM is used in the experiment. Road
network data used in the experiment is the base roads of Pitt
County in North Carolina, USA. The road network data is
obtained from the tutorial data of ArcGIS, offered by ESRI,
and GPR-Tree is implemented using C#. Trajectory data are
prepared beforehand using a trajectory editing tool developed
with ArcGIS Engine. We make a comparison of spatio-
temporal window query and trajectory updating performance
between GPR-Tree and route oriented MON-Tree in the
experiment. Experimental result, as illustrated in figure 2 and
figure 3, shows that GPR-Tree’s trajectory updating efficiency
is equivalent to MON-Tree, or a little lower, as it has to index
more trajectories, but it provides better performance for spatio-
temporal window query.
Figure 2. Index updating cost vs. mo Num
Figure 3. Query response time vs. query window size
VI. CONCLUSIONS AND FUTURE WORK
In the paper, a simple and efficient index structure for
network constrained moving objects’ history trajectories,
named GPR-Tree, is proposed based on network space
partition. GPR-Tree is composed of a hash table and a 2D R*-
Tree to index road network, and a forest of 2D R*-Trees to
index trajectories. Algorithms for trajectory update, spatio-
temporal window query are also provided. In the future work,
we will try to combine GPR-Tree with other index methods so
as it can provide more query operations, and introduce parallel
calculating technique to improve its query and updating
efficiency.
REFERENCES
[1] D. Pfoser, “Indexing the Trajectories of Moving Objects,” IEEE Data
Engineering Bulletin, vol.25(2), pp.2-9, 2002.
[2] Y. Theodoridis, M. Vazirgiannis, and T. Sellis, “Spatio-Temporal
Indexing for Large Multimedia Applieations,” in Proceedings of the
IEEE Conference on Multimedia Computing and Systems(ICMCS),
1996.
[3] S. Leutenegger, J. M. Edgington and M. A. Lopez, “STR: A Simple and
Effieient Algorithm for R-tree Packing,” in Proceedings of the 13th
IEEE Conference on Data engineering(ICDE), pp. 497-506, 1997.
[4] M. A. Naseimento, and J. R. O. Silva,“Towards Historical R-Trees,” in
Proceedings of the ACM Symposium on Applied Cmoputing, 1998.
[5] Y. Tao and D. Papadias, “The MV3R-Tree: A Spatio-Temporal Aeeess
Method for Time stamp and Interval Queries,” in Proceedings of the
International Conference on Very Large Databases(VLDB), 2001.
[6] G. Kollios, V. J. Tsotras, D. Gunopulos, A. Delis, and M.
Hadjieleftheriou, “Indexing Animated Objeets Using Spatiotemporal
Aeeess Methods,” IEEE Transactionson Knowledge and Data
Engineerng(TKDE), vol.13(5), pp.758-777, 2001.
[7] Alshaer J. J. and Gubarev V. V., “Indexing Moving Objects on
Transportation Networks,” The Third International Forum on Strategic
Technologies, pp. 249-252, 2008.
[8] G. Kollios, D. Gunopulos and V. Tsotras, “On Indexing Mobile
Objects,” in Proceedings of the 18th ACM Symposium on Principles of
Database Systems, Philadelphia, PA, USA, pp.261-272, 1999.
[9] C. S. Jensen, and D. Pfoser, “Indexing of Network Constrained Moving
Objects,” in Proc. of the 11th Intl. Symp. on Advances in Geographic
Information Systems, 2003.
[10] E. Frentzos, “ Indexing Objects Moving on Fixed Networks,” In Proc. of
the 8th Intl. Symp on Spatial and Temporal Databases, pp.289-305,
2003.
[11] Kyong-Sook Kim, Si-Wan Kim, and Tae-Wan Kim. “Fast Indexing and
Updating Method for Moving Objects on Road Networks,” in Proc. of
the 4th Intl. Conf. on Web Information Systems Engineering
Workshops, pp.34-42, 2003
[12] Victor T. D. A., and Ralf H. G., “Indexing the Trajectories of Moving
Objects in Networks,” GeoInformatica. vol.9 (1), pp.33-60, 2005
[13] ZHANG Jing-min, WANG Pei-chong, and LU Feng-jia, “Indexing
Method of Moving Objects on Networks,” Computer Engineering and
Applications. vol.45(12), pp.144-146, 2009.
[14] GUO JingFeng, WANG JianChao, DONG HongYu and YAN LiHua,
“Indexing Scheme of Moving Objects on Fixed Networks,” Computer
Science. vol.31(7), pp.68-70, 2006.
[15] LI Xuefei, FU Peihong and LIU Jingnan, “Spatio-temporal Index Based
on Networks,” Geomatics and Information Science of Wuhan University.
vol.31(7), pp.620-623, 2006.
[16] Kyoung Soo Bok, Ho Won Yoon, Dong Min Seo, Su Min Jang,
Myoung-Ho Kim, and Jae Soo Yoo, “Indexing the Current Positions of
Moving Objects on Road Networks,” APWeb/WAIM Workshops 2007,
pp.247-252, 2007.