LEMONS: An open-source platform to generate non-circuLar, anthropometry-based pEdestrian shapes and simulate their Mechanical interactiONS in two dimensions

The paper introduces LEMONS, an open-source platform featuring Python and C++ libraries along with a graphical interface, designed to generate realistic, non-circular pedestrian shapes based on anthropometric data and simulate their mechanical interactions in two dimensions to overcome the limitations of traditional circular crowd models.

The Gist

Imagine you are trying to simulate a crowd of people, like a concert mosh pit or a busy subway station. For decades, scientists have done this by pretending every person is a perfect, round dinner plate.

While easy to calculate, this "dinner plate" model has a big problem: real people aren't round. We are wide at the shoulders, narrow at the waist, and deep at the chest. Because of this, if you pack dinner plates together, you can't get them very close without leaving weird gaps. Real crowds, however, can get incredibly dense—much denser than the plate model allows.

LEMONS (the tool described in this paper) is like a digital tailor and a physics engine rolled into one. It stops pretending people are circles and starts treating them like real, oddly shaped humans.

Here is a breakdown of how it works, using simple analogies:

1. The "Digital Mannequin" (Generating the Crowd)

Instead of drawing circles, LEMONS uses a 3D scanner of real human bodies (specifically, frozen cadavers from a medical database) to create a "template."

• The Analogy: Imagine taking a real human torso and slicing it horizontally at chest height. You get a weird, organic shape.
• The Trick: To make the computer fast, they don't use the complex shape directly. Instead, they cover that slice with five overlapping bubbles (disks).
  • Two bubbles for the shoulders.
  • Two for the chest muscles.
  • One for the back.
• The Result: When you put these five bubbles together, they look like a human torso. Because the computer knows the exact size of the shoulders and chest from real data (like the ANSURII database of US Army personnel), it can generate a crowd where some people are broad-shouldered and others are slender, just like in real life. This allows the crowd to pack much tighter—up to 7.2 people per square meter (compared to only 4 with the old "plate" model).

2. The "Springy Jello" (How They Push)

When two dinner plates touch, they just bounce off. But when two people bump into each other, their bodies squish, their clothes rub, and they might lean back or forward.

• The Analogy: LEMONS treats every contact between these "bubble-people" like a spring and a shock absorber (like the suspension on a car).
  • The Spring: If two people overlap, a spring pushes them apart (elasticity).
  • The Shock Absorber: As they push, energy is lost (damping), just like your body absorbs the shock of a bump.
  • The Friction: If they try to slide past each other, there is friction (like rubbing your hands together).
• The Physics: The software calculates these forces in real-time. If someone gets pushed, the force ripples through the crowd like a wave in a stadium, because the "springs" connect everyone.

3. The "Puppet Master" (Decision Making)

This is the most important part: LEMONS doesn't decide where people go. It only handles the physics of what happens when they bump.

• The Analogy: Think of LEMONS as a physics sandbox. You (the user) are the puppet master. You tell the digital people, "I want to go to the exit," or "I want to push that guy."
• Why this is cool: It separates the brain (deciding where to walk) from the body (how it feels to be squeezed). This lets researchers test different "brains" (e.g., "What if everyone panics?" vs. "What if everyone stays calm?") while keeping the realistic body physics the same.

4. The "Toolbox" (How to Use It)

The paper introduces a complete package for anyone who wants to do this:

• The Online App: A website where you can click buttons to generate a crowd, see it in 3D, and download the settings. It's like a "crowd builder" video game.
• The Engine (C++): The heavy-lifting part that does the math super fast.
• The Controller (Python): A simple script that lets you talk to the engine. You can write a few lines of code to say, "Make 50 people stand in a line, then push the first one," and watch the simulation run.

Why Does This Matter?

• Safety: If you are designing a stadium or a subway station, you need to know how many people can fit before it becomes dangerous. The old "circle" models underestimated how many people could fit, but they also failed to predict how forces build up in a crush. LEMONS gives a more accurate picture of crowd crushes.
• Realism: It allows scientists to study things like "What happens if a tall person bumps into a short person?" or "How does a backpack change the way someone gets pushed?"
• Open Source: It's free. Anyone from a university researcher to a high school teacher can use it to teach physics or crowd safety.

In summary: LEMONS replaces the boring, round "cookie-cutter" people with realistic, squishy, human-shaped agents. It lets you build a crowd, push them around, and watch the physics play out, helping us understand how to keep real crowds safe.

Technical Summary

1. Problem Statement

Existing crowd dynamics models frequently rely on oversimplified circular (disk) representations of pedestrians. This simplification leads to significant limitations:

• Density Discrepancy: Circular models using realistic body widths (bideltoid breadth) only achieve packing densities of ~4 pedestrians/m², far below empirical observations of peak densities exceeding 8 pedestrians/m² in real-world crushes.
• Geometric Inaccuracy: Circular shapes fail to capture human morphology (e.g., the difference between chest depth and shoulder width) and artificially limit the number of simultaneous physical contacts (max 6 for circles vs. observed 8+ in dense crowds).
• Lack of Heterogeneity: Most models do not account for anthropometric diversity (height, mass, body proportions) or complex agent types (e.g., cyclists, people with bags).
• Coupling Issues: There is a gap between models focusing purely on decision-making (low density) and those focusing on mechanics (high density), particularly regarding how non-circular shapes influence contact forces and collision statistics.

