Paper: Aggregate Dynamics for Dense Crowd Simulation (2009)

Ming Lin's latest work has been featured in the recent publication of SIGGRAPH Asia 2009. The author presents an innovative method that is able to simulate tens of thousands of agents at interative rates.

The work achieves these rates by combining a local behavioural model with a global planner such as Continuum Crowds or Adaptive elastic Roadmaps (AeRO).

Image taken from gamma.cs.unc.edu

The image above shows an overview of the algorithm. So how does this actually work?

First of all, as I mentioned this approach combines a local behaviour with a global planner. The global planner here computes the flow of agents around an environment. The steps are described below:

• Each agent is given a position and a current velocity computed.
  
• Using the global planner such as the roadmap based method or Continuum Crowds method, a preferred velocity is then computed for each agent.
• The navigable area in the environment is divided into a discrete grid of cells. The flow of particle for each cell is computed, using the current velocity and density of agents in the cell.
• For each agent, a new velocity is computed, by interpolating the flow velocity with the desired velocity weighted by the local density at each cell.
• Velocities of agents are constrained in dense areas by the global particle flow. In coarser areas, the agent's velocity are influence less by the global flow, and more by the velocity for the cell.
• Finally, collision detection is applied, as well as a minimum distance for each pair of individual agents, similar to the continuum crowds simulation.

Here's a video of the simulation:

Aggregate Dynamics for Dense Crowd Simulation

A good hybrid approach used here that decreases the computation time considerably to accomodate a very large number of agents at interactive rates. The Unilaterally Incompressibility Constraint (UIC) introduced here that allows the interpolation between the global and local approach is something that has interested me.

Oxford Circus 'X' Crossing opens

As mentioned in a previous post about the Oxford Circus intersection getting a revamp, the intersection has finally been opened today after a number of months of the usual British roadworks. A picture of which can be seen below. A video can be found on a BBC news article here



It's interesting to see how a simulation has been transformed into reality, and the benefits it will bring for pedestrians through one of Europe's busiest intersections. I would also guess that the simulation certainly aided the arguments for benefits of having Oxford Circus get a revamp. I'm certain there must be many more examples that exist, where simulations aid urban planners or architects for such applications.

XBox 360 and GPGPU

It seems Microsoft's console is jumping into the bandwagon of parallel computing using GPGPUs, with new research published that explores parallel computing using the graphics card of Microsoft's XBox 360.

Dr Simon Scarle, previously a Microsoft Rare Studio Software Engineer, who is now a researcher at Warwick University's WMG Digital Laboratory, used one of the XBox 360's GPUs to carry out research on how electrical signals around the heart moved around damaged cardiac cells.



Sony's PS3 has made the use of parallel computing from the very date of its release, with Stanford University's Folding@Home project, and has software development kits (SDK) for harnessing the parallel processing capability of the console.

On a previous post, I mentioned how the PS3's parallel computing capability has also been used to create a flocking simulation. It would be interesting to see if such simulations are, created on the X360, and to see if Microsoft will consider releasing an SDK to attract researchers and developers to use its console for this purpose.

It would certainly be a cost saving way of carrying out research that requires parallel computations, rather than the traditional use of clustered PCs or setting up a network of PCs.

Simulation of Starlings flocking behaviour using captured 3D video recordings of Starlings in flight

I was quite interested to find this flocking simulation of starling's on MIT's Physics arXiv blog.

I mentioned Reynold's flocking behaviour model in an earlier post, it's nice to see progress has been made in creating more accurate simulations by actually capturing 3D recordings using stereographic photography of real starlings in flight.



These video recordings that were published last year has actually allowed Charlotte Hemelrijk at the University of Groningen to create a flocking model, and vary the parameters that closely match real flight recordings of the starlings.

These birds have very complex rules creating this self-organising behaviour, and the researchers seem to have been able to take apart the rules that govern them. These rules also govern other species such as fish, insects and even human crowds, and will likely give further insight into crowd behaviour, and allow for more accurate simulations of human crowds.

I'll be looking forward to seeing a video of this flocking simulation.

XFlow: Fluid simulation tool

I've just come across XFlow, from NextLimit, which is an accurate fluid simulation tool. It uses a particle based method, instead of a computational grid that are used in other Computational Fluid Dynamics (CFD) tools.



The interesting part of this tool is that they have explored other fields, where CFD can be applied to. As they use a particle based method, it is well suited for applying to simulation for complex systems. Examples include:

1. Traffic Simulation
2. Cell Simulation
3. Crowd Simulation

For the crowd simulation application, the particles can represent the pedestrians in different conditions, which can then be applied to scenarios such as emergency evacuation.

Layar: Augmented Reality Browser - Google Android Platform

I've just come across this Augmented reality browser available as an app on the Google Android Market. This is not actually an app, but a platform, which has provided its own API. Therefore, developers can create their own augmented reality layers on top of the browser. This addition of layers over the application brings huge potential in crowd sourced content, and the various other uses that are possible such as augmented reality tour guides, tourist information, social networks, points of interest, transport, etc.,



There can be some more exotic approaches that can be applied to this kind of platform, such as augmented reality games, although, they have been around for a while (mainly GPS location based games), this takes it to a whole new level.

I also wonder about the possibility of using this platform to study crowd behaviour of tourism and leisure activities. These types of behaviour have been traditionally very hard to model, and as this platform will mainly be focussed on these kinds of activities, it would give an insight into the behaviour. Although, getting user permission to gather such data would be an issue in itself.

Netlogo to 3D Max: Code

Based on the pseudocode for the Netlogo to 3DMax implementation, I have now decided to post a short tutorial on exporting the Netlogo traffic simulation to 3DMax. This tutorial will mainly cover the output of the turtles and visualising it in 3DMax.

Netlogo (traffic grid simulation):

For the turtles, I output during runtime, therefore, open the file at the first tick, keep writing, and close the file at the last tick, depending on how many ticks you would want to output, in my case 500.

if ticks = 0 [file-open "myfile.txt"]
ask turtles [
              file-write xcor file-type " " file-show ycor
            ]
if ticks >= 500 [file-close]

This will output in the form:

-12 (turtle: 2) 11
-17 (turtle: 0) 5
-4 (turtle: 1) -8

I didn't find a simple way just to output only the turtle id number, so I manually delete the brackets and text using find and replace, giving me an output as seen below:

-12 2 11
-17 0 5
-4 1 -8

Now our next step is to import it into 3DMax. Once the output file has been stored, the script below can be run, and on clicking the 'Make' button, locate the output file, and it will create the animation.

The code works by importing the Netlogo output file into an array. It can be found here.

I have commented the code in order to explain what is happening at each step.

Running this script will result in the animation shown in my previous post. To get the road patches, and traffic lights in 3DMax, the code can be extended further to store the patches and traffic light states in arrays for each frame, once imported from the Netlogo output.

Update: As pointed out by a reader, there is actually a simple way to output only the turtle id number using the command:

ask turtles [print who]

Therefore, the Netlogo output above can be obtained by using the following command

ask turtles 
[
file-type word xcor " " file-type word who " " file-print ycor
]