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
]

Big, Fast Crowds on the Sony PlayStation 3

Craig Reynolds first introduced flocking to the computer graphics area by creating the Boids artificial life simulation in 1986. It was a computer model of coordinated animal motion such as bird flocks or fish schools, that allowed for collision avoidance and goal seeking. This model has had various applications such as bat swarms and penguin flocks in the movie 'Batman Returns'. A video of the early model can be seen below, further details can be found here


The above model has a complexity of O(n²), as each boid needs to consider each other boid in order to determine whether its a nearby flockmate. The complexity can be reduced to O(n), by the use of spatial hashing that keeps the boids sorted according to their location, and therefore, increase the population of the boids.

Craig now works for the US R&D group of Sony Computer Entertainment. Recently he created a crowd simulation on the Sony PlayStation 3, which extends from the very early model above. As spatial hashing is used in order to accomodate large numbers of agents, here, it forms the basis of a scalable multi-processor approach to create large, fast crowd simulations. The PlayStation 3 has Cell processor, which consists of a Power Processor Unit (PPU), multiple Synergistic Processor Units (SPU) - 6 available to the model, and an RSX GPU. The model makes use of this architecture to spatially subdivide regions, and use the multiple SPUs to update a number of regions in parallel, accelerating the crowd simulation. The model has been able to incorporate 15,000 agents running at 60fps. A video can be seen by clicking the picture below:


It is interesting to see how different architectures can be used to create crowd simulations, and how the parallel processing nature of today's video games consoles, make them low-cost and high performance platforms for parallel execution. I will be looking forward to see other general purpose applications of the Sony PS3.

GPU Crowd Simulation

This is a conference sketch by Shopf, J., Oat, C., Barczak, J., presented in Siggraph Asia 2008.

I've been talking about how I am looking into creating a crowd simulation on the GPU. The sketch states that, to their knowledge it is the first implementation of a massive crowd simulation entirely on the GPU. A video clip of the simulation can be seen by clicking the picture below, and the slides of their Siggraph Asia 2008 presentation can be found here.



The implementation consists of a simulation of 65,000 agents at realtime frame rates. They have used a framework that combines a continuum-based global path planner (similar to the continnuum crowds post I did earlier), with a local avoidance model at a finer scale.

This also allows the level of detail to change as the view is scaled. There are other conference sketches by ATI, such as 'GPU Tesselation for Detailed, Animated Crowds', and 'GPU-Based Scene Management for Rendering Large Crowds' that must have been used in the simulation.

These sketches give an interesting insight into the capabilities of the GPU for simulating massive crowds, and how the level of detail can be varied based on the scale.

Pedestrian model for a Tokyo style intersection of Oxford Circus

As has been recently announced, Oxford circus is to get a pedestrian-friendly revamp. Here is a video of a pedestrian model, first referred to me by Duncan Smith, a PhD student at CASA. The model consists of 5000 people, where a particle-based system was used to run the simulation. These particles were then replaced by animated people.

The model was created by designhive, and a map of the redesign can be seen here.




Here, the pedestrian and traffic simulation models are combined with a 3D Studio Max model of the Oxford Circus proposals, which makes this finished video very realistic.

This is a type of application, where a 3D visualisation of the model can be used to enhance the communication of ideas, and making it more accessible to others.

Continuum Crowds

This is a paper by Treuille, A. Cooper, S., and Popović, Z, presented in Siggraph 2006.
It's a real time crowd model based on continuum dynamics. The motion of crowds is controlled by a dynamic potential field, which allows it to avoid moving obstacles without the need of explicit collision avoidance. Their paper and video can be downloaded here.



This paper presents a lot of potential in creating a real time crowd simulation with large crowds. It would be interesting to see other implementations of this technique.

Netlogo to 3DMax: Pseudocode

As mentioned in an earlier post that I will be posting a pseudocode for a Netlogo to 3DMax implementation.
This pseudocode is mainly for the Netlogo traffic simulation, but I will try and make it as general as possible in order to use in other models.