2. Methodology

The authors propose LEMONS, an open-source numerical tool that bridges these gaps through a multi-layered approach combining anthropometric data, granular mechanics, and modular software architecture.

A. Anthropometric Shape Generation

Instead of circles, pedestrians are modeled as anisotropic shapes derived from medical data:

• Data Source: Cross-sectional images from the Visible Human Project (cryopreserved cadavers) and the ANSUR II database (6,000 US Army personnel).
• Geometric Representation: A pedestrian's 2D projection (at torso height) is approximated by five overlapping disks (two for shoulders, two for pectoral muscles, one for the back).
• Synthesis: The system generates synthetic crowds by scaling the radii and positions of these five disks based on individual anthropometric measurements (bideltoid breadth, chest depth, mass, height) to match statistical distributions.
• 3D Extension: The tool also supports 3D visualization by stacking cross-sectional contours at various altitudes, applying scaling factors that modulate with height to preserve head/foot proportions while inflating the torso.

B. Mechanical Interaction Model

The platform treats pedestrians as deformable mechanical bodies governed by Newtonian mechanics:

• Contact Forces: Interactions between the constituent disks of different agents (or walls) are modeled using granular material physics:
  • Normal Direction: A Kelvin–Voigt model (spring in parallel with a dashpot) to capture elasticity and energy dissipation.
  • Tangential Direction: A spring-dashpot system in series with a slider, implementing Coulomb friction (stick-slip behavior).
• Equations of Motion:
  • Translational: $m_i \frac{d\mathbf{v}_i}{dt} = \mathbf{F}_p - m_i \frac{\mathbf{v}_i}{t_{transl}} + \sum \mathbf{F}_{contact}$
  • Rotational: $I_i \frac{d\omega_i}{dt} = \tau_p - I_i \frac{\omega_i}{t_{rot}} + \sum \tau_{contact}$
  • Where $\mathbf{F}_p$ and $\tau_p$ are user-defined propulsion forces/torques (the "decisional layer"), and $t_{transl}/t_{rot}$ represent relaxation times due to ground friction.
• Solver: The system uses the Velocity-Verlet algorithm to integrate these coupled differential equations.

C. Software Architecture

LEMONS is designed for modularity and extensibility:

• C++ Library (CrowdMechanics): A high-performance shared library handling the mechanical layer, contact detection, and time evolution.
• Python Wrapper: Facilitates crowd generation, visualization, and interaction with the C++ library.
• XML Configuration: Uses a generic XML format (processed via TinyXML-2) to define static parameters (geometry, materials, agent shapes) and dynamic states (positions, velocities, forces). This allows for easy interchangeability and configuration.
• Online Platform: A Streamlit-based web interface for generating crowds, visualizing shapes, and downloading configuration files without coding.

3. Key Contributions

1. Realistic Shape Modeling: Introduction of a 5-disk composite shape derived from medical data, enabling realistic packing densities (~7.2 pedestrians/m²) and multi-contact interactions.
2. Open-Source Framework: Release of a complete, modular tool (Python/C++) that decouples the mechanical layer from the decision-making layer, allowing researchers to plug in any behavioral model.
3. Anthropometric Diversity: Capability to generate heterogeneous crowds with varying body types, masses, and dimensions based on statistical databases.
4. Extensibility: The generic XML schema and class structure allow for the inclusion of non-pedestrian agents (e.g., cyclists, strollers) and future 3D extensions.
5. Validation: Comprehensive testing of the mechanical layer (force, friction, torque, relaxation) and a practical case study simulating a push propagating through a queue, showing agreement with experimental data from Feldmann et al.

4. Results

• Packing Density: Simulations using the 5-disk model achieved a maximum random packing density of 7.2 pedestrians/m², significantly closer to real-world observations (8+ ped/m²) than the ~4 ped/m² limit of circular models.
• Mechanical Tests: Eight distinct test suites confirmed the correct implementation of normal forces, Coulomb friction, rotational damping, and relaxation dynamics.
• Case Study: A simulation of a push propagating through a line of pedestrians (mimicking Feldmann et al. experiments) successfully reproduced the trajectory and force propagation observed in physical experiments, validating the mechanical parameters (Young's modulus, damping coefficients).
• Visualization: The tool successfully generated 2D and 3D visualizations of heterogeneous crowds, including mixed populations of pedestrians and cyclists.

5. Significance

LEMONS represents a paradigm shift in crowd simulation by moving away from idealized circular agents toward physically grounded, anthropometry-based models.

• Scientific Impact: It enables more accurate studies of high-density crowd phenomena, such as stampedes, crushes, and crowd turbulence, where body shape and contact mechanics are critical.
• Practical Application: The tool is accessible to both experts and beginners (via the web interface), aiding urban planners and public authorities in designing safer spaces.
• Pedagogical Value: It serves as an educational tool for teaching complex systems, active matter, and granular physics.
• Future-Proofing: By separating the mechanical solver from the decision-making logic, LEMONS provides a robust foundation for future research into the coupling of human behavior and physical constraints in complex environments.