- Open Access
Smart crowds in smart cities: real life, city scale deployments of a smartphone based participatory crowd management platform
© Franke et al. 2015
- Received: 26 May 2015
- Accepted: 5 November 2015
- Published: 22 December 2015
We describe a platform for smart, city-wide crowd management based on participatory mobile phone sensing and location/situation specific information delivery. The platform supports quick and flexible deployments of end-to-end applications for specific events or spaces that include four key functionalities: (1) Mobile phone based delivery of event/space specific information to the users, (2) participatory sensor data collection (from app users) and flexible analysis, (3) location and situation specific message multicast instructing people in different areas to act differently in case of an emergency and (4) post mortem event analysis. This paper describes the requirements that were derived through a series of test deployments, the system architecture, the implementation and the experiences made during real life, large scale deployments. Thus, until today it has been deployed at 14 events in three European countries (UK, Netherlands, Switzerland) and was used by well over 100,000 people.
- Crowd management
- Crowd sourcing
- Large scale cooperative sensing
Pedestrian crowds are an integral part of cities. Planing for crowds, monitoring crowds and managing crowds, are fundamental tasks in city management. As a consequence, crowd management is a sprawling R&D area (see related work) that includes theoretical models, simulation tools, as well as various support systems. There has also been significant interest in using computer vision techniques to monitor crowds. However, overall, the topic of crowd management has been given only little attention within the smart city domain. In this paper we report on a platform for smart, city-wide crowd management based on a participatory mobile phone sensing platform. Originally, the apps based on this platform have been conceived as a technology validation tool for crowd based sensing within a basic research project. However, the initial deployments at the Notte Bianca Festival1 in Malta and at the Lord Mayor’s Show in London2 generated so much interest within the civil protection community that it has gradually evolved into a full-blown participatory crowd management system and is now in the process of being commercialized through a startup company. Until today it has been deployed at 14 events in three European countries (UK, Netherlands, Switzerland) and used by well over 100,000 people.
Mobile phone based delivery of event/space specific information to the users. In a nutshell, this is the classic city/event information app functionality that motivates users to download and run the App.
Participatory sensor data collection from app users (on an opt-in basis) and translation of that data into an appropriate representation of the crowd state and its evolution. This provides responsible crowd managers with a “heat map-like”, concise, real time overview of the spatial and temporal evolution of the state of the crowd in the entire area.
Support for location and situation specific messaging allowing the messages to instruct people in different areas to act differently in case of an emergency. This allows for smart, adaptive emergency response and evacuation strategies to be implemented in real time.
The ability for post mortem analysis of an event as means of future planning.
The concept of crowd management as a use case for participatory smart city technology including a requirements analysis based on several real life deployments of different prototypes.
- 2.The architecture and implementation of a corresponding platform comprising of
A generic, configurable, multi-platform app to facilitate collaborative, city-wide sensing as well as location and situation sensitive information delivery
A data processing backend that collects and stores the sensor data from the participants and converts them into situational awareness of the crowd state.
A configuration front end that allows the generic app platform to be quickly instantiated according to the specific event/space.
An event management front end that provides the visualization of the crowd state and allows for an easy creation of situation and location specific messages.
All of the above is implemented in a modular way allowing easy integration of additional functionality (e.g. new sensor data analysis and visualization schemes).
Results and experiences from large scale real life deployments ranging from the information that the system can deliver about an event over the statistics of app usage to quantitative and qualitative results of user interviews (with both event visitors and civil protection personnel).
1.2 Related work
Obtaining knowledge about the current size and density of a crowd is one of the central aspects of crowd monitoring . For the last decades, automatic crowd monitoring in urban areas has mainly been performed by means of image processing . One use case for such video-based applications can be found in , where a CCTV camera-based system is presented that automatically alerts the staff of subway stations when the waiting platform is congested. However, one of the downsides of video-based crowd monitoring is the fact that video cameras tend to be considered as privacy invading. Therefore,  presents a privacy preserving approach to video-based crowd monitoring where crowd sizes are estimated without people models or object tracking.
With respect to the mitigation of catastrophes induced by panicking crowds (e.g. during an evacuation), city planners and architects increasingly rely on tools simulating crowd behaviors in order to optimize infrastructures. Murakami et al.  presents an agent based simulation for evacuation scenarios. Shendarkar et al.  presents a work that is also based on BSI (believe, desire, intent) agents – those agents however are trained in a virtual reality environment thereby giving greater flexibility to the modeling. Kluepfel et al.  on the other hand uses a cellular automaton model for the simulation of crowd movement and egress behavior.
With smartphones becoming everyday items, the concept of crowd sourcing information from users of mobile application has significantly gained traction . Roitman et al.  presents a smart city system where the crowd can send eye witness reports thereby creating deeper insights for city officials. Szabo et al.  takes this approach one step further and employs the sensors built into smartphones for gathering data for city services such as live transit information. Ghose et al.  utilizes the same principle for gathering information on road conditions. Pan et al.  uses a combination of crowd sourcing and social media analysis for identifying traffic anomalies.
We have previously published papers focusing on the sensing part of our system. In  we describe in details how the data gathered using the mobile phones is being processed and visualized. In  the accuracy of our data processing and visualization method is evaluated using video footage from an event where the system was deployed. It is shown that while the user penetration of our system was below 1 % during this event our methodology nevertheless achieved a correlation factor of 0.83 between the actual crowd density (obtained by counting people on videos) and our system’s calculated crowd density. While our previous work dealt with the matter of assessing crowd parameters in detail, this paper is concentrating on presenting the entire approach as a whole by providing insights into use cases, the overall system architecture and lessons learned.
Crowd phenomena are a well studied yet by far non-trivial example of collective human behaviors [15, 16]. Understanding and controlling such phenomena has significant practical relevance in civil protection applications such as, for example, the management of large scale public events and emergency evacuation. Problems with crowd management can have disastrous consequences. Well known examples of crowd disasters include the 1990 stampede in Mecca (where 1426 people died inside a pedestrian tunnel)  or the 2010 German Love Parade disaster where 21 people were trampled to death (with more than 500 having been injured) when a mass panic broke out .
Two key requirements for successful crowd management are situational awareness and the ability to exert influence on the crowd.
2.1 Situational awareness
Individual observations must be put together into a coherent picture that provides information about relevant global parameters such as density distribution, motion directions, turbulence etc.
Developments and trends need to be monitored and analyzed as they evolve over time so that problems cannot only be spotted when they occur, but be foreseen in time to be prevented.
It should be possible to review the entire course of an event retrospectively to identify problems and irregularities and understand their causes. While, fortunately, major accidents are rare, deviations from the plan, unexpected behaviors and potentially dangerous situations are common. Understanding how and why they happened is critical for reducing the probability of major incidents in the future.
2.2 Crowd control
The main tool of crowd management during large scale public events is the physical layout of the space defined and implemented in advance. It includes barriers, entrances, exits, gangways etc. In general, the layout is based on theoretical models and simulations . Given (1) an initial crowd state (e.g. size, initial distribution), (2) a physical space layout, and (3) a certain general crowd behavior (e.g. everyone heading towards the nearest exit, or most people moving in one direction) such models can predict the evolution of global parameters such as the density distribution, evacuation time or average physical pressure within the crowd. During the event, crowd management needs to react to changes in the crowd’s state and behavior in order to make sure that key parameters remain within acceptable bounds and no undesirable phenomena (e.g., panic, stampede, blockages, jams, etc.) occur. To this end two main types of actions can be taken: (1) dynamic changes in space configuration (e.g. closing entrances, opening new exits, creating new barriers) and (2) issuing instructions to the crowd in order to influence its behavior. While, within certain limits given by the venue, physical space reconfiguration can be prepared beforehand (e.g. placing removable and movable barriers, or posting security personnel to redirect people) and executed effectively, issuing complex instructions to the crowd and ensuring compliance is a difficult problem. Today, it often involves “primitive” approaches such as security forces shouting through megaphones and raising improvised signposts. Obviously, the amount and complexity of information that can be delivered this way is limited. In particular it is difficult to deliver differentiated instructions (e.g. send different parts of the crowd to different exits) and background information explaining the necessity of certain measures (crucial to ensure compliance). By contrast, a location and activity sensitive App can deliver complex, personalized and situation adapted instructions and convincing explanations in real time.
Our work is based on the observation that more and more cities, tourist resorts, sports clubs, concerts and parades have their own apps and people increasingly rely on such apps to plan and manage their visit. Many such apps already use sensors (in particular location) for context and situation adapted information delivery. As a consequence they are a potentially perfect vehicle for both collecting data about a crowd and delivering personalized, situation specific information and instructions. A key research question addressed in this paper is what is needed to realize this potential. The answer is based on a series of deployments during which our system has been incrementally evolved and validated building on feedback from various stakeholders (for details, see the box “How was the System perceived?”) and usage by around 100,000 people until now [20, 21].
3.1 Basic considerations
How many users need to install the app to provide a useful estimate?
How much communication load does the system generate?
3.1.1 Required number of users
In simple terms density estimation means that, for any given area within the relevant space, we can provide the percentage of visitors who are located there. Our system determines this percentage from the sample of users who are running our app: if x percent of the users running our app are within a given area, we assume the same to be true for all users. Thus, we essentially perform statistical sampling which is a common technique for example in opinion surveys and for which the relationship between sample size and the accuracy of the estimate is well understood.
Thus, if the M E p computed from the above formula is for example 1 % then, with the probability of 0.95 (our chosen confidence), the true number of people within a given area will be within ±1 % of the percentage estimated from the data provided by the app users.
Looking at the deployment during the 2013 Zurich festival as an example, a total of 28,000 people were uploading location data into our system – with about 4,000 simultaneous uploaders at peak times (see Fig. 11 towards the end of this paper for reference). Setting n = 4,000 leads to M E p = 0.0155 – an error margin of roughly 1.5 %. The total number of visitors over the three day festival period was roughly 2 million, which equals about 660,000 unique visitors per day with a peak of approximately 300,000 people being at the festival area at the same time. Hence, at a confidence level of 95 % our system has an error margin of roughly 0.0155 × 300,000 = 4650 people during peak times.
Summarizing the above, for crowd management purposes we need to be able to reliably distinguish between a number of different density states (e.g. less than 2, around 2, around 4, around 6 persons per square meter, etc.). How does that relate to the margin of error described above? The answer is: through spatial resolution. The margin of error is given as absolute number of people. Integrating the density over an area also gives us an absolute number of people. The larger the area the larger not only the absolute number of people but also the absolute number of people by which the relevant density states differ.
Coming back to the specific example from the Zurich festival, we consider a zone with an area of 75 m by 75 m. This leads to 11,250 people per zone in case of a density of 2 persons per square meter. The worst-case number of 6 persons per square meter leads to 33,750 people per zone. With our margin of error we can estimate the number of people within a given area to within ± 4650 people. This allows us to easily distinguish the relevant states, as the distance between them is more than double the margin of error.
Influence of zone size on the number of people within a zone and the minimal sample size m i n n which is needed to detect critical states
Persons per m2
25 m x 25 m
50 m x 50 m
75 m x 75 m
100 m x 100 m
125 m x 125 m
3.1.2 Communication load
The second point we want to discuss with respect to basic considerations is our approach’s data consumption. If the system uses too much of the user’s data plan, it will not be accepted on a wide basis. As it will be shown later on in this paper, there are two main data streams which need to be analyzed for this: (1) location data being uploaded to our server and (2) content updates (i.e. event specific information such as schedules, maps, etc.) and messages which are sent from the event organizers to the app users.
With respect to content updates and messages, making a general statement is impossible as that amount of data very much depends on the specific event. Usually, apps are delivered with all the contents already on board, hence the amount of additional data traffic required for content updates depends largely on how much information needs to be added to the app after its publication to an app store. The same is true for messaging: it is impossible to generalize the messaging behavior of an event organizer. However, given that messages and content updates are consisting of 90 % textual information, the data volume is definitely not exuberant. However, since the apps poll the server backend for content updates and messages, it is possible to quantify the amount of data that is being used for those update requests.
Data traffic consumed by app-based crowd management system
Traffic per call
Traffic per hour
Traffic per day
3.2 Evolution and deployment history
As described in the introduction, the system was originally developed as a participatory data collection test platform. As such, it was first deployed during the Notte Bianca festival in Malta. In a simple festival information application it embedded the ability to collect (with user informed consent) time stamped location data and transmit it to a remote data server. In addition, CCTV cameras were set up at key locations to collect crowd density ground truth.
Despite a very low penetration of the software (only less than one percent of the visitors had used it), at least at a qualitative level, the estimate of the crowd density was surprisingly accurate.
The system was very well received by the civil protection forces (Civil Protection Department of Malta and the Ministry of Home Affairs). They particularly emphasized the importance of the real time crowd density information for identifying areas where incidents might be most likely to occur.
From the above conclusions it was decided to move from a mere data collection platform to a full blown crowd and event management application. Therefore, a presentation was given to decision makers responsible for public safety in the City of London. Its goal was to find the right event that would (1) be willing to support our team during the creation of the application with feedback from an organizer’s point of view and (2) have the ability to deploy and evaluate the application at a large scale.
It should not only consider emergency aspects but instead cover the whole bandwidth of event information. This also included the application’s ability to adapt to last minute changes which are quite common in event management.
It should facilitate a unidirectional communication channel from the event organizers to the event visitors to be able to control the crowd efficiently by sending commands to the visitors’ smartphones. Special emphasis was given to the need for location based messages which allow for sending a message only to those people located in a specific geographic area.
It should be based on a generic framework which could be quickly adapted to the requirements of each event without the need for any programming whatsoever.
The framework should support the creation of native smartphone apps for the iOS and Android operating systems.
Based on the findings of the workshops and the list of requirements mentioned above, the system presented in this article was created. It mainly consists of two components. Firstly, a web application focusing on the needs of event organizers and emergency and civil protection staff offers the means to (1) define the design and the functionality of the smartphone app to be deployed and (2) to analyze the collected data from the crowd and to interact with the crowd via messages. For details about the web application’s functionality, please refer to the sections 4.2 and 4.3.
The second main component of the system is the generic app for the iOS and Android operating system which is deployed at the events. Based on the outcome of the workshops, a set of modules for the app was defined (see section 4.1 for a complete list). At runtime, the generic app receives information about its design, menu structure and activated modules enabling it to present itself to the user in exactly the way intended by the event organizers. This ability of the app to reconfigure itself at runtime allows event organizers to change contents of the app at any time – even when the event is already taking place can information or features be added remotely to react to the current circumstances.
During the first deployments, the user base of the system was quite small (a couple of thousand app users per event). However, the deployment during the inauguration festivities in Amsterdam for King Willem of the Netherlands in April 2013 was the big breakthrough: thanks to an integration of the app into the event’s publicity campaign a total of more than 70,000 people downloaded the app (about 10 % of the event spectators). Regardless of these numbers we were unable to actually perform any data recordings during the event because the largest Dutch telecommunication provider opposed to the system due to fears of network congestion on the highest political level. While these fears were cleared eventually, it was too late to perform a data recording.
Therefore, the first big impact deployment of the system was during the 2013 Zurich festival with a total of 28,000 active app users contributing data over a period of three days . The resulting data set is the largest of its kind according to our knowledge.
Since the Zurich deployment, the system has been routinely used in several European events and the interest in the technology is rapidly growing. Furthermore, a Windows Phone app has been added to the framework.
Overview of the system’s deployments between 2011 and 2014
# App downloads
# Data contributors
Notte Bianca, 2011
Lord Mayor’s Show, 2011
Lord Mayor’s Show, 2012
Zurich New Year’s Eve, 2012
Dutch Coronation, 2013
Zurich Festival, 2013
West End Live Festival, 2012
Westminster Olympics App, 2012
Vier Daagse Feesten, 2013
Amsterdam Gay Pride, 2013
Tilburgse Kermis, 2013
Vier Daagse Feesten, 2014
Leids Ontzet, 2014
Summarizing the above, the system’s functionality can be divided into three categories: (1) features for the event visitors, (2) features directed at the event organizers and (3) features for the emergency and civil protection services.
4.1 Visitor features
The Map Module displays geographic contents such as points of interest (POIs) and routes either on a platform specific map (i.e. Google Maps, Apple Maps or Bing Maps) or on a custom map provided by the event organizers. POIs can be annotated with extra information such as images, texts and links. Furthermore, the user can navigate to POIs.
The Event Calendar Module gives users an overview about the details of events that stretch out over a longer period of time. In case of the app for the London 2012 Olympics for example, it contained all competitions, concerts and other relevant events with detailed information such as maps, images, texts and links.
The One Day Event Module provides a list based overview about the proceedings of short events.
The Contact Module allows users to contact the event organizers and other important entities via phone or email and also gives them the option to visit their website.
The Checklist Module can be used to inform visitors about items they need to bring along. The City of London Police for example uses this module in their app to tell people about the items they should have in their houses in case of emergencies.
The Messaging Module acts as a generic inbox for broadcast and location based messages sent by the event organizers and the emergency forces. Messages are being received via several channels (travel, general, emergency, location specific) to allow for an easy prioritization by the users.
The RSS Reader allows app users to read event-relevant news that are being published as RSS feeds.
In some cases, event organizers want to make Static Contents available for the visitors via the app. One example for this might be the map of a city’s subway system.
The City of London Police had a special module made for their app: the Street Level Crime Viewer. This module allows app users based in the UK to view the crimes that took place in an area of one kilometer around their current position allowing them for example to check if an area is known for frequent burglaries before moving there.
Given the fact that most app users are very enthusiastic about social media, a Twitter Module was added to our framework to give users access to news spread this way.
One of the easiest ways to add existing contents to our apps is by using the Web Content Module. The app for the London 2012 Olympics for example, incorporated the city’s public transport information system using this module.
A special case of the Web Content Module is the Mobile Heat Map Module which displays the crowd density heat map with a fixed view port.
The Badge Collector is a great module to motivate event visitors to use the app more frequently. It sets certain goals for the users (e.g. spending a certain amount of time in a certain region) and awards them with badges if they reached that goal.
The Friend Finder is another motivational module: it allows to select some of the user’s Facebook friends and share the user’s location with them. This enables app users to coordinate their stay at the event better with their friends.
The app framework’s Privacy Modules have the purpose of informing the app users about what exactly the app is doing. They give a detailed overview about the status of each sensor, show information on when and where a recording is being performed and also give the option to opt out of the crowd sensing feature.
4.2 Event organizer features
Event organizers mostly interact with the web application element of our system. Before an event, their main task is to create apps and fill them with content. To learn more about this process, please refer to the box “How to Manage a King’s Coronation?”.
During an event, our system gives event organizers the option to change their app’s behavior and content with the click of a button. This way, organizers can add for example geographical contents to the app’s map section to mark certain locations as closed or to highlight routes people should take to move to different parts of the venue.
Furthermore, event organizers need to be able to communicate with the visitors directly via messages. This task is also accomplished through the web UI. Messages can either be sent as broadcasts (please also see the box “How to Manage a King’s Coronation” for details) in which case they are received by all app users or as location based messages, meaning that they are only received by people who are located within the geographic area targeted by the message.
4.3 Emergency and civil protection features
Like event organizers, emergency forces mostly use the system’s Web UI component for their work during an event. They too can change the behavior of the app – however, the reason for doing so is much more serious.
Imagine an actual incident where important safety advice needs to be sent out to event visitors as quickly as possible. Using the Web UI, the emergency responders can disable all app features that are not directly relevant to the mitigation of the potentially hazardous situation, thereby focusing the users’ attention on the important information.
The messaging features – especially the location based messages – can be used to steer different parts of the crowds into different directions to decrease the crowd density in critical locations. Adding geographic contents such as escape routes and safety zones to the app’s map module is another valuable feature for crowd managers during an incident.
After an event is over, our system can play back the recorded crowd data allowing for a “post-mortem” analysis of the event. During numerous deployments, this feature proofed itself to be a unique tool to learn from an event and to improve crowd management related measures for future events.
In the following, we are describing the architecture of the system’s three main components: the generic app which can be easily customized to the events’ specific requirements, the data processing back-end and the web front-end which is used by event organizers to access the system’s features. In contrast to existing crowd sourcing solutions (see related work section for examples) which are tailor made for one specific use case, our system architecture allows for a quick adaptation to the requirements of the user. This allows for flexible deployments in all sorts of events and smart city scenarios (where crowd control and targeted messaging are also of high value) without the need to re-engineer either the app component or the back-end. The entire process of creating an app (for details, please refer to the box “How to Manage a King’s Coronation?”) only takes a couple of hours at most with the biggest effort being the entering of event specific data (schedules, geographic information, etc.) into the system via the web front-end. Details about the system’s unique flexibility are mentioned in the following sections.
5.1 Generic app
The updating mechanism of the app is realized by its update manager which controls a whole host of so-called update channels. Each update channel corresponds to one modality of the app – e.g. layout, map content, technical information, etc. The update channels poll the cloud based backend in regular intervals to check if the information the app has stored is still up to date. In case of an update, the new JSON file is passed to the update manager which stores it in the central data store object and notifies all relevant objects of the new data. These objects are then responsible for (1) retrieving the new data and (2) for reconfiguring themselves accordingly.
The layout manager is responsible for setting the app up according to its layout JSON file and is one of the first objects to be created during the app’s startup procedure. It parses the JSON to get the information about the basic app structure – i.e. colors of UI elements, icons and names of tabs, menus, menu items and background pictures. When a user selects a menu item, the layout manager creates the corresponding object in an “get instance by name style”. Consequently, the different event apps are always compiled with all modules “on board” – only at runtime it is decided which objects are actually needed and which ones aren’t.
The app modules all inherit from a MainView object which encapsulates common functionalities such as notifying the statistics manager when a feature has been invoked. Furthermore, all app modules implement an interface defining the proper initialization routines. During its initialization, an app module reads the startup information delivered with the layout JSON to present itself correctly. For example in case of the web content module, this startup information consists of nothing more than a URL that should be displayed by the module.
The sensor manager is not only responsible for recording data from different sensor modalities and for forwarding this data to the upload manager. It is also responsible for deciding when and where the sensors must be activated and deactivated – in light of recent privacy discussions this is an especially important task. Based on the recording schedule JSON, the sensor manager enables the phone’s rough location sensing modalities (i.e. energy aware location sensing through WiFi and GSM triangulation). Once the user is near the recording zone, the sensor manager switches to precise location sensing to get a clear idea about whether or not the user is in that zone. If the user is in the recording zone and has also consented to sharing his phone’s sensor data, the sensor manager enables the recording of data. This whole process is also time triggered meaning that if the user is in a recording zone but there’s no recording scheduled at the current time, the sensor manager won’t activate the data recording. Furthermore, the entire checking process happens on the device. In other words, this means that the devices are responsible for checking their geographic location and the current time and for comparing those parameters to the recording schedule. Consequently, no data is leaving the phone at any time until the user agrees to participating in the recording.
During a recording the data is stored in an upload buffer by the upload manager. This buffer is sent to the server once every minute. At the moment, the recorded sensor data is platform specific. On iOS and Windows Phone, our system only records GPS data including the user’s heading, speed and the GPS fix’s accuracy. On Android however, the app also offers the option to record the number of Bluetooth devices in the phone’s vicinity. This data offers some valuable insights into the crowd density in the user’s direct proximity.
The statistics manager has the simple job of keeping track of when and where each feature of the app has been used. Each module sends a corresponding notification to the manager. If a user stays on a screen for more than three seconds, the manager considers the feature as having been used and creates a record for it. This record contains the name of the feature, the time of use and the location of the usage. In case of navigation and POI information requests, the record also contains the location of the navigation’s target or the POI’s name and location. This information can be used to gain greater insights into how the app was used and allows for a more detailed post-event analysis. Once every three minutes, the statistics manager sends the collected data to the system’s backend. For the sake of privacy, the user ID is not being sent along with the data so it’s impossible to create a precise usage record of individual people.
Finally, the central app manager is responsible for controlling the app’s run loop. It registers with the smartphone platform’s push notification service, initializes the main objects and controls the app’s transition between background and foreground behavior.
5.2 Data processing backend
The system’s backend needs to be considered as two separate sub-systems: (1) the system for administrating the smartphone apps (i.e. for creating the layout and content JSON files) and (2) the system for collecting and analyzing the recorded sensor data whose output is, for example, the crowd density heat map.
The administration system consists of an application server, an SQL database and a dispatching cluster. In all deployments up to now, we used Amazon S3 as storage system for binary files to minimize the load on the system’s backend.
The application server runs the web application which will be described in the next section. The outputs of the web application are the app configurations which are being stored in the SQL database.
The dispatching cluster is the component with the heaviest load in this sub-system as all deployed event apps contact the cluster in order to check for updates. Versioning of app configuration data has been implemented using revision numbers – the app’s update channels send a request to the dispatching cluster containing the app’s dispatch ID and the revision number of the update channel. The dispatching cluster then compares the received revision number with the content’s current revision number and sends back the new data in case of an update. Otherwise, it sends back an empty reply, thereby signaling to the client that the data is still up to date.
In order to perform as strongly as possible, the dispatch nodes try to keep the app contents in memory at all times. Whenever there’s a change in the SQL database, the dispatch nodes get a notification letting them know that there is new data to dispatch. The nodes then create new JSONs for each affected update channel and keep that data in memory. This way, each update request can be handled by simply comparing two integers and potentially sending back pre-computed data.
The entire app administration sub-system is being hosted on Amazon’s AWS cloud services for reasons of cost effectiveness and to make sure that there are always enough computing resources available to be able to cope with peaks in user load. Following the advise of Amazon consultants we decided to employ a multitude of smaller computing instances instead of a small number of large instances. When using small Amazon EC2 instances (roughly comparable to single core 1.5 GHz CPU machines with 1.7 GB of RAM) each instance is able to handle approximately 800 users. The dispatch cluster scales automatically based on the average load on all dispatch nodes. When the average load is greater than 0.8, an instance is being added – when it is lower than 0.4 an instance is shut down. Spinning up a new instance typically takes around 3 min. In all deployments up to now, this infrastructure worked without any problems that would have affected the experience of the end user.
For the heat map sub-system used for receiving and aggregating the recorded data we relied on the CoenoSense system  developed at ETH Zurich’s Wearable Computing Lab until mid 2013.
In June 2013 we began migrating apps to a custom made solution. Both systems have a sharded MongoDB3 at their core which was designed for maximum performance and scalability from the beginning making it more suitable than alternatives such as CouchDB (which uses REST over HTTP compared to MongoDB’s much quicker binary protocol between the DB server and the client application).
Compared to CoenoSense, the new solution relies on Lighttpd4 as a web server which provides a higher performance. Another addition was the introduction of a queue layer. The data packets received by the web server are being passed on to a pool of input workers realized in the Python programming language. These workers write the data in a Beanstalkd5 queue where it’s being buffered. The data is then being processed by output workers which are also written in Python. The output workers store the data in the sharded MongoDB. Benchmarks with 10,000 simulated concurrent users have shown that this solution for the backend reaches a request response time of around 0.04 s.
The application server in this sub-system hosting the web front end is explained in more detail in the following section.
5.3 Web front end
Both the administration and the heat map sub-systems offer an easy-to-use web interface to allow for a maximum compatibility with client devices. The interfaces have been tested with the latest builds of Firefox, Chrome and Safari. Therefore, they can be run on a multitude of device categories ranging from desktop PCs to tablets and even smartphones.
The heat map GUI itself requests the latest information about crowd conditions in regular intervals from the application server where it is stored in a MongoDB. When doing so, it sends a timestamp along with the request specifying which data it is interested in. The application server then fetches all the available location data from the Mongo DB cluster and returns a data structure that contains one location for each user that contributed data at that specific time.
The data is delivered by the application server to the GUI in a compact JSON format. Only when that data arrives at the GUI is it rendered. Offloading the heat map rendering task to the client (i.e. the GUI) saves considerable resources on the server side thereby making sure that the heat map can be accessed by many clients simultaneously. If the server was delivering rendered heat maps or tiles to the clients, it would need to be scaled much larger and thereby become much more expensive.
As mentioned earlier, the heat map view provides a time slider for inspecting past data. Technically, this has been implemented using an AJAX approach (a background call to the server) which allows for an almost instant displaying of the required data without a page refresh.
To provide a standard level of security against unauthorized access, the heat map is protected with a token only known to the administrative backend which seamlessly integrates the heat map view provided by the heat map sub-system’s front end. However, it is worth noting that this view can also be accessed individually if the situation calls for it (e.g. if a police officer on the ground wants to access it on a tablet device). Therefore, the heat map administration system can generate a URL which gives access to a webpage containing only the heat map without any other elements of the system.
As mentioned above, our system has been deployed at a series of events throughout Europe and was used by well over 100,000 people. Since a more detailed description and evaluation of the crowd density estimation as it was performed in Chapter 3.1.1 goes beyond the scope of this system overview and experience paper – and has already been published in  – we want to focus on a broader description of the results of the deployments and report on the user feedback.
As Figs. 1 and 4 demonstrate, visualizing the crowd density in form of a heat map generated by crowd sourced real-time location data provides a good representation of the situation on the ground. Furthermore, the visualization gives a good insight into the temporal and spatial evolution of the crowd, thereby facilitating situational awareness, prediction and post event analysis.
One of the most important lessons learned during the numerous deployments was that it is absolutely vital to have a solid PR strategy for the distribution of the event apps. Chapter 3.1.1 clearly shows that the system performs well with only a few percent of the visitors sending data to our backend. Our system has shown to work reliably with a user penetration of around 1 or 2 % – a user penetration of 10 % would even allow for a very detailed analysis. However, depending on the size of the event, even a small percentage of app users can be a sizable absolute number. During our first deployments, visitors were only made aware of the app via social medial channels and the event website. The resulting number of downloads (see Table 3) based on this PR approach was not very satisfying. Over time we learned to better deal with this situation and during the deployment at the coronation of the Dutch King in 2013, roughly 10 % of the event visitors had downloaded the app (about 70,000). The PR campaign responsible for this success was employing numerous channels ranging from online articles, social media campaigns and print articles to actual TV coverage. As this might be more effort than some event organizers are willing to put into PR for an app, the Zurich festival proved that there are also simpler ways to achieve a solid number of downloads: on top of a social media campaign and a prominent download section on the event’s website, the app was simply mentioned on all event posters and in event brochures. In summary, it can be said that the event apps should be made an integral part of the event planning process if the system is to deliver reliable results.
With respect to user acceptance of the system, we performed debriefing sessions with civil protection authorities and surveys with app users. While details about both can be found in the box “How is the System perceived?”, it seems particularly worth mentioning that all participating authorities were keen on deploying the system at a larger scale and also wanted to explore further use cases for it. From an event management point of view, it is very encouraging to know that 82 % of all survey participants would actively consult such an app in case of an emergency, 94 % would follow the app’s advice and only less than 1 % generally don’t trust advice given out on a phone.
In the previous section we gave an overview of the system’s architecture – in particular we described the generic app’s main components. Amongst those components, the Statistics Manager was mentioned. This object’s purpose goes a lot further than just sending information about how popular each feature of an app is. Instead, it collects information about how the app is being used and which requests have been made.
Specifically, it is being logged what feature is being used where and when. Also, for requests concerning points of interest (i.e. navigation requests or requests for more information about the item), it is being logged when and where the request was made, what was requested and where the requested item is located at. Evaluating this information on the system’s backend gives an insight into what the crowd is currently interested in. This information in turn, can be used as an even earlier predictor for future crowd characteristics. For example, if a meaningful part of the crowd is interested in a certain concert at an event, the system could make an estimate about the growth of the crowd in front of the concert stage.
Figure 11 visualizes this approach using again the example of the 2013 Zurich festival. The grey line represents the evolution of the size of the crowd as measured by our system – please note that for this particular event there was no ground truth available as we had no access to video footage and the event was also open to anybody, hence there was no information about the number of tickets available. The blue line represents the usage of the event app. It can be clearly seen that changes in the app’s usage curve antedate corresponding changes in the curve of the crowd size.
We consider this representation of user interest an important factor for predicting crowd behavior. Future research will focus on further developing this approach.
In this work we presented the evolution of a smartphone based crowd management system from a simple research prototype to a full blown event management solution which is currently being commercialized. The system was deployed at multiple large scale events throughout Europe and was used by several civil protection authorities – all of which highly valued the impact the system had on their work.
The app element of the system was downloaded by well over 100,000 people who collectively contributed over 100 million data points. The general public responded very well to the concept of event apps collecting anonymous data for the greater good.
We furthermore demonstrated the principal architecture of all system components, thereby presenting a system design for reconfigurable, scalable smartphone based crowd sourcing systems which could also be used for other purposes.
While our work’s outcomes show that the system is generally up to its task, there are a number of issues which need to be addressed during future work:
One of the main problems we experienced is related to network connectivity. Complete network failures were never experienced during our deployments. However, during a New Year’s Eve event, a 15 min blackout did occur in an isolated area. During those times, the crowd density heat map stayed empty in the affected area for obvious reasons. Also, this area couldn’t be contacted with messages during the outage. In case of an emergency, such a network blackout could have drastic consequences.
Therefore, one focus of future work should be on the implementation of alternative means of communication in case of network blackouts. The most obvious solution seems to be the implementation of an AdHoc/Mesh-like opportunistic networking approach to bridge those areas without network connectivity.
Secondly, at one point our research work suffered from the interference of a telecommunication provider who claimed that the network wouldn’t support the traffic caused by our app. While those arguments could be countered eventually, it still proved the point that we failed to include telecommunication providers as an important stakeholder in our concept. We’re therefore currently implementing means for providers to define critical thresholds for their infrastructure which will not be exceeded by our system.
Thirdly, future versions of our system will take feedback we received from civil protection authorities into account. For example, GLA (Greater London Authority) expressed the wish to have multiple agencies feed contents into the same system so that it would allow for an integrated workflow.
Finally, the system will be used to establish a living lab at the Technical University of Kaiserslautern. Therefore, a university app is currently being created which is based on our framework. The goal is to establish a platform that will enable research groups to run large scale experiments using crowd sourced data from participating students.
The authors would like to thank all student helpers – especially Torben Schnuchel – who contributed to the creation of the system with countless hours of programming work. The initial steps of this work were supported by the Socionical project, funded under the European Commission’s FP7 program (grant: 231288). Further funding was received from the European Commission’s FP7 program under grant agreement #600854 “Smart Society - hybrid and diversity-aware collective adaptive systems: where people meet machines to build smarter societies” and by the CoCoRec (Collaborative Context Recognition in Dynamic, Multimodal Smart Environments) project supported by the German Federal Ministry of Education and Research.
Open Access This article is distributed under the terms of the Creative Commons Attribution 4.0 International License(http://creativecommons.org/licenses/by/4.0/), which permits unrestricted use, distribution, and reproduction in any medium, provided you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made.
- Rahmalan H, Nixon MS, Carter JN. On crowd density estimation for surveillance: IET; 2006. http://digitallibrary.theiet.org/content/conferences/10.1049/ic_20060360.
- Davies AC, Yin JH, Velastin SA. Crowd monitoring using image processing. Electron Commun Eng J. 1995; 7(1):37–47.View ArticleGoogle Scholar
- Lo B, Velastin S. Automatic congestion detection system for underground platforms. In: Intelligent Multimedia, Video and Speech Processing, 2001. Proceedings of 2001 International Symposium on. IEEE: 2001. p. 158–61.Google Scholar
- Chan AB, Liang Z-S, Vasconcelos N. Privacy preserving crowd monitoring: Counting people without people models or tracking. In: Computer Vision and Pattern Recognition, 2008. CVPR 2008. IEEE Conference on. IEEE: 2008. p. 1–7.Google Scholar
- Murakami Y, Minami K, Kawasoe T, Ishida T. Multi-agent simulation for crisis management. In: Knowledge Media Networking, 2002. Proceedings. IEEE Workshop on. IEEE: 2002. p. 135–9.Google Scholar
- Shendarkar A, Vasudevan K, Lee S, Son Y-J. Crowd simulation for emergency response using bdi agent based on virtual reality. In: Proceedings of the 38th conference on Winter simulation, Winter Simulation Conference. IEEE: 2006. p. 545–53.Google Scholar
- Kluepfel HL. A cellular automaton model for crowd movement and egress simulation. Fakultät für Physik: PhD thesis, Universität Duisburg-Essen; 2003.Google Scholar
- Asimakopoulou E, Bessis N. Buildings and crowds: Forming smart cities for more effective disaster management. In: Innovative Mobile and Internet Services in Ubiquitous Computing (IMIS), 2011, Fifth International Conference on. IEEE: 2011. p. 229–34.Google Scholar
- Roitman H, Mamou J, Mehta S, Satt A, Subramaniam L. Harnessing the crowds for smart city sensing. In: Proceedings of the 1st international workshop on Multimodal crowd sensing. ACM: 2012. p. 17–8.Google Scholar
- Szabo R, Farkas K, Ispany M, Benczúr A, Batfai N, Jeszenszky P, et al. Framework for smart city applications based on participatory sensing. In: Cognitive Infocommunications (CogInfoCom), 2013,IEEE 4th International Conference on. IEEE: 2013. p. 295–300.Google Scholar
- Ghose A, Biswas P, Bhaumik C, Sharma M, Pal A, Jha A. Road condition monitoring and alert application: Using in-vehicle smartphone as internet-connected sensor. In: ervasive Computing and Communications Workshops (PERCOM Workshops), 2012, IEEE International Conference on. IEEE: 2012. p. 489–91.Google Scholar
- Pan B, Zheng Y, Wilkie D, Shahabi C. Proceedings of the 21st ACM SIGSPATIAL International Conference on Advances in Geographic Information Systems. ACM: 2013. p. 344–53.Google Scholar
- Wirz M, Franke T, Roggen D, Mitleton-Kelly E, Lukowicz P, Troster G. Inferring crowd conditions from pedestrians’ location traces for real-time crowd monitoring during city-scale mass gatherings. In: Enabling Technologies: Infrastructure for Collaborative Enterprises (WETICE), 2012, IEEE 21st International Workshop on. IEEE: 2012. p. 367–72.Google Scholar
- Wirz M, Franke T, Roggen D, MitletonKelly E, Lukowicz P, Tröster G. Probing crowd density through smartphones in city-scale mass gatherings. EPJ Data Sci. 2013; 2(1):1–24.View ArticleGoogle Scholar
- Helbing D, Buzna L, Johansson A, Werner T. Self-organized pedestrian crowd dynamics: Experiments, simulations, and design solutions. Transport. Sci. 2005; 39(1):1–24.View ArticleGoogle Scholar
- Helbing D, Farkas IJ, Molnar P, Vicsek T. Simulation of pedestrian crowds in normal and evacuation situations. Pedestrian Evacuation Dyn. 2002; 21:21–58.Google Scholar
- Ngai KM, Burkle FM, Hsu A, Hsu EB. Human stampedes: a systematic review of historical and peer-reviewed sources. Disaster Med Publ Health Preparedness. 2009; 3(04):191–5.View ArticleGoogle Scholar
- Helbing D, Mukerji P. Crowd disasters as systemic failures: analysis of the love parade disaster. EPJ Data Sci. 2012; 1(1):1–40.View ArticleGoogle Scholar
- Wirz M, Franke T, Mitleton-Kelly E, Roggen D, Lukowicz P, Tröster G. Coenosense: A framework for real-time detection and visualization of collective behaviors in human crowds by tracking mobile devices. In: Proceedings of the European Conference on Complex Systems 2012. Springer: 2013. p. 353–61.Google Scholar
- Franke T, Lukowicz P, Wirz M, Mitleton-Kelly E. Participatory sensing and crowd management in public spaces. In: Proceeding of the 11th annual international conference on Mobile systems, applications, and services. ACM: 2013. p. 485–6.Google Scholar
- Blanke U, Troster G, Franke T, Lukowicz P. Capturing crowd dynamics at large scale events using participatory gps-localization. In: Intelligent Sensors, Sensor Networks and Information Processing (ISSNIP), 2014, IEEE Ninth International Conference on. IEEE: 2014. p. 1–7. http://ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=6827652&url=http%3A%2F%2Fieeexplore.ieee.org%2Fiel7%2F6820824%2F6827478%2F06827652.pdf.
- Oberhagemann D. Statische und dynamische Personendichten bei Grossveranstaltungen. Technical Report of the Association for the Improvement of German Fire Protection TB 13-01. 2012. http://www.vfdb.de/download/TB_13_01_Grossveranstaltungen.pdf.