Simulation du mouvement de piétons sur python

[itslunyitsluny]

Bonjour,
je suis un élève de MP.Je ne suis pas spécialisé en informatique.Mais j'ai les bases de Python.En tout cas,je cherche à faire une simulation dans le plan du mouvement de piétons(un mouvement à deux dimensions :vers le haut,le bas,la droite et la gauche) .Ca doit etre donc une animation.Déjà je ne sais pas comment faire des animations sur Python,et de plus je dois utiliser des équations physiques (que je peux vous donner) et qui dépendent de plusieurs paramètres:le temps,la distance,...
Svp est ce que vous pouvez me guider pour réaliser ce travail (ca m'aidera dans mon TIPE)?
Si vous voulez les equations physiques je pourrais vous les donner avec une explication.
Merci d'avance.
-----

[Henrix]

Bonjour,
Si tu donnais les équations (ce qu'elles représentent et leurs unités), ça pourrait aider.
A part ça, il y a dans Python un module pour le graphisme tkinter ou Tkinter en fonction de la version (pas vraiment une bonne idée ce changement de casse)

[itslunyitsluny]

Bonjour,
Je m'intéresse à un modèle dit de forces sociales,c'est de la méca classique.D'ailleurs,les piétons seront modélisés par des disques
on applique le PFD à l'ième piéton:m_ia_i=f_i+g_i avec ai l'acceleration du ième piéton,mi sa masse.pour gi,c'est la force de contact entre le piéton i et les autres piétons.Normalement cette force a une forme exponentielle,mais on va la simplifier en une sorte de "signal de Dirac".g_i=[somme sur j de] (gij) avec j different de i et g_ij=Kmin(D_ij,0) avec K de l ordre de 1.2 10⁵ kg s^-2.Cette force va servir,pour la simulation,à éviter les congestions.Il ne faut pas que deux disques s'interpenetrent.Autrement dit, dès que la distances entre deux piétons devient négative,il faut avoir une répulsion voire un changement de chemin.Pour fi,c'est le reste des forces sauf les forces de contact,on pourra la simplifier et prendre fi égale à la somme vectorielle du poids et de la réaction du plan.
Pour trouver la position, on peut donc procéder par la méthode d'euler:
Prenons un intervalle de temps [0,T] qu'on divise en N intervalles [t_n,t_n+1].on prend un pas h=T/N qui represente la longueur de [t_n,t_n+1]: on note p la position du ième piéton (élement de R²) (on réécrit les equations déjà évoquées sans l'indice i juste pour alléger l'écriture,donc f et fi c'est la mm chose par exemple)
p_n+1=hv_n+1+p_n
v_n+1=h/m (f_n+g_n)
avec Gⁿ represente la grandeur G à l'instant t_n et Gⁿ⁺¹ represente la grandeur G à l'instant t_n+1.
il faut donc fixer la position initiale,la vitesse initiale et savoir f_n ,g_n.
pour f_n,je crois qu'on peut faire une hypothese très simplificatrice en prenant f=0 à tout instant (Un mouvement sans frottementdans lequel le poids et la reaction du plan se compensent).il reste donc g.

[itslunyitsluny]

Dij est la distance entre le ième et le jème piéton.

[A voir en vidéo sur Futura]

[pm42]

Pour la partie Python, la méthode actuelle recommandée est de faire écrire le squelette du code par ChatGPT.

Par exemple, tu lui dis "ecris le code python qui affiche graphiquement le mouvement d'un piéton dans le plan sur la base d'une fonction foo() dont je fournirai le code plus tard" et il te donne du code avec matplotlib qui n'est pas top pour les animations.

Donc tu ajoutes : "je ne veux pas utiliser matplotlib parce que je veux une animation en temps réel. Peux tu me donner du code qui fait cela ?"

Et tu as du code avec PyGame.

Si tu préfères TkInter, tu lui dis : "Peux t'on faire la même chose avec TkInter ?" et tu as le code.

C'est actuellement ce que font pas mal de gens y compris des programmeurs professionnels : la plupart des codes ont déjà été écrits et passer son temps à piger comment marche une librairie pour faire ce qu'on veut n'a pas une grande valeur ajoutée.

Dans ton cas, tu peux probablement faire quelque chose qui affiche d'abord un résultat précalculé puis passer à l'animation ensuite.

P.S : avant, on faisait la même chose, on cherchait du code qui faisait ce qu'on voulait en open-source ou dans les exemples de stackoverflow.com pour éviter de réinventer la roue. Le faire générer sur la base de specs par une IA est simplement beaucoup plus rapide encore.

[itslunyitsluny]

Bonjour.
Pour la fonction foo(),qu'est ce que je dois mettre dedans?
Merci déjà pour la réponse.

[pm42]

Pour la fonction foo(),qu'est ce que je dois mettre dedans?

A un moment, il faut essayer par soi même, réfléchir un peu, tout ça...

[itslunyitsluny]

Mais foo() n'a meme pas d'arguments,je ne peux pas compléter son code sans savoir à quoi elle sert .

[Henrix]

Foo(v) ça doit être le déplacement initial (pour qu'il se passe quelque chose, que ça bouge)

[MissJenny]

dès que la distances entre deux piétons devient négative

il vaut mieux éviter les distances négatives.

[Ikhar84]

Si les pietons sont de simples cercles... la colision arrive quand la distance entre les centres est (inférieure ou) égale à la somme des deux rayons... le double pour des cercles de même diamètres...

Il vaut mieux utiliser des valeurs absolues pour les distances (une distance dans le monde réel est en valeur absolue, quel que soit le sens des déplacements !).

[itslunyitsluny]

Je me suis mal exprimé,je voudrais dire par distance d=(distance entre les deux centres des deux disques) - 2* (rayon du disque)

[MissJenny]

Je me suis mal exprimé

tu n'es pas le seul. Je me souviens d'avoir trouvé dans un livre de bioclimatologie écrit par deux "pointures" du domaine la mention d'une "pression négative"...

[polo974]

Je me suis mal exprimé,je voudrais dire par distance d=(distance entre les deux centres des deux disques) - 2* (rayon du disque)

Quand on compare des distances, autant comparer le carré des distances, ça économise une ou des racines carrées...

(bon, en python, ça ne se verra peut-être pas beaucoup, mais c'est un réflexe à avoir.)

[itslunyitsluny]

Quand on compare des distances, autant comparer le carré des distances, ça économise une ou des racines carrées...

(bon, en python, ça ne se verra peut-être pas beaucoup, mais c'est un réflexe à avoir.)

J'ai compris l'idée,mais ca ne marchera pas dans ce cas car on compare à 0,si on compare les carrées ca donnera tjrs 0.

[itslunyitsluny]

Voici un code que j'ai modifié pour qu'il soit adapté à mes équations.
Le problème c'est que meme si j'ai inséré deux equations ax=Fx/m et Fy=ay/m ,avec Fx=[somme sur j de] (Fij(x)) Fy=[somme sur j de] (Fij(y)) où j different de i et Fij(x)=Kmin(Dij,0) (xi-xj)/Dij et Fij(y)=Kmin(Dij,0) (yi-yj)/Dij et Dij la distance entre les centres des deux disques concernés,je rencontre encore un problème d'interpenetration entre les disques.Mais la force F est principalement définie pour éviter ces interpenetrations lors du contact entre deux piétons.ChatGPT me propose alors un bloc supplementaire pour résoudre ce problème,mais je ne suis pas convaincu,est ce que vous pouvez me proposer une alternative pour ne pas ajouter un bloc supplementaire?
Le code:

import pygame
import random
import math

# Initialize Pygame
pygame.init()

# Set up the display
width, height = 800, 400
screen = pygame.display.set_mode((width, height))
clock = pygame.time.Clock()
pygame.display.set_caption("People Animation")

# Colors
SILVER = (192, 192, 192)
BLACK = (0, 0, 0)
BLUE = (0, 0, 255)
RED = (255, 0, 0)

# Constants
NUM_PEOPLE = 350
PERSON_RADIUS = 10
MAX_SPEED = 4
INTERACTION_FORCE = 0.1
DOOR_WIDTH = 5
DOOR_HEIGHT = 100
MASS = 1.0
DT = 0.1

# Create a list of people
people = []
for _ in range(NUM_PEOPLE):
    x = random.uniform(PERSON_RADIUS, width - PERSON_RADIUS)
    y = random.uniform(PERSON_RADIUS, height - PERSON_RADIUS)
    vx = random.uniform(-MAX_SPEED, MAX_SPEED)
    vy = random.uniform(-MAX_SPEED, MAX_SPEED)
    people.append((x, y, vx, vy))

# Calculate the positions of the doors
left_door_x = DOOR_WIDTH
right_door_x = width - DOOR_WIDTH

# Main loop
running = True
while running:
    screen.fill(SILVER)  # Set a silver background

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # Draw the doors
    pygame.draw.rect(screen, BLACK, pygame.Rect(0, height // 2 - DOOR_HEIGHT // 2, DOOR_WIDTH, DOOR_HEIGHT))  # Left door
    pygame.draw.rect(screen, BLACK, pygame.Rect(width - DOOR_WIDTH, height // 2 - DOOR_HEIGHT // 2, DOOR_WIDTH, DOOR_HEIGHT))  # Right door

    # Update and draw people
    for i in range(len(people)):
        x, y, vx, vy = people[i]

        # Calculate the direction towards the nearest door
        left_direction_x = left_door_x - x
        left_direction_y = height / 2 - y
        left_distance_to_target = math.sqrt(left_direction_x ** 2 + left_direction_y ** 2)

        right_direction_x = right_door_x - x
        right_direction_y = height / 2 - y
        right_distance_to_target = math.sqrt(right_direction_x ** 2 + right_direction_y ** 2)

        if left_distance_to_target < right_distance_to_target:
            direction_x = left_direction_x
            direction_y = left_direction_y
        else:
            direction_x = right_direction_x
            direction_y = right_direction_y

        # Normalize the direction vector
        distance_to_target = math.sqrt(direction_x ** 2 + direction_y ** 2)
        if distance_to_target > 1e-8:
            direction_x /= distance_to_target
            direction_y /= distance_to_target

        # Initialize acceleration components
        ax = 0.0
        ay = 0.0

        for j in range(len(people)):
            if i != j:
                x_j, y_j, _, _ = people[j]
                r_i = PERSON_RADIUS
                r_j = PERSON_RADIUS
                distance = math.sqrt((x - x_j) ** 2 + (y - y_j) ** 2)
                force_x = INTERACTION_FORCE * min(distance - 2 * r_i, 0) * (x - x_j) / distance
                force_y = INTERACTION_FORCE * min(distance - 2 * r_i, 0) * (y - y_j) / distance
                ax += force_x / MASS
                ay += force_y / MASS

                # Interpenetration prevention logic
                if distance < 2 * r_i:
                    penetration = 2 * r_i - distance
                    normal = (x_j - x) / distance, (y_j - y) / distance
                    x -= normal[0] * penetration * 0.5
                    y -= normal[1] * penetration * 0.5

        # Add the direction vector towards the door to the acceleration
        ax += (direction_x / DT ** 2) 
        ay += (direction_y / DT ** 2) 

        # Update velocities using Euler method
        vx += ax * DT
        vy += ay * DT

        # Limit the speed
        speed = math.sqrt(vx ** 2 + vy ** 2)
        if speed > MAX_SPEED:
            ratio = MAX_SPEED / speed
            vx *= ratio
            vy *= ratio

        # Update position using Euler method
        x += vx * DT
        y += vy * DT

        # Keep people within the boundaries of the screen
        x = max(PERSON_RADIUS, min(x, width - PERSON_RADIUS))
        y = max(PERSON_RADIUS, min(y, height - PERSON_RADIUS))

        # Update the person's data
        people[i] = (x, y, vx, vy)

        # Draw the person
        pygame.draw.circle(screen, BLUE, (int(x), int(y)), PERSON_RADIUS)
        pygame.draw.circle(screen, RED, (int(x), int(y)), PERSON_RADIUS, 2)
        # Check if the person has reached one of the doors
        if (left_door_x <= x <= left_door_x + DOOR_WIDTH and
                height // 2 - DOOR_HEIGHT // 2 <= y <= height // 2 + DOOR_HEIGHT // 2) or \
                (right_door_x - DOOR_WIDTH <= x <= right_door_x and
                 height // 2 - DOOR_HEIGHT // 2 <= y <= height // 2 + DOOR_HEIGHT // 2):
            # Remove the person from the list
            people.pop(i)
            break        

    pygame.display.flip()
    clock.tick(60)

# Quit the program
pygame.quit()

[itslunyitsluny]

Voici le bloc que je désire eviter:
# Interpenetration prevention logic
if distance < 2 * r_i:
penetration = 2 * r_i - distance
normal = (x_j - x) / distance, (y_j - y) / distance
x -= normal[0] * penetration * 0.5
y -= normal[1] * penetration * 0.5

[JPL]

J’ai fait ce que tu aurais dû faire si tu avais respecté les règles du forum. Tu es conscient qu’un programme python sans indentation est ininterprétable ?

[itslunyitsluny]

Je m'excuse,j'ai cru que l'indentation ne change pas en faisant un copier-coller.Merci.

[JPL]

Hélas non. C’est une bizarrerie bien connue du langage html qui sert à la composition des pages web : on peut mettre autant d’espaces qu’on veut à la suite, l’affichage se comportera comme s’il y en avait un seul. Voilà pourquoi on doit encapsuler les lignes de programme dans une balise spéciale [Code]...[/Code] qui protège la disposition exacte des caractères.

[Henrix]

Il est évident que pour éviter les interpénétrations, il faut une procédure dédiée, qu'on l'appelle bloc, fonction, ou autre...

[itslunyitsluny]

Il est évident que pour éviter les interpénétrations, il faut une procédure dédiée, qu'on l'appelle bloc, fonction, ou autre...

Mais c'est pour cela qu'on a défini la force d'interaction,que j'ai implémenté par la formule a=F/m selon les deux composantes de l'acceleration.Normalement cela doit suffir pour éviter les interpenetration par ce que cette force porte un effet sur l'acceleration .