Joachim Gudmundsson

Problem
Input: x
1
, … , x n
: moving entities in the plane k: a positive integer r: a positive real value
An axis aligned square σ of side length r is a popular place if at least k entities visit it.
σ
σ is a popular place for k  5

Problem: Two models
Continuous model:
σ is a popular place if it is intersected by polylines from at least k different entities.
Discrete model:
σ is a popular place in the discrete model if it contains input points from at least k different entities.
T
1
σ
T
2


2
2


2
2





Results

What should we output?
• Detect if there exists a popular place?
• Report the popular place with the maximum number of visitors?
• Report “all” popular places?
• …

Continuous model – report all

Continuous model – report all
Problem:
Given a set of polygons, with holes, find a point that stabs a maximum number of polygons.

Idea: Use a sweep-line algorithm
Continuous model – report all

Complexity: O(  2 )
Continuous model – report all

Continuous model – report all
Straight forward approach (almost):
Running time:
Space:
O(t
O(t
2
2 n n
2
2 ) log tn)
Apply topological sweep by Edelsbrunner and Guibas:
Running time:
Space:
O(t
O(t
2
2 n n)
2 )

Continuous model – report all
Find the maximum “colour depth” using topological sweep by Edelsbrunner & Guibas.

Continuous model – report all
Improvement (incl. topological sweep [Edelbsbrunner & Guibas’89])
Running time: O(

2 n 2 )
Space: O(
 n)
Non-trivial to implement due to the degenerate cases.
The problem has an
 ( 
2 n 2 ) lower bound.

Continuous model – report all n=32 t=1000
Time: 5 seconds
Compression + finding all popular places

maximum number of visitors O(  n log  n)
 (  n log  n)
maximum number of visitors O(
 (

2 n 2 )

2 n 2 )
Results

Problem
For analysis, it is often necessary to break a trajectory into pieces according to the behaviour of the entity (e.g., walking, flying, …).
Input: A trajectory T, where each point has a set of attribute values, and a set of criteria.
Attributes: speed, heading, curvature…
Criteria: bounded variance in speed, curvature, direction, distance…
Aim: Partition T into a minimum number of subtrajectories (socalled segments) such that each segment fulfils the criteria.
“Within each segment the points have similar attribute values”

Trajectory T sampled with equal time intervals.
Example

Trajectory T sampled with equal time intervals.
Top right: speed cannot differ more than a factor 2
Example

Trajectory T sampled with equal time intervals.
Bottom left: direction of motion differs by at most 90◦
Example

Example
Trajectory T sampled with equal time intervals.
Bottom right: both criteria are used in conjunction (speed and direction)

Problem
Observation:
Many trajectories span over several activities.
Goal:
Segment a trajectory into subtrajectories according to its behaviour.
We will only consider segmenting trajectories at vertices.

Criteria-Based Segmentation
Goal: Partition trajectory into a small number of segments such that a given criterion is fulfilled on each segment each segment are uniform e.g. heading angular range

Criteria-Based Segmentation
Goal: Partition trajectory into a small number of segments such that a given criterion is fulfilled on each segment
Criteria: heading, speed, location, curvature, sinuosity … and combinations of these e.g., describe movement characteristics

Greedy Algorithm
Definition: A criterion is decreasing monotone, if it holds on a segment, it holds on any subsegment.
Examples: disk criterion (location), angular range (heading), speed…
Theorem: A combination of conjunctions and disjunctions of decreasing monotone criteria is a decreasing monotone criterion.

Greedy Algorithm
Observation:
If criteria are decreasing monotone, a greedy strategy works.

Greedy Algorithm
Observation:
If criteria are decreasing monotone, a greedy strategy works.
For many decreasing monotone criteria Greedy requires O(n) time, e.g. for speed, heading…

Greedy Algorithm
Observation:
For some criteria, iterative double & search is faster.
Double & search: An exponential search followed by a binary search.

Criteria-Based Segmentation
Boolean or linear combination of decreasing monotone criteria
Greedy Algorithm • incremental in O(n) time or constant-update criteria e.g. bounds on speed or heading
• double & search in O(n log n) time for nonconstant update criteria e.g. staying within some radius
[Buchin et al.’11]