Netlogo:
For each tick:
1. Output to file - x coordinate, turtle id, y coordinate

Please note, that when the data is exported into a text file, it will have other test such as 'turtle id:', all text needs to be deleted, and should leave you with 3 numbers. An example for 3 turtles (1 tick) can be seen below:



This creates a file that has the turtle id and locations for each tick. Now, our next step is to import it into 3DMax, but this time each tick represents a frame. I did this by creating a script that would store the data in an array for each frame.


3DMax:
1. Initialise an object (eg, box), for each turtle in the output file
2. Read in netlogo output file, and store xy coordinates for each object per tick in an array. (I stored the array in a 2D form [object id][xy coordinates])
3. Initialise positions of each object for first frame
4. While not end of array
5. Advance frame, and update object position corresponding to the object id in the array
6. Keep repeating step 5 till end of file is reached.
7. Render final animation

Same process for traffic lights, where each traffic light is a turtle in netlogo.

Book: Crowd Simulation By Daniel Thalmann, Soraia Raupp Musse, SpringerLink

I will be occasionally posting details of books that I have come across, which some may find interesting.
This book gives a very good review of what is out there in the Crowd Simulation area. This includes different disciplines such as physics, sociology, computer science (as I mentioned in my first post), and the areas it's used in, such as the film and games industry, the academic research areas, planning, evacuation scenarios, and so on.


One of the authors, Daniel Thalmann, has quite a few publications in the Crowd simulation area, which can be found here
As I mentioned in my first post that I will be exploring some of the above mentioned areas. This book also interestingly mentions that 'despite the apparent breadth of the crowd simulation research basis, interdisciplinary exchange of ideas is rare; researchers in one field are usually not very aware of works done in other fields'. I find this point very interesting, and therefore, brings to mind that work in various fields may often be duplicated, although I havent yet come across duplicate work, it is worth bearing in mind. I welcome such a book that would explore work that has been carried out in different disciplines.

Netlogo to 3D Max: Visualisation

The first few posts will be a catch up of what has been done so far. The first piece I worked on was a Netlogo to 3D Max implementation. This implementation is for a street level scale of a city. Although, 3D Max is used for crowd and particle simulations, in order to model these complex systems, an external package like Netlogo is used. Through the use of loose coupling with 3D Max, it allows us to easily visualise these systems.

The movie below was first posted on the Digital Urban blog. This was my first step to export a basic traffic model from Netlogo to 3D Max. The movements of the cars were first output into a file, the second step was to write a 3DS script to import these movements and animate them in 3D Max.

NetLogo to 3D Max - Proof of Concept from digitalurban on Vimeo.


I have noticed quite a few comments asking how this import was done. I will be posting a pseudocode soon, and will try and give a summary for each step.

Introduction

As this is my first post, let me detail a little about me, and about this blog.
I am currently studying for a PhD in Crowd Simulation in the Centre of Advanced Spatial Analysis, University College London (UCL). I did an MSc in Vision, Imaging & Virtual Environments (VIVE) at UCL last year. I am in my 1st year of the PhD, and will be regularly updating this blog to include posts related to my work, work related to this area, and applications that I come across in the field.
My main aim for the PhD will be to create a real time scalable crowd simulation, therefore, allowing users to look at, for example, crowds in the city of london at varying scales, in real time.
This will be achieved using different architectures depending on the scale. The architectures I will be exploring will include disciplines in social science and computer science.
The work will carried out on the Graphical Processing Unit (GPU), concentrating on general purpose programming, i.e., GPGPU.
The reason I have chosen to use general purpose programming on the GPU, is because, there has been active research in this area over the last few years with the wide deployment of GPUs. The parallel processing of GPUs also gives us a distinct advantage to populate larger amounts of the city with agents, or a larger number of agents in a smaller area.