Pith. sign in

REVIEW 3 major objections 5 minor 30 references

Fast Simulation of Crowd Collision Avoidance

T0 review · 3 major / 5 minor · reviewed 2026-08-14 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read The paper claims that ORCA pedestrian steering, implemented on a GPU with a batch linear-program solver and grid-based neighbor sharing, runs up to 30 times faster than the multicore CPU version and can simulate over 100,000 people in…

desk verdict GPU ORCA with plausible 30x speedups, but the paper never shows the GPU and CPU neighbor sets match, so the headline claim is conditional. read the letter →

arxiv 1908.10107 v1 pith:FEKVPFKP submitted 2019-08-27 cs.RO

John Charlton , Luis Rene Montana Gonzalez , Steve Maddock , Paul Richmond This is my paper · ORCID
classification cs.RO
keywords ORCApedestriansimulationGPUcomputingcollisionavoidancevelocityobstacleslinearprogrammingspatialpartitioningreal-timecrowd
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper sets out to show that the ORCA pedestrian steering model, which is normally run on CPUs, can be implemented on the GPU without changing its collision-avoidance logic. It reports a GPU implementation that is up to 30 times faster than a multicore CPU reference and that wins outright once there are roughly 2,000 agents or more. The speed comes from a GPU-tailored batch linear-program solver for the per-agent velocity problem and from grid-based spatial partitioning that limits each agent to reading nearby agents' messages. The payoff is that more than 100,000 simulated people can be updated at real-time frame rates, a scale useful for interactive crowd and safety studies.

What carries the argument

The load-bearing mechanism is the combination of a batch two-dimensional linear-programming solver built for GPU execution and a spatial-partitioning message system. In ORCA each agent's constraints are half-planes in velocity space, one per nearby person, and the agent must pick the velocity closest to its desired one that satisfies all half-planes; this is exactly the low-dimensional LP the batch solver is designed for. The solver is based on an incremental LP algorithm but reorganized into cooperative 'work units' so that when one agent's constraints force a new velocity calculation, other threads can help rather than idle. The neighbor-sharing side uses a grid of spatial bins: each agent writes a message of its observable properties to its bin, and reads messages only from its own and neighboring bins, avoiding the all-to-all read while keeping communication local.

What would settle it

Instrument both implementations to record each agent's neighbor list on identical scenarios and population counts; any agent whose GPU neighbor list omits a neighbor that the CPU KD-tree includes would show that the GPU solves a different, smaller problem, and the 30x figure would not reflect pure implementation speed.

Watch

Extended reading notes

Core claim

The central claim is that ORCA's per-agent velocity selection can be parallelized efficiently enough to move the entire model to the GPU. The authors argue that the two expensive parts of ORCA—solving a low-dimensional linear program for every agent every timestep, and letting each agent observe its neighbors—both have GPU-friendly replacements: a batch LP solver that keeps threads busy by splitting constraint-update work into equal-sized units, and a bin-based message partition so agents read only nearby bins. On the GPU hardware used in the experiments they measure up to a 30x speed-up over the multicore CPU version, with the GPU ahead for sufficiently large populations and reaching close to 30 frames per second at roughly 500,000 agents. They conclude that real-time interactive simulation of very large crowds is practical on current graphics hardware.

Load-bearing premise

The speed comparison is fair only if the GPU's fixed-size spatial bins return the same nearby-neighbor set as the KD-tree used by the CPU version; the paper does not state the bin size or observation radius, or verify that the neighbor sets match.

Editorial extensions