Decreasing and Increasing Monotone Criteria
Observation:
For a combination of decreasing and increasing monotone criteria the greedy strategy does not always work.
Example: Min duration 2 AND Max speed range 4 speed
5
1
28

Goal: Delineate stopover sites of migratory geese
• Two behavioural types
 stopover
 migration flight
• Input:
 GPS tracks
 expert description of behaviour
Case Study: Geese Migration

Case Study: Geese Migration
Data
Spring migration tracks
White-fronted geese
4-5 positions per day
March – June
Up to 10 stopovers during spring migration
Stopover: 48 h within radius 30 km
Flight: change in heading <120°
Kees
Adri

Comparison manual computed

Few local differences:
Shorter stops, extra cuts in computed segmentation
Evaluation

Within radius 30km stopover
AND
At least
48h OR
Change in heading
<120° migration flight
Criteria
A combination of decreasing and increasing monotone criteria

Non-Monotone Segmentation
Many Criteria are not (decreasing) monotone:
• Minimum time
• Standard deviation
• Fixed percentage of outliers
Example: Geese Migration
For these Aronov et al. introduced the start-stop diagram
35

Start-Stop Diagram
Algorithmic approach: input trajectory compute start-stop diagram compute segmentation
36

Given a trajectory T over time interval
I = {t
0
,…,t

} and criterion C
The start-stop diagram D is (the upper diagonal half of) the n x n grid, where each point (i,j) is associated to segment [t i
,t j
] with
• (i,j) is in free space if C holds on [t i
,t j
]
• (i,j) is in forbidden space if C does not hold on [t i
,t j
]
A (minimal) segmentation of T corresponds to a (min-link) staircase in D
Start-Stop Diagram forbidden space staircase free space
37

Start-Stop Diagram
A (minimal) segmentation of T corresponds to a (min-link) staircase in D.
5
3
2
4
1
6 7
11
8
12
10
9
5
4
3
2
1
12
11
10
9
8
7
6
1 2 3 4 5 6 7 8 9 10 11 12
123456789101112
38

Start-Stop Diagram
A (minimal) segmentation of T corresponds to a (min-link) staircase in D .
5
3
2
4
1
6 7
11
8
12
10
9
5
4
3
2
1
12
11
10
9
8
7
6
1 2 3 4 5 6 7 8 9 10 11 12
123456789101112
39

Start-Stop Diagram
Discrete case:
• A non-monotone segmentation can be computed in O(n 2 ) time.
1 6
4
5 8 11
12
9 10
7
5
4
3
2
1
12
11
10
9
8
7
6
1 2 3 4 5 6 7 8 9 10 11 12
123456789101112
40

Start-Stop Diagram
Discrete case:
• A non-monotone segmentation can be computed in O(n 2 ) time.
1 6
4
5 8 11
12
9 10
7
5
4
3
2
1
12
11
10
9
8
7
6
1 2 3 4 5 6 7 8 9 10 11 12
[Aronov et al.13]
41

Stable Criteria
Definition:
A criterion is stable if and only if 𝑛 𝑖=𝑜 𝑣 𝑖 = 𝑂(𝑛) where 𝑣 𝑖 = number of changes of validity on segments [0,i], [1,i], …, [i-1,i]
42

Stable Criteria
Definition:
A criterion is stable if and only if 𝑛 𝑖=𝑜 𝑣 𝑖 = 𝑂(𝑛) where 𝑣 𝑖 = number of changes of validity on segments [0,i], [1,i], …, [i-1,i]
Observations:
Decreasing and increasing monotone criteria are stable.
A conjunction or disjunction of stable criterion are stable.
43

Compressed Start-Stop Diagram
For stable criteria the start-stop diagram can be compressed by applying run-length encoding.
Examples: decreasing monotone increasing monotone
9
22

Computing the Compressed Start-Stop Diagram
For a decreasing criterion consider the algorithm:
ComputeLongestValid(crit C, traj T)
Algorithm
:
Move two pointers i,j from n to 0 over the trajectory. For every trajectory index j the smallest index i for which  [I,j] satisfies the criterion C is stored.
9 i j
22

