Visualisation of the pedestrian orientations/movements, where they are heading to (or want to)

[mip2025]

Hello,

We have some passengers who are currently stuck in our simulation. Despite incorporating social force models and various logic approaches, the issue persists. Therefore, we would like to analyze their orientations in order to gain a deeper understanding of their movements.
We attempted to visualize the movements, but the plot remains empty. Could you please assist us in resolving this issue?

code.txt

Thanks!

[chraibi]

Hi,
do you have a minimal working example? The code you sent is not complete. (for instance holes are not defined)

The code has new models like jps.CellularAutomatonModel and jps.VelocityObstacleModel. Did you implement these in your own fork? I'd like to use it too. Would be nice if you could share.

The jupedsim animation function shows directions. They are calculated, but it still gives a good picture, where agents are going.

Example:

[mip2025]

Dear Chraibi,

Thank you for your prompt response. The agents do appear to demonstrate alignment. However, when multiple passengers converge and obstruct an exit or entrance while barely moving, it becomes unclear which destination they are aiming for. To address this, we hope to gain greater clarity through visualization.

I have attached the code in both .txt and .ipynb formats for your reference.

I truly appreciate your assistance—thank you very much!
code.txt
Python_Code-2212_04.zip

[chraibi]

Maybe you can do something like

 for number, simulation in simulations.items():
        while simulation.agent_count() > 0 and simulation.iteration_count() < max_iterations:
            simulation.iterate()
   
            for agent in simulation.agents():
                print(
                    f"""agent.id = {agent.id}, 
                    agent.position = ({agent.position}, 
                    agent.orientation = {agent.orientation}, 
                    agent.target = {agent.target}
                    """
                )    

Which will give you the information you need.

Moreover, this is probably less helpful but still:
You can plot the route that agents are supposed to take:

import matplotlib.pyplot as plt
import numpy as np

def plot_agent_paths(routing, agent_trajectories, exit_poly, exits):

    fig, ax = plt.subplots(figsize=(10, 8))
    unique_agents = agent_trajectories['id'].unique()
    for e in exits:
        x, y = e.exterior.xy
        ax.plot(x, y, color='black', linewidth=2)

    for agent_id in unique_agents[0:2]:
        agent_data = agent_trajectories[agent_trajectories['id'] == agent_id]
        ax.plot(agent_data['x'], agent_data['y'], '-', lw=0.8, label=f'Agent {agent_id}')
        exit_center = (exit_poly.centroid.x, exit_poly.centroid.y)        
        starting_point = agent_data.iloc[0][['x', 'y']]
        path = routing.compute_waypoints(starting_point, exit_center)
        path_array = np.array(path)
        ax.plot(path_array[:, 0], path_array[:, 1], 'ro--', 
                linewidth=0.8, label=f'Computed Path')
    
        print(exit_poly)
        x, y = exit_poly.exterior.xy
        ax.plot(x, y, color='red', linewidth=2)

        
    
    ax.set_xlabel('X Position')
    ax.set_ylabel('Y Position')
    ax.set_title('Agent Trajectories and Computed Paths')
    ax.grid(True)
    ax.legend()
    
    ax.set_aspect('equal')
    
    plt.tight_layout()
    return fig, ax

# Assuming you have these variables:

# Create the visualization

routing = jps.RoutingEngine(walkable_area1.polygon)

exit_area_train_left = Polygon([(0.2, 5.8), (8.9, 5.8), (8.9, 5.0), (0.2, 5.0)])
exit_area_train_right = Polygon([(9, 5.8), (17.8, 5.8), (17.8, 5.0), (9, 5.0)])
exit_area_boardwalk_left = Polygon([(0.1, 0.1 -2), (8.9, 0.1 -2), (8.9, 0.8 -2), (0.1, 0.8 -2)])
exit_area_boardwalk_right = Polygon([(9, 0.1 -2), (17.9, 0.1 -2), (17.9, 0.8 -2), (9, 0.8 -2)])
exits = [exit_area_train_left , exit_area_train_right, exit_area_boardwalk_left, exit_area_boardwalk_right]

agent_trajectories_data = agent_trajectories.data

fig, ax = plot_agent_paths(routing, agent_trajectories_data, exit_poly=exit_area_train_left, exits=exits)
plt.show()

[mip2025]

Thank you so much! We'll work on implementing it into our simulation and let you know how it goes.