Indexing Moving Objects

1
Indexing Moving Objects

• Presented By
• Mohamed F. Mokbel

2
Moving Object Modeling

• Moving objects in the D-dimensional space send
  their locations using a GPS-like devices.
• It is hard to send/store all the incoming
  information from the moving object.
• Approach I
• The movement of an object is represented by
  position sampling.
• Linear interpolation is used between sample
  points.
• A trajectory consists of connected line segments.
• Approach II
• An object sends its information only when the
  direction is changed.
• The movement of an object is represented by a
  reference point and a velocity vector.

3
Indexing Moving Objects

• Two problems can be distinguished
• Indexing the history of an object
• Indexing the current and the future positions of
  an object

4
Indexing Past Trajectories
Dieter Pfoser, Chrisian S. Jensen, Yannis
Theodorid Novel Approaches in Query Processing
for Moving Object Trajectories. VLDB 2000 395-406
5
Query Types

• Coordinate-Based Queries
• Range Queries Find all objects within a given
  area sometime during a given time interval
• Time Slice Queries A special case of range query
  with window size 0
• Trajectory-Based Queries
• Topological Queries Find all objects that
  (enters/crosses/leaves/bypasses) a given area.
  Such a query involves the whole trajectory.
• Navigational Queries At what speed does this
  plane move.

6
Why NOT R-Tree

• The problem is converted to indexing a set of
  line segments, which is solved by the R-Tree.
• An underlying assumption when using the R-Tree is
  that all inserted geometries are independent.
• R-Tree tends to cluster line segments according
  to its spatial locations.
• Trajectory Preservation is not captured in R-Tree.

7
Spatio-Temporal R-tree (STR-Tree)

• STR-Tree is an extension of the R-Tree, with
  different insert/split algorithm.
• Leaf nodes in the form (id, tid, MBB,
  orientation) instead of (id, MBB) in the R-Tree.
• STR-Tree keeps spatial closeness and partial
  trajectory preservation.
• STR-Tree tries to keep line segments belonging to
  the same trajectory together while keepin spatial
  closeness as the R-Tree
• A parameter p is introduced to balance between
  spatial properties and trajectory preservation. A
  smaller p decreases the trajectory preservation.

8
STR-Tree Insertion

• To insert a new line segment S, we search for the
  leaf node N that contains its predecessor in the
  same trajectory.
• If there is a room, insert S in N. Otherwise,
  search in the p-1 parents.
• If there is a room in the parents, invoke the
  SPLIT algorithm. Otherwise, deal with it as the
  R-Tree.

9
STR-Tree (Split)

• The SPLIT algorithm distinguishes among three
  segment types (disconnected, connected,
  bi-connected).
• The condition for minimum node capacity m in
  R-Tree is relaxed.

10
Trajectory-Bundle Tree (TB-Tree)

• TB-Tree strictly preserves trajectories where a
  leaf node only contains segments belonging to the
  same trajectory.
• As a drawback, line segments of different
  trajectories that lie spatially close will be
  stored in different nodes.
• Leaf node entries in the form (id, MBB,
  orientation), tid can be stored once in the
  header of the leaf node.
• TB-Tree is growing from left to right. The left
  most leaf node was the first and the right most
  is the last inserted one.

11
TB-Tree (Insert)

• To insert a new line segment S, we search for the
  leaf node N that contains its predecessor in the
  same trajectory.
• If there is a room, insert S in N. Otherwise, we
  step up in the tree until we find a non-full
  parent.
• We choose the right most path to insert the new
  node. If there is a room, we insert the new node,
  otherwise, we propagate the insertion to upper
  levels.

12
Trajectory-Preservation in TB-Tree
13
Qualitative Comparison (R-Tree, STR-Tree, TB-Tree)
14
Indexing Current and Future Trajectories
Simonas Saltenis, Christian S. Jensen, Scott T.
Leutenegger, Mario A. Lopez Indexing the
Positions of Continuously Moving Objects. SIGMOD
2000 331-342
15
Problem Setting

• An object position at time t is X(t) (X1(t),
  X2(t),,Xd(t)), t gt tcurrent.
• The object position is modeled as a linear
  function of time, specified by two parameters.
• The object position at a reference time X(tref)
• The velocity vector v(v1,v2,,vd)
• X(t)X(tref)v(t-tref)
• An object reports its position only when a change
  occur to the previously reported position.

16
Why NOT R-Tree ?

• R-tree does not take the velocity and direction
  into consideration

17
Query Types

• Time slice query
• Window Query
• Moving Query

18
Time Parameterized R-Tree (TPR-Tree)

• The TPR-tree is an R-Tree based index structure.
• Points are grouped in a so called conservative
  bounding rectangles
• The lower bound of a conservative interval is set
  to move with the minimum speed of enclosed
  points. The upper bound is set to move with the
  maximum speed of the enclosed points.
• Conservative bounding intervals never shrink.

19
Updating the bounding rectangles

• Since rectangles never shrink, but may actually
  grow too much, it is desirable to be able to
  adjust bounding rectangles occasionally.

20
Queries in TPR-Tree

• Timeslice queries The same as regular R-tree.
  The only difference is that all bounding
  rectangles are computed for the time tq.
• Window/Moving queries Need an efficient
  algorithm for hyper-trapezoid intersection.

21
TPR-Tree operations

• In the regular R-Tree, objective functions
  (e.g., the areas of bounding rectangles, the
  overlapping area) need to be minimized. In the
  TPR-Tree, these functions are time dependent.
• If A(t) is area, the integral computes the area
  of the trapezoid that represents part of the
  trajectory of a bounding rectangle.
• The TPR-Tree insertion algorithm is the same as
  the R-Tree, with one exception instead of using
  the above functions, integrals are used.
• Deletions in the TPR-tree are performed as in the
  R-tree. If a node gets under full, it is
  eliminated and its entries are reinserted.

22
Summary

• Moving objects are modeled either with sampling
  or with a reference point and a velocity vector.
• Theoretically, R-tree like index structures can
  support moving objects. However, special index
  structures can provide trajectory-preservation
  for past queries and time parameterized bounding
  rectangles for future queries.
• STR-Tree provides partial trajectory-preservation
  for past queries.
• TB-Tree provides full trajectory-preservation for
  past queries.
• TPR-Tree provide time parameterized bounding
  rectangles for future queries.