Computing the Compressed Start-Stop Diagram
For a decreasing criterion ComputeLongestValid(crit C, traj T):
Move two pointers i,j from n to 0 over the trajectory
9 i j
Requires a data structure for segment [i,j] allowing the operations
isValid, extend, and shorten, e.g., a balanced binary search tree on attribute values for range or bound criteria.
Runs in O(n  c(n)) time where c(n) is the time to update & query.
Analogously for increasing criteria .
22

Computing the Compressed Start-Stop Diagram
The start-stop diagram of a conjunction (or disjunction) of two stable criteria is their intersection (or union).
9
The start-stop diagram of a negated criteria is its inverse.
The corresponding compressed start-stop diagrams can be computed in O(n) time.
22

Attributes and criteria
Examples of stable criteria
• Lower bound/Upper bound on attribute
• Angular range criterion
• Disk criterion
• Allow a fraction of outliers
• …
22

Computing the Optimal Segmentation
Observation: The optimal segmentation for [0,i] is either one segment, or an optimal sequence of segments for  [0,j<i] appended with a segment [j,i], where j is an index such [j,i] is valid.
Dynamic programming algorithm for each row from 0 to n find white cell with min link
That is, iteratively compute a table
S[0,n] where entry S[i] for row i stores
last: index of last link
count: number of links so far
Runs in O(n 2 ) time
S
22

Computing the Optimal Segmentation
More efficient dynamic programming algorithm for compressed diagrams
Process blocks of white cells using a range query in a binary search tree T
(instead of table S) storing
index: row index
last: index of last link
count: number of links so far augmented by minimal count in subtree
Runs in O(n log n) time
T
[Alewijnse et al.’14]
22

Summary
• Greedy algorithm for decreasing monotone criteria
O(n) or O(n log n) time
[Buchin, Driemel, van Kreveld, Sacristan, 2010]
• Case Study: Geese Migration
[Buchin, Kruckenberg, Kölzsch, 2012]
• Start-stop diagram for arbitrary criteria
O(n 2 ) time
[Aronov, Driemel, van Kreveld, Löffler, Staals, 2012]
• Compressed start-stop diagram for stable criteria
O(n log n) time
[Alewijnse, Buchin, Buchin, Sijben, Westenberg, 2014]
51

Given a query region, does an object (animal, vehicle, …) regularly visit the region?
Regular behaviour?
Every day?
Every month?
Annual migration?
Regular ?
75% of all Saturdays I play football. Regular?
Regular visits

Motivation
Time start inside outside end

Motivation
Time start offset period length
Length = 5 end

Motivation
Time start offset period length end
Length = 9
Visit 78% of the times

Time start period offset period length
Motivation end

Simplest case
Given period offset and period length.
Time period offset period length period offset
0 1 1 0 1 1 1 0 1 1 0
Problem:
Given a bitstring S of length n and a constant 0<c<1, find the longest subsequence S’ of S such that there are at least c  |S’|
1s in S’.

S = 100011100110 f(i) = i
 j=1 s i
Maximize b - a s.t. f(b) - f(a)  c  (b-a)
6
3 f(i)
3 6 9 12
Longest Dense Substring problem g(i) = f(i) – c  i
Maximize b - a s.t. g(b) - g(a)  0
1
0
-1
0 3 g(i)
6 9 12

S = 100011100110 g(i) = f(i) – c  i
Maximize b - a s.t. g(b) - g(a)  0
1
0
-1
0 3 g(i)
6 9 12
Longest Dense Substring problem
Maximize b - a s.t. g(b)  g(a) g(b) must lie on the URE g(a) must lie on the LLE
1
0
-1
0 3
URE
6
LLE
9 12

Longest Dense Substring problem
Longest Dense Substring can be computed in O(n) time
Compressed case:
11100010100000011100000  3,3,1,1,1,6,3,5 size n  size k
Compressed LDS can be computed in O(k) time

Given period length, but no period offset
Given period length
Time

Time
Given period length

Time
Given period length
A offset
Find the longest vertical segment A such that at least a fraction c of the horizontal segments it intersects are
“inside”.

