1
Hybrid Long-Range Collision Avoidance for
Crowd Simulation
Abhinav Golas
1
, Rahul Narain
2
, Sean Curtis
1
, and Ming C. Lin, Fellow, IEEE
1
1
University of North Carolina at Chapel Hill
2
University of California, Berkeley
Abstract
—Local collision avoidance algorithms in crowd simulation often ignore agents beyond a neighborhood of a certain size.
This cutoff can result in sharp changes in trajectory when large groups of agents enter or exit these neighborhoods. In this work,
we exploit the insight that exact collision avoidance is not necessary between agents at such large distances, and propose a
novel algorithm for extending existing collision avoidance algorithms to perform approximate, long-range collision avoidance. Our
formulation performs long-range collision avoidance for distant agent groups to efficiently compute trajectories that are smoother
than those obtained with state-of-the-art techniques and at faster rates. Comparison to real-world data demonstrates that crowds
simulated with our algorithm exhibit an improved speed sensitivity to density similar to human crowds.
Another issue often sidestepped in existing work is that discrete and continuum collision avoidance algorithms have different
regions of applicability. For example, low-density crowds cannot be modeled as a continuum, while high-density crowds can
be expensive to model using discrete methods. We formulate a hybrid technique for crowd simulation which can accurately
and efficiently simulate crowds at any density with seamless transitions between continuum and discrete representations. Our
approach blends results from continuum and discrete algorithms, based on local density and velocity variance. In addition to being
robust across a variety of group scenarios, it is also highly efficient, running at interactive rates for thousands of agents on portable
systems.
Index Terms—crowd simulation, collision avoidance, lookahead, hybrid algorithms
F
1 INTRODUCTION
Long-range vision is critical to human navigation;
in addition to avoiding nearby obstacles, the human
visual system looks ahead to perform dynamic global
planning and local navigation. By considering the
distribution of other pedestrians and obstacles over
large distances, people can anticipate overcrowded
regions and navigate around them, thereby finding
efficient, uncongested paths to their goals. Thus long-
range vision greatly improves crowd flow and progress.
Most existing work addresses either global navigation
around static obstacles or local avoidance of collisions
with nearby pedestrians, but often neglects the im-
portance of long-range collision avoidance. Modeling
long-range collision avoidance holds tremendous po-
tential, to improve the flow of simulated crowds and
help them reach their goals faster. To maximize utility,
such a model should improve crowd flow without
disrupting existing crowd simulation pipelines. Thus
we consider this as the primary goal of this work.
The state of the art for this topic is a synthetic-
vision based steering algorithm proposed by Ondrˇej et
al. [1]. This method explores a vision-based approach
for collision avoidance among walkers. It offers global
efficiency among the agents in terms of overall walking
golas@cs.unc.edu
narain@eecs.berkeley.edu
seanc@cs.unc.edu
lin@cs.unc.edu
time. Achieving reasonable performance is perhaps the
key challenge of using this approach for large-scale,
interactive applications. Even a parallel, GPU-based
implementation cannot handle more than 200 agents
at interactive rates. Complementing this approach, our
work addresses this problem by offering a simple and
efficient alternative that naturally extends existing local
collision avoidance algorithms to provide long-range
collision avoidance. Our avoidance algorithm works
based on the concept of lookahead, i.e. future agent
states are approximated using past and present infor-
mation; and these states are used to model possible
collisions with agents not considered by local collision
avoidance. Our method is robust even in presence
of obstacles and chaotic crowd motion, and provides
improved correspondence to real-world behavior.
Collision avoidance algorithms can be broadly clas-
sified into two categories: discrete and continuum –
based on the underlying representation of crowds. We
formulate and demonstrate our lookahead approach
for both classes of algorithms, as the problem is not
restricted to either class. Though our demonstration
in this paper uses specific examples of continuum
and discrete algorithms, our technique can be easily
applied and generalized to other collision avoidance
algorithms.
The use of continuum and discrete algorithms for col-
lision avoidance also brings up a common issue with ei-
ther class, namely their applicability to different ranges
2
Fig. 1. Results without lookahead (left) and with lookahead (right) for 2 demo scenarios.
Crossing
: (Top) shows
two groups of agents seeking to exchange positions at simulation time
t = 10 s
. Note how, with lookahead, the
bigger group parts to allow smaller group through.
Circle
: (Bottom) shows agents on the edge of a circle heading
to diametrically opposite points at simulation time t = 40 s. Note significantly improved progress with lookahead.
of agent density. Continuum algorithms (e.g. [2]) are
ideally suited for medium to high densities, since the
continuum assumption holds when pedestrian paths
are tightly constrained by the nearby neighbors found
at these levels of density. On the other hand, though
discrete algorithms can be applied at any density, their
computational costs escalate at high densities, along
with numerical issues in some cases. Since crowds can
exhibit an entire spectrum of densities even in any
particular scene, these cases are not exceptions, but
common occurrences. This insight suggests the need
for an inexpensive hybrid scheme that locally blends
both approaches for efficient collision avoidance over
the entire spectrum of crowd densities. Such a scheme
should choose the most suitable underlying algorithm
for a particular simulation sub-domain, especially for
problem cases where the wrong choice can lead to
instabilities or other computational issues such as in
scenarios of high or low densities, high variance of
agent velocities, etc.
To address these problems, this paper introduces
the following main results:
•
A novel approach for approximate long-range
collision avoidance that can be used with discrete
or continuum algorithms with minimal increase
in computational costs.
•
An inconsistency metric to measure oscillations
in agent trajectories that can be used to detect
chaotic crowd behavior and curtail lookahead or
to serve as a basis for comparing crowds, real or
simulated.
•
A hybrid algorithm that combines existing contin-
uum and discrete collision avoidance algorithms
to efficiently compute smooth local collision avoid-
ance responses in any sub-domain.
•
Comparison to real-world data that demonstrates
improved speed sensitivity to density in simulated
crowds using our algorithm, similar to human
crowds as measured using the fundamental dia-
gram.
Our results show significant improvements in crowd
progress with minor increases in computational costs
In Fig. 1, we demonstrate our approach on two
scenarios, where improvements in crowd behavior
and progress are seen with less than 3x computational
overhead. Our approach is able to perform interactive
long-range steering for both large, dense crowds and
sparsely populated scenes, but also achieve interactive
rates on a commodity laptop.
2 BACKGROUND
We model a crowd as a set of agents, each of which has
a specified goal position that it attempts to reach while
avoiding collisions with other agents and with static
obstacles in the environment. The standard crowd
3
simulation loop that we and others often use is as
follows:
1)
For each agent, perform global planning to find a
path to the goal that avoids collisions with static
obstacles while ignoring other agents. Set the
preferred velocity
v
p
along the direction of the
initial segment of the path.
2)
For each agent, perform local collision avoidance
(LCA) to steer the preferred velocity
v
p
away
from collisions with other agents, yielding the
actual velocity v that the agent moves with.
Below, we briefly discuss some of the prior work
relating to these two steps and discuss some of the data
and techniques used for validating crowd simulation.
Most algorithms for global planning represent the
connectivity of free space in the environment as a
graph, and perform search queries for each agent to
determine a collision-free path [3], [4], [5], [6], [7], [8],
[9]. We do not diverge from previous work in this
aspect.
A variety of models have been proposed for local
collision avoidance among agents. These may use
either discrete or continuum representations of the
crowd. In discrete models, each agent considers other
agents as individual obstacles, and attempts to avoid
all of them simultaneously. Collision avoidance in this
context can be formulated in terms of repulsion forces
between agents [9], [10], [11], [12], [13], [14], [15], [16],
or geometrically based algorithms [17], [18], [19], [20],
[21]; the state of the art involves treating possible
collisions as obstacles in velocity space [22], [23],
[24], [25]. As considering the interaction of all pairs
of agents becomes expensive in large crowds, such
methods typically only take into account neighboring
agents that lie within a specified radius, limiting the
amount of lookahead possible. Guy et al. [26] propose
a method to mitigate the computational cost of large
neighborhoods by approximately clustering agents.
In a continuum-based approach, one first obtains
from the set of agents a density field and a veloc-
ity field by accumulating the agents’ positions and
velocities on a background grid. This smoothed repre-
sentation can then be used to compute the ideal motion
of agents while avoiding regions of high density. The
method of Treuille et al. [27] performs a global solve
over the obtained density and velocity fields, giving
compelling results including long-range congestion
avoidance effects. However, its computational cost
increases steeply with the number of distinct goals
in the simulation, making this approach unsuitable
for interactive crowd simulation where agents may
have many diverse goals. Narain et al. [2] propose a
technique that prevents overcrowding in highly dense
crowds, but it relies on purely local information and
thus cannot plan around congestion at a large distance.
Validating crowd simulation has always been chal-
lenging. Historically, the presence of so-called “emer-
gent phenomena” has been considered evidence which
suggested correctness. Steerbench is a suite of tests
designed to allow comparison of models [28]. While it
suggests some basis for comparing models, it does
not present (or use) a ground truth; there is no
data of human pedestrians used in performing the
benchmarks.
In the pedestrian dynamics community, the most
common quantitative metrics for crowd behavior deal
with aggregate crowd properties: flow and density.
The relationship between flow and density has been
referred to as the “fundamental diagram” [29]. In
addition to this aggregate analysis, Guy et al. propose
a new statistical metric for measuring how likely a
particular pedestrian model is to match a given set
of data [30]. In recent years, experiments have been
performed with human subjects in various scenarios
and several data sets have been made publicly avail-
able: “one-dimensional” pedestrian movement, uni-
directional movement [31], uni- and bi-directional flow
in a corridor [32], [33], and flow through a bottleneck
[34]. The value of lookahead is greatest in the case of
conflict. As such, we do not perform validation against
the uni-directional corridor or bottleneck flow. Instead,
we perform analysis on an experimental setup similar
to [33]. Ideally, we would prefer data of pedestrians
moving over a large space, however, even in this
limited scenario, we can show that lookahead improves
the behavior of the simulated crowds (see Fig. 12).
Our approach aims to extend some of the existing
work in LCA algorithms to support long-range colli-
sion avoidance queries. We accomplish this through the
simple yet effective approach of extrapolating agents’
motion into the future. Our algorithm is described
in section 3, and we demonstrate its application to
continuum and discrete algorithms in section 3.1 and
section 3.2. In some cases lookahead may not be
possible, particularly in presence of obstacles and
turbulent flow. These are detailed in section 4 in
addition to a novel metric for measuring oscillation
and chaotic behavior in crowds. Furthermore, using
discrete models alone can be extremely expensive in
dense crowds, while continuum models are poorly
suited to representing the motion of sparse crowds.
In section 5, we propose a hybrid algorithm that
blends results from continuum and discrete algo-
rithms, producing consistently realistic results for
both low and high densities under various velocity
conditions. We demonstrate the advantages of our
proposed techniques with examples in section 6, and
compare our proposed lookahead based long-range
collision avoidance algorithm with real-world data in
section 7. Finally, we conclude with the limitations of
our method, and discuss avenues for future work in
section 8.
4
Fig. 2. Effect of extrapolation in time from
x = 0, t = 0
to
x = 4, t = i∆t
. Dotted line indicates effective radius
(
P ≥ 0.4
) of agent for collision avoidance, while spread
of gaussian curve indicates splatting area for density
field creation.
3 LOOKAHEAD FOR LONG-RANGE COLLI-
SION AV OIDANCE
In this section, we describe our approach for efficiently
computing long-range collision avoidance for both
continuum-based and discrete agent-based crowd
models. The problem can be summarized as follows:
For each agent with a given preferred velocity
v
p
(as
computed by the global planning stage), we wish
to find an updated velocity
v
close to the preferred
velocity
v
p
that avoids congestion in front of the agent
at a range of distances from far to near, and also avoids
collisions with neighboring agents. Influences from
nearer agents should receive priority; that is, the agent
should not divert itself to collide with a nearby agent
in trying to avoid congestion farther away.
Given the extensive amount of already existing work
on local collision avoidance algorithms, our aim is to
take advantage of these existing techniques to solve
the problem of long-range collision avoidance. In this
paper, we propose a general approach for decomposing
long-range collision avoidance into a sequence of
simple LCA queries. Thus, our algorithm can re-use
existing LCA algorithms with minimal increase in
computation and coding effort. We show how to apply
this approach to both the discrete and continuum
settings, resulting in efficient algorithms for long-range
collision avoidance in both cases. The crux of the idea
lies in evaluating LCA queries not only on the current
state of the crowd, but on its future state, estimated
at a series of future times, enabling greater lookahead
while using only local operations.
When an agent plans its long-term motion, it needs
to estimate the motion of other agents over a large
time interval into the future. While the future motions
of other agents are of course unknown, they can be
estimated with some degree of confidence using the
agents’ current velocities. To reflect the uncertainty in
this estimation, we treat an agent’s predicted location
in the future not directly as a point, but as a probability
distribution representing the expected probability of
finding the agent at a given position. Intuitively, one
can think of this as a traveling “blob” of probability,
whose center
x(t)
is linearly extrapolated from the
agent’s current position and velocity, and whose
spread
σ(t)
gradually expands over time, reflecting
the increasing uncertainty as one looks further in the
future.
In the continuum representation of the crowd, this
has the effect of smoothing out the influence of any
agent on the crowd density field, which enlarges the
distance over which it influences the motion of other
agents while simultaneously attenuating the magni-
tude of its effect. Thus, when an agent performs a
short lookahead, only its nearby agents are significantly
influential, while over a large lookahead, it only sees
a smoothed-out density field that averages over many
agents across a large area. In the discrete model, an
agent is treated as a rigid, impenetrable “blocker” of
fixed radius. When the agent position is uncertain,
we consider a point to be blocked by the agent if
the probability that the agent covers that point is at
least a certain threshold
p
. As can be seen in Fig. 2,
as the uncertainty increases, the effective size of the
blocker decreases. This has the desirable effect that
agents planning far into the future are not excessively
hindered by the estimated motion of other agents,
given that the latter is unreliable.
With this model for uncertainty, we can formulate
the basic lookahead algorithm for long-range collision
avoidance. The algorithm starts with the preferred ve-
locities
v
p
obtained from the global planning stage, and
performs a number of iterations
i = i
max
, i
max −1
, . . . , 0
with decreasing time horizons
∆t
i
= 2
i−1
∆t, i > 0
,
and
∆t
0
= 0
. In each iteration, we extrapolate the
state of the crowd by a time interval
∆t
i
into the
future, perform an LCA query (with uncertainty) using
the preferred velocity, and then replace the preferred
velocity with the result of the LCA, as illustrated in
Fig 3. In the last iteration, we set the lookahead
∆t
0
to zero, so that we perform the standard LCA with no
uncertainty, and thus maintain the collision avoidance
guarantees of the underlying LCA.
With this scheme, agents are sampled in a larger
radius than in the standard LCA query, and extrap-
olated queries are biased towards the direction of
motion, providing lookahead. Our approach smoothly
merges the effects of distant and nearby avoidance
considerations. Congestion avoidance with a long
time horizon takes place in earlier levels, influencing
the final result by updating the preferred velocity;
nevertheless, this can still be overridden if needed to
avoid imminent collisions with nearby agents, which
are considered later in the process.
The algorithm is defined formally in Fig. 4, where we
denote by
v = A(v
p
, v
c
, x, ρ)
an LCA query performed
for an agent at position
x
with current velocity
v
c
and preferred velocity
v
p
in a region of local density
ρ
(people per unit area), producing a collision-free
velocity
v
. In the following subsections, we apply
5
v = v
p
x + v
Fig. 3. Effect of lookahead. Note how lookahead allows
the orange agent to see the approaching crowd and
adjust its velocity from preferred velocity
v
p
to
v
by
incorporating information from the future crowd state at
time t + ∆t.
For each leaf node p
• Foreach level i in range i
max
to 0 DO
1)
Determine future state of crowd
x
i
= x +
v
c
∆t
i
2)
Solve local collision avoidance problem
v = A(v
p
, v
c
, x
i
, ρ
i
)
3) Update preferred velocity v
p
= v
• END Foreach
Fig. 4. Lookahead Algorithm using LCA algorithm A.
our generic long-range collision avoidance algorithm
to two examples of LCA algorithms, one continuum-
based and one discrete, showing the broad applicability
of our technique. We also describe some optimizations
that are possible in the specific cases.
3.1 Continuum Lookahead
Continuum representations treat the crowd as a con-
tinuous distribution of density
ρ
and velocity
v
over
space, through which any given agent must navigate.
The knowledge of the density distribution enables us
to determine congestion directly as regions of high
density. It is well known that pedestrians walk slower
in regions of high density [35], a fact that can be
formalized into a graph known as the fundamental
diagram relating density,
ρ
, to a natural walking speed:
v
max
= f(ρ)
Therefore, agents should navigate around
overcrowded regions to avoid lowering their speed
and maximize their rate of progress towards their goals.
In this section, we first describe a simple algorithm
that uses this idea to avoid congestion over a short
time horizon, then extend it to look much further in
time using our long-range approach.
Consider an agent that has a preferred velocity
v
p
pointing towards of the goal. Suppose over the
planning time horizon
∆t
, the agent maintains a
constant heading along a chosen direction
ˆv
and walks
at the maximum speed allowed by the fundamental
diagram
f
. Then to first order, the density it passes
through will change at a rate of
f ˆv · ∇ρ
, and so its
displacement after time ∆t will be
d(∆t) = f ˆv∆t +
1
2
(f ˆv · ∇ρ)f
0
ˆv∆t
2
, (1)
where
f
and
f
0
are evaluated at the density at the
current position. We choose
ˆv
to maximize the progress
towards the goal,
v
p
· d(∆t)
. This formulation reduces
to the following optimization problem,
arg max
ˆv
v
p
· ˆv +
f
0
∆t
2
(ˆv · ∇ρ)(v
p
· ˆv)
kˆvk ≤ 1.
(2)
We can solve this problem using projected gradient
descent, with the direction of the current velocity as the
initial guess; this converges in less than ten iterations
on average. This simple approach produces excellent
avoidance results with maximal progress while still
being computationally inexpensive. Though similar in
spirit to [2], it avoids the need to calculate a global
pressure to exert forces.
Before formulating the lookahead algorithm for
continuum crowds, we first need to estimate the
future densities of the crowd. In accordance with
the uncertainty model, extrapolation further into the
future requires that each agent’s contribution to the
density field be spread out over larger and larger
areas, which can become inefficient with the traditional
“splatting” approach. Instead, it is more efficient to
represent future states on coarser grids, which will
automatically have the effect of increasing the agents’
effective footprint. Each successive grid is coarsened by
a user-defined factor
c
, which represents the increase in
uncertainty
σ(∆t)
from one level of lookahead to the
next. Thus, a pyramid of grids is constructed, where
each level is coarser than the one below it by a factor
c
. Level
i
of the pyramid contains the future state of
the crowd at time t + ∆t
i
.
With this representation, the lookahead algorithm
as defined in Fig. 4 can be directly applied. For each
cell at the bottom of the pyramid, we solve the LCA
problem separately at multiple levels of the pyramid,
starting from the top and cascading the solution at
level
i
as the preferred velocity at level
i − 1
. Though