If this is right

  • Above roughly 2,000 agents the GPU implementation is consistently faster than the multicore CPU version, and the advantage grows with population size.
  • Crowds over 100,000 people can be simulated at 60 frames per second on consumer GPU hardware, making interactive crowd scenarios feasible.
  • The GPU version keeps ORCA's collision-avoidance semantics, so existing ORCA-based applications can adopt it without redesigning their steering logic.
  • GPU memory, not computation time, currently caps the simulation at about 500,000 agents on 4 GB; the authors expect managed memory or larger GPUs to raise that ceiling.
  • Real-time visualizations in an external rendering engine were demonstrated for 2,500 and 10,000 agents, which the paper says would not be possible on comparable CPU hardware.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The paper does not quantify whether the bin-based neighbor query reproduces the KD-tree neighbor sets, so the headline speed-up is best read as a GPU-vs-CPU engineering gain plus any difference in the interaction set; a direct neighbor-set comparison would settle how much is each.
  • Since ORCA's constraints are half-planes in velocity space, the same batch LP solver and binning pipeline should transfer to other velocity-obstacle variants that share that constraint structure, such as reciprocal velocity obstacles.
  • Replacing fixed bins with a radius- or density-aware neighbor query could make the GPU behavior match the CPU behavior more closely in heterogeneous crowds, at some cost in throughput.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 5 minor

Summary. The paper describes a GPU implementation of the ORCA crowd-collision-avoidance model. The two main ingredients are a specialized batched low-dimensional linear-program solver taken from the authors' earlier work and a uniform-grid spatial partitioning scheme based on FLAME-style message passing, which replaces the KD-tree neighbor lookup used by the CPU RVO2 reference implementation. The manuscript presents visual results for 2-way and 8-way crossing scenarios, plus a performance benchmark against the multi-core CPU ORCA implementation. It reports speedups of up to 30 times and states that the GPU simulations ran at close to 30 frames per second for up to 5x10^5 agents, with the abstract further claiming that over 100,000 people can be simulated in real time at 60 frames per second.

Significance. If the claimed speedups hold, this is a practically useful engineering contribution: it would bring ORCA-style reciprocal collision avoidance into the range of real-time interactive crowd simulation at scales well beyond current CPU implementations. The paper's strengths are the clear decomposition of the ORCA computation into GPU-friendly stages, the reuse of a previously published batch LP solver, and the correct identification of the neighbor-search step as the key algorithmic difference from the CPU baseline. The central performance claim is plausible, but it is only partially supported: the benchmark lacks statistical detail, the code is not provided, and there is no quantitative demonstration that the GPU simulation solves the same ORCA problem as the CPU reference. The contribution is therefore promising but not yet fully verified.

major comments (3)
  1. [§3, Fig. 2] The neighbor-selection parameters are unspecified. The paper does not state the spatial bin side length, the observation radius r_obs, or the corresponding neighborDist and maxNeighbors values used by the CPU RVO2 baseline. Because the GPU reads only an agent's own bin and its immediate neighbors and then filters by r_obs, an agent can fail to observe a neighbor that the CPU KD-tree would include if the bin size is comparable to or smaller than r_obs; conversely, if r_obs is smaller than the CPU neighbor radius, every GPU agent solves a linear program with fewer constraints. Either mismatch would make the timing comparison measure a different, easier problem. The authors should report these parameters for both implementations and provide a quantitative check that they produce the same per-agent neighbor sets, or at least statistically equivalent trajectories, in the benchmark scenarios.
  2. [§4, Fig. 6] The benchmark lacks the statistical and behavioral validation needed to support the headline speedup. No error bars, number of runs, or variance are reported, and the timings are said to be averaged across different test cases and agent parameters without specifying the mix or the per-configuration results. More importantly, there is no quantitative comparison of simulation behavior between the GPU and CPU versions: no collision counts, no flow or density metrics, no trajectory error under identical initial conditions. The visualizations in Figs. 3-5 are too coarse to certify that the GPU implementation is solving the same ORCA problem. The authors should add repeated timing data and a behavioral equivalence check.
  3. [Abstract vs. §4] The abstract claims that the method 'allows over 100,000 people to be simulated in real time (60 frames per second),' but the results section reports a measured operating point of 'close to 30 frames a second' for up to 5x10^5 agents. The specific frame time at 100,000 agents is not given. The authors should either report the measured 100,000-agent frame time explicitly or adjust the abstract and conclusions to state the actual measured operating point.
minor comments (5)
  1. [§3] There is a typo in the paragraph on the incremental solver: 'as only only some of the solvers require a new valid velocity' should read 'as only some of the solvers require a new valid velocity.'
  2. [§3] The sentence 'The associated overhead in organizing messages into bins outweighs the cost of reading all messages and discarding those far away' appears to say the opposite of what is intended; it should probably read 'is outweighed by' or be rephrased.
  3. [§4] The description of Fig. 6 is confusing: it states that the colored bars correspond to the primary axis and the relative time to the secondary axis, but the figure caption says the secondary axis uses a linear scale for 'relative timing.' Please clarify which curves or bars are associated with which axis and define the quantity plotted on the secondary axis.
  4. [§4] The statement that 'the speed increases proportionally to the number of people' is unclear; the data presumably show that the relative speedup grows with the number of agents, not that the absolute speed increases. Please rephrase.
  5. [General] The paper does not state whether the simulation code or benchmark data will be made available. For an engineering performance contribution, source code or a reproducibility package would substantially strengthen the claims.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the central speedup claim is a measured benchmark of a GPU ORCA implementation against an external CPU baseline, and the cited GPU components are independently published rather than fitted to this paper's results.

full rationale

The paper's central claim is an engineering performance result: the GPU implementation is benchmarked against the multi-core CPU ORCA library and frame times are measured directly, so no parameter is fitted to reproduce the claimed speedup and no predictive quantity is defined in terms of the output. The self-citations to the batch GPU linear-programming solver [8] and FLAME GPU message framework [22] describe components used in the implementation, but the load-bearing support for the speedup claim is the measured comparison with the CPU baseline in Section 4, not a derivation from those citations. The batch solver was published separately in the Journal of Parallel and Distributed Computing and is externally falsifiable, so it constitutes real independent evidence rather than circular reliance. The paper's failure to report bin sizes, observation radius, or CPU neighbor parameters is a potential threat to the fairness of the comparison, because the GPU grid neighborhood may not match the CPU KD-tree neighborhood; however, that is a correctness or experimental-validity concern, not a circularity concern, since the report does not presuppose the equivalence of the neighbor sets in order to derive the speedup. Because no step in the paper reduces, by construction or by self-citation, to its own inputs, the circularity score is 0.

Assumptions & free parameters 2 free parameters · 3 assumptions · 0 invented entities

The paper is an engineering performance study. It introduces no new physical or mathematical entities. The main unstated inputs are simulation parameters (bin size, observation radius) and the assumption that the GPU neighbor search matches the CPU baseline, which together support the fairness of the speedup comparison.

free parameters (2)
  • spatial bin size = not reported
    The grid cell size used in message partitioning is not stated; its relationship to the observation radius determines whether all relevant neighbors are found, and it directly affects performance.
  • observation radius (robs) = not reported
    The cutoff for neighbor interaction is a user-set parameter of ORCA; without its value, the equivalence between GPU grid search and CPU KD-tree neighbor sets cannot be checked.
assumptions (3)
  • standard math ORCA half-plane formulation as described by van den Berg et al. [4] is correct and applicable.
    The GPU implementation inherits the ORCA linear programming formulation without modification; the paper cites [4] for the derivation.
  • domain assumption All neighbors within the observation radius fall within the bin neighborhood read by each agent in the grid partitioning.
    The message partitioning reads only same and neighboring bins; if the bin size is too small relative to the observation radius, agents would miss neighbors, changing behavior. This is assumed but never stated or verified.
  • domain assumption The GPU implementation produces behavior equivalent to the CPU ORCA model, so timing comparisons are apples-to-apples.
    The paper only shows visual examples and claims expected behaviors like lane formation; no quantitative trajectory or collision comparison is provided.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Fast Simulation of Crowd Collision Avoidance." pith.science (2026). https://pith.science/paper/FEKVPFKP

@misc{pith2026190810107,
  author       = {Pith},
  title        = {Pith review of: Fast Simulation of Crowd Collision Avoidance},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/FEKVPFKP}},
  note         = {Machine review of arXiv:1908.10107}
}
read the original abstract

Real-time large-scale crowd simulations with realistic behavior, are important for many application areas. On CPUs, the ORCA pedestrian steering model is often used for agent-based pedestrian simulations. This paper introduces a technique for running the ORCA pedestrian steering model on the GPU. Performance improvements of up to 30 times greater than a multi-core CPU model are demonstrated. This improvement is achieved through a specialized linear program solver on the GPU and spatial partitioning of information sharing. This allows over 100,000 people to be simulated in real time (60 frames per second).