Given period length
Theorem:
Given a set of intervals I, a constant 0<c  1 and a period length p the longest c-dense repetitive pattern over all offsets can be computed in O(n 3/2 log 2 n) time using O(n log n) space.
Time

General case
What if neither period offset nor period length is known?
(no two consecutive visits in the “same region”)
Observation:
The longest pattern can be translated and scaled such that one of its “visits” coincides with the start point of an interval and one
“visit” coincides the start/end point of an interval.

General case
Theorem:
There are O(n 2 ) pairs of distances. Each distance may generate n/c period lengths, thus O(n 3 /c) possible period lengths in total. This also fixes the offset!
The longest c-dense repetitive pattern for each period length can be found in O(n) time, thus O(n 4 /c) time in total.
Can be improved to O(n 7/2 log 3 n).
[Djordjevic et al.’10]

Theorem:
Offset & period length O(n)
Period length
Period length
Nothing
O(n
O(n
3/2
O(n log n) - approximate
7/2 log log
2
3 n) n)
Summary

Open problems

Problem
Input: A Euclidean graph G in the plane
Preprocess G into a data structure such that given a polygonal query curve Q and a positive constant  report all subcurves   G for which
 (  ,Q) ≤ 
G
(  does not need to start and end at a vertex of G)

Q

Previous results
Assume  is given as part of the input
Input: polygonal path P of size n and a constant  >0
Query: segment Q (length >6  )
P de Berg et al.’11: (Counting)
6-distance approximation
Preprocessing O(n 2 + s polylog n)
Space O(s polylog n)
Query time O(n/  s polylog n), for n<s<n 2
Q

A geometric graph G is c-packed if the total length of all the edges of
G inside any ball is at most c times the radius of the ball.
T
Input: O(1)-packed tree T of size n and a constant  >0
Query: polygonal path Q of size m (each segment >2  )
Gudmundsson and Smid:
(3+  ) -distance approximation
Preprocessing O(n polylog n)
Space O(n polylog n)
Query time O(m polylog n)
Our results

A geometric graph G is c-packed if the total length of all the edges of
G inside any ball is at most c times the radius of the ball.
T
Q
Input: O(1)-packed tree T of size n and a constant  >0
Query: polygonal path Q of size m (each segment >2  )
Gudmundsson and Smid:
(3+  ) -distance approximation
Preprocessing O(n polylog n)
Space O(n polylog n)
Query time O(m polylog n)
Our results

Our results
Pros: Extends to trees (instead of paths)
Query path instead of query segment
Approximation improved from 6 to
(1+  ) for query segments
(3+  ) for query paths
Improved preprocessing time
Cons: Input must be O(1)-packed
If G is a tree the edges must be “long” Q
G

References
• M. Benkert, B. Djordjevic, J. Gudmundsson and T. Wolle. Finding popular places.
IJCGA, 2010.
• S. Alewijnse, T. Bagautdinov, M. de Berg, Q. Bouts, A. ten Brink, K. Buchin and M.
Westenberg. Progressive Geometric Algorithms. SoCG, 2014.
• M. Buchin, A. Driemel, M. J. van Kreveld and V. Sacristan. Segmenting trajectories: A framework and algorithms using spatiotemporal criteria. Journal of Spatial Information
Science, 2011.
• B. Aronov, A. Driemel, M. J. Kreveld, M. Loffler and F. Staals. Segmentation of
Trajectories for Non-Monotone Criteria. SODA, 2013.
• M. Buchin, H. Kruckenberg and A. Kölzsch. Segmenting Trajectories based on
Movement States. SDH, 2012.
• B. Djordjevic, J. Gudmundsson, A. Pham and T. Wolle.
Detecting Regular Visit Patterns. Algorithmica, 2011.
74

References
• B. A. Burton. Searching a bitstream in linear time for the longest substring of any given density, Algorithmica, 2011.
• B. Djordjevic and J. Gudmundsson. Detecting areas visited regularly. COCOON 2010.
• M. de Berg, A. F. Cook IV and J. Gudmundsson. Fast Frechet Queries. CGTA, 2013.
• J. Gudmundsson and M. Smid. Frechet queries in geometric trees. ESA,
2013.
75