Figures

Figures reproduced from arXiv: 1908.10107 by the authors.

Figure 1
Figure 1. (a) A system of 2 people a and b with corresponding radius ra and rb. (b) The associated velocity obstacle V Oa|b in velocity space for a look-ahead period of time τ caused by the neighbor b for a. (c) The vector of velocities v opt a − v opt a lies within the velocity obstacle V Oa|b . The vector u is the shortest vector to the edge of the obstacle from the vector of velocities. The corresponding half-plane ORCAa|b… view at source ↗
Figure 2
Figure 2. FLAME message partitioning. The simulation is discretized into spatial [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗
Figure 3
Figure 3. Visualization of 2,500 people in Unreal. Two crowds navigate past each [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (3 more)
Figure 4
Figure 4. Figure 4: Visualization of 2,500 people in Unreal. Two crowds navigate past each [PITH_FULL_IMAGE:figures/full_fig_p008_4.png]
Figure 5
Figure 5. Figure 5: Visualization of 10,000 people in Unreal. Eight crowds attempting to [PITH_FULL_IMAGE:figures/full_fig_p009_5.png]
Figure 6
Figure 6. Figure 6: Frame time (in ms) for multi-core CPU and GPU ORCA models with [PITH_FULL_IMAGE:figures/full_fig_p010_6.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

30 extracted references · 21 canonical work pages

  1. [1]

    In: Proceedings 2001 IEEE/RSJ International Conference on Intelligent Robots and Systems

    Abe, Y., Yoshiki, M.: Collision avoidance method for multiple autonomous mo- bile agents by implicit cooperation. In: Proceedings 2001 IEEE/RSJ International Conference on Intelligent Robots and Systems. Expanding the Societal Role of Robotics in the the Next Millennium (Cat. No.01CH37180). vol. 3, pp. 1207–1212 vol.3 (Oct 2001). https://doi.org/10.1109/I...

    work page arXiv 2001

  2. [2]

    Graphical Models 99, 31–45 (Sep 2018)

    Barut, O., Haciomeroglu, M., Sezer, E.A.: Combining GPU-generated linear trajec- tory segments to create collision-free paths for real-time ambient crowds. Graphical Models 99, 31–45 (Sep 2018). https://doi.org/10.1016/j.gmod.2018.07.002

    work page doi:10.1016/j.gmod.2018.07.002 2018

  3. [3]

    In: IEEE International Conference on Robotics and Automation, 2008

    van den Berg, J., Lin, M., Manocha, D.: Reciprocal Velocity Obstacles for real-time multi-agent navigation. In: IEEE International Conference on Robotics and Automation, 2008. ICRA 2008. pp. 1928–1935 (May 2008). https://doi.org/10.1109/ROBOT.2008.4543489

    arXiv 2008

  4. [4]

    In: Robotics Research, pp

    van den Berg, J., Guy, S.J., Lin, M., Manocha, D.: Reciprocal n-Body Collision Avoidance. In: Robotics Research, pp. 3–19. Springer, Berlin, Heidelberg (2011). https://doi.org/10.1007/978-3-642-19457-3 1

    doi:10.1007/978-3-642-19457-3 2011

  5. [5]

    White paper, GDC 9 (2009)

    Bleiweiss, A.: Multi agent navigation on the gpu. White paper, GDC 9 (2009)

    work page 2009

  6. [6]

    Transportation Research Record: Journal of the Transportation Research Board 1644, 29–36 (1998)

    Blue, V., Adler, J.: Emergent Fundamental Pedestrian Flows From Cel- lular Automata Microsimulation — Request PDF. Transportation Research Record: Journal of the Transportation Research Board 1644, 29–36 (1998). https://doi.org/http://dx.doi.org/10.3141/1644-04

    doi:10.3141/1644-04 1998

  7. [7]

    Transportation Research Record: Journal of the Transportation Research Board 1678, 135–141 (Jan 1999)

    Blue, V., Adler, J.: Cellular Automata Microsimulation of Bidirectional Pedestrian Flows. Transportation Research Record: Journal of the Transportation Research Board 1678, 135–141 (Jan 1999). https://doi.org/10.3141/1678-17

    work page doi:10.3141/1678-17 1999

  8. [8]

    Journal of Parallel and Distributed Computing 126, 152–160 (Apr 2019)

    Charlton, J., Maddock, S., Richmond, P.: Two-dimensional batch linear program- ming on the GPU. Journal of Parallel and Distributed Computing 126, 152–160 (Apr 2019). https://doi.org/10.1016/j.jpdc.2019.01.001

    work page doi:10.1016/j.jpdc.2019.01.001 2019

Show all 30 references
  1. [9]

    CIS Final Project Final report, University of Pennsylvania (2007)

    Fickett, M., Zarko, L.: GPU Continuum Crowds. CIS Final Project Final report, University of Pennsylvania (2007)

    2007

  2. [10]

    The Int’l Journal of Robotics Research 17(7), 760–772 (Jul 1998)

    Fiorini, P., Shiller, Z.: Motion Planning in Dynamic Environments Using Veloc- ity Obstacles. The Int’l Journal of Robotics Research 17(7), 760–772 (Jul 1998). https://doi.org/10.1177/027836499801700706

    1998 doi

  3. [11]

    In: Proceedings 2007 IEEE International Conference on Robotics and Automation

    Fulgenzi, C., Spalanzani, A., Laugier, C.: Dynamic Obstacle Avoidance in uncer- tain environment combining PVOs and Occupancy Grid. In: Proceedings 2007 IEEE International Conference on Robotics and Automation. pp. 1610–1616. IEEE, Rome, Italy (Apr 2007). https://doi.org/10.11...

    2007

  4. [12]

    In: Proceedings of the 2009 ACM SIGGRAPH/Eurographics Symposium on Com- puter Animation

    Guy, S.J., Chhugani, J., Kim, C., Satish, N., Lin, M., Manocha, D., Dubey, P.: ClearPath: Highly Parallel Collision Avoidance for Multi-agent Simulation. In: Proceedings of the 2009 ACM SIGGRAPH/Eurographics Symposium on Com- puter Animation. pp. 177–187. SCA ’09, ACM, New Yor...

    2009

  5. [13]

    arXiv:1602.03623 [cs] (Feb 2016)

    He, L., Pan, J., Narang, S., Wang, W., Manocha, D.: Dynamic Group Behaviors for Interactive Crowd Simulation. arXiv:1602.03623 [cs] (Feb 2016)

    2016 arXiv

  6. [14]

    Helbing, D., Moln´ ar, P.: Social force model for pedestrian dynamics. Phys. Rev. E 51(5), 4282–4286 (May 1995). https://doi.org/10.1103/PhysRevE.51.4282 12 J. Charlton et al

    1995 doi

  7. [15]

    EG UK Theory and Practice of Computer Graphics (2010)

    Karmakharm, T., Richmond, P.: Agent-based Large Scale Simulation of Pedestri- ans With Adaptive Realistic Navigation Vector Fields. EG UK Theory and Practice of Computer Graphics (2010)

    2010

  8. [16]

    In: Yuta, S., Asama, H., Prassler, E., Tsubouchi, T., Thrun, S

    Kluge, B., Prassler, E.: Recursive Probabilistic Velocity Obstacles for Reflective Navigation. In: Yuta, S., Asama, H., Prassler, E., Tsubouchi, T., Thrun, S. (eds.) Field and Service Robotics: Recent Advances in Reserch and Applications, pp. 71–79. Springer Tracts in Advanced ...

    2006 doi

  9. [17]

    V´ aclav Skala - UNION Agency (2013)

    Li, B., Mukundan, R.: A Comparative Analysis of Spatial Partitioning Methods for Large-Scale, Real-Time Crowd Simulation. V´ aclav Skala - UNION Agency (2013)

    2013

  10. [18]

    In: ACM SIGGRAPH Asia 2009 Papers

    Narain, R., Golas, A., Curtis, S., Lin, M.C.: Aggregate Dynamics for Dense Crowd Simulation. In: ACM SIGGRAPH Asia 2009 Papers. pp. 122:1–122:8. SIGGRAPH Asia ’09, ACM, New York, NY, USA (2009). https://doi.org/10.1145/1661412.1618468

    2009

  11. [19]

    http://docs.nvidia.com/cuda/maxwell-tuning-guide/index.html (2018)

    Nvidia: Tuning CUDA Applications for Maxwell. http://docs.nvidia.com/cuda/maxwell-tuning-guide/index.html (2018)

    2018

  12. [20]

    In: ACM SIGGRAPH 2008 Classes

    Pettr´ e, J., Kallmann, M., Lin, M.C.: Motion Planning and Autonomy for Virtual Humans. In: ACM SIGGRAPH 2008 Classes. pp. 42:1–42:31. SIGGRAPH ’08, ACM, New York, NY, USA (2008). https://doi.org/10.1145/1401132.1401193

    2008

  13. [21]

    In: Bousseau, A., Gutierrez, D

    Pettr´ e, J., Pelechano, N.: Introduction to Crowd Simulation. In: Bousseau, A., Gutierrez, D. (eds.) EG 2017 - Tutorials. The Eurographics Association (2017). https://doi.org/10.2312/egt.20171029

    2017 doi

  14. [22]

    Department of Com- puter Science Technical Report CS-11-03, University of Sheffield (2011)

    Richmond, P.: Flame Gpu Technical Report and User Guide. Department of Com- puter Science Technical Report CS-11-03, University of Sheffield (2011)

    2011

  15. [23]

    Proceedings of EUROSIS ESM2008 (2008)

    Richmond, P., Romano, D.M.: A high performance framework for agent based pedestrian dynamics on gpu hardware. Proceedings of EUROSIS ESM2008 (2008)

    2008

  16. [24]

    Biosystems 51(3), 123–143 (Sep 1999)

    Sch¨ onfisch, B., de Roos, A.: Synchronous and asynchronous updating in cellular automata. Biosystems 51(3), 123–143 (Sep 1999). https://doi.org/10.1016/S0303- 2647(99)00025-8

    1999 doi

  17. [25]

    Discrete Comput Geom 6(3), 423–434 (Sep 1991)

    Seidel, R.: Small-dimensional linear programming and convex hulls made easy. Discrete Comput Geom 6(3), 423–434 (Sep 1991). https://doi.org/10.1007/BF02574699

    1991 doi

  18. [26]

    Contribute to snape/RVO2 development by creating an account on GitHub (Mar 2019)

    Snape, J.: Optimal Reciprocal Collision Avoidance (C++). Contribute to snape/RVO2 development by creating an account on GitHub (Mar 2019)

    2019

  19. [27]

    In: Proceedings of the 2006 ACM International Conference on Virtual Reality Continuum and Its Applications

    Thalmann, D.: Populating Virtual Environments with Crowds. In: Proceedings of the 2006 ACM International Conference on Virtual Reality Continuum and Its Applications. pp. 11–11. VRCIA ’06, ACM, New York, NY, USA (2006). https://doi.org/10.1145/1128923.1128925

    2006

  20. [28]

    In: Proceedings of the 21st ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming

    Wang, Y., Davidson, A., Pan, Y., Wu, Y., Riffel, A., Owens, J.D.: Gunrock: A high-performance graph processing library on the GPU. In: Proceedings of the 21st ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming. p. 11. ACM (2016)

    2016

  21. [29]

    Journal of Computer Science and Technology 29, 799–811 (Sep 2014)

    Xu, M.L., Jiang, H., Jin, X., Deng, Z.: Crowd Simulation and Its Applications: Recent Advances. Journal of Computer Science and Technology 29, 799–811 (Sep 2014). https://doi.org/10.1007/s11390-014-1469-y

    2014 doi

  22. [30]

    2016 IEEE International Conference on Robotics and Automation (ICRA) pp

    Yang, Z., Pan, J., Wang, W., Manocha, D.: Proxemic group behav- iors using reciprocal multi-agent navigation. 2016 IEEE International Conference on Robotics and Automation (ICRA) pp. 292–297 (2016). https://doi.org/10.1109/ICRA.2016.7487147

    2016

Pith tools

Reviewed August 14, 2026 · model on record in the stance chip above.