IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Physique Discussion :

Collision de disques


Sujet :

Physique

  1. #1
    Membre du Club Avatar de CompuTux
    Homme Profil pro
    Développeur Python et Django
    Inscrit en
    Août 2004
    Messages
    82
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 45
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Développeur Python et Django
    Secteur : Conseil

    Informations forums :
    Inscription : Août 2004
    Messages : 82
    Points : 68
    Points
    68
    Par défaut Collision de disques
    Bonjour,

    J'ai écris ce petit script en python, utilisant pygame pour simuler des collisions de disques :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    ###### BALLE REBONDISSANTE PAR CEDRIC B ######
     
    import pygame
    from math import sqrt
    from pygame.locals import *
     
    pygame.init()
     
    # Defining some colors
    black = (0,0,0)
    white = (255,255,255)
    green = (0,255,0)
    red = (255,0,0)
    gray=(115,115,115)
     
    # Defining some constants
    WIDTH = 900
    HEIGHT = 650
     
    # Defining some variables
    x_pos=850
    y_pos=325
    dx,dy=25,-15
     
    # Set the height and width and title of the screen
    size=[WIDTH,HEIGHT]
    screen=pygame.display.set_mode(size, pygame.HWSURFACE)
    pygame.display.set_caption("Flipper")
     
    #Loop until the user clicks the close button
    done=False
     
    # Used to manage how fast the screen updates
    clock=pygame.time.Clock()
     
    def Draw():
        global x_pos, y_pos
        screen.fill(white)
        pygame.draw.circle(screen, red, (x_pos,y_pos),20,0)
        pygame.draw.circle(screen, green, (300,275), 70,0)
        pygame.draw.circle(screen, green, (600,275), 70,0)
        pygame.draw.circle(screen, green, (450,450), 70,0)
     
    def Move():
        global x_pos, y_pos, dx, dy
        x_pos,y_pos = x_pos+dx,y_pos+dy
        if (x_pos>880 and dy>0):
            x_pos, dx, dy = 880,-dx,dy
        if (x_pos>880 and dy<0):
            x_pos, dx, dy = 880,-dx,dy
        if (y_pos>630 and dx>0):
            y_pos, dx, dy=630,dx,-dy
        if (y_pos>630 and dx<0):
            y_pos, dx, dy=630,dx,-dy
        if (x_pos<20 and dy>0):
            x_pos, dx, dy = 20,-dx,dy
        if (x_pos<20 and dy<0):
            x_pos, dx, dy = 20,-dx,dy
        if (y_pos<20 and dx>0):
            y_pos, dx, dy=20,dx,-dy
        if (y_pos<20 and dx<0):
            y_pos, dx, dy=20,dx,-dy
     
     
        d1=(300-x_pos)**2+(275-y_pos)**2
        if (d1<8100):
            pygame.draw.circle(screen, red, (300,275), 70,0)    
            unx=(x_pos-300)/sqrt((300-x_pos)**2+(275-y_pos)**2)
            uny=(y_pos-275)/sqrt((300-x_pos)**2+(275-y_pos)**2)
            utx=-uny
            uty=unx
            vn=unx*dx+uny*dy
            vt=utx*dx+uty*dy
            vn=(-99*vn)/101
            vnx=vn*unx
            vny=vn*uny
            vtx=vt*utx
            vty=vt*uty
            dx=vnx+vtx
            dy=vny+vty
     
        d2=(450-x_pos)**2+(450-y_pos)**2
        if (d2<8100):
            pygame.draw.circle(screen, red, (450,450), 70,0)    
            unx=(x_pos-450)/sqrt((450-x_pos)**2+(450-y_pos)**2)
            uny=(y_pos-450)/sqrt((450-x_pos)**2+(450-y_pos)**2)
            utx=-uny
            uty=unx
            vn=unx*dx+uny*dy
            vt=utx*dx+uty*dy
            vn=(-99*vn)/101
            vnx=vn*unx
            vny=vn*uny
            vtx=vt*utx
            vty=vt*uty
            dx=vnx+vtx
            dy=vny+vty
     
        d3=(600-x_pos)**2+(275-y_pos)**2
        if (d3<8100):
            pygame.draw.circle(screen, red, (600,275), 70,0)    
            unx=(x_pos-600)/sqrt((600-x_pos)**2+(275-y_pos)**2)
            uny=(y_pos-275)/sqrt((600-x_pos)**2+(275-y_pos)**2)
            utx=-uny
            uty=unx
            vn=unx*dx+uny*dy
            vt=utx*dx+uty*dy
            vn=(-99*vn)/101
            vnx=vn*unx
            vny=vn*uny
            vtx=vt*utx
            vty=vt*uty
            dx=vnx+vtx
            dy=vny+vty
     
    # -------- Main Program Loop ---------
    while done==False:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                done=True
        Draw()
        Move()
     
        clock.tick(30)
        pygame.display.update()
     
    pygame.quit()
    Bon, je sais, mon code n'est pas très optimisé, mais il semble fonctionner pendant une minute puis la petite balle rouge se colle au disque vert de gauche.

    Je ne comprends pas pourquoi....

    Auriez vous une solution?

    Merci d'avance!

  2. #2
    Membre du Club Avatar de CompuTux
    Homme Profil pro
    Développeur Python et Django
    Inscrit en
    Août 2004
    Messages
    82
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 45
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Développeur Python et Django
    Secteur : Conseil

    Informations forums :
    Inscription : Août 2004
    Messages : 82
    Points : 68
    Points
    68
    Par défaut
    Pour info j'ai utilisé l'algorithme de ce pdf.

    Ce sont des collisions élastiques et pourtant la vitesse de la balle rouge diminue au cours des collisions.

    J'ai fixé la masse des disques verts à 100 et la masse du disque rouge à 1.

    Cela me dépasse...

  3. #3
    Membre expérimenté
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mars 2011
    Messages
    576
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Mars 2011
    Messages : 576
    Points : 1 527
    Points
    1 527
    Par défaut
    Salut,

    L'impression que ça me donne d'après ta description, c'est que la balle rouge "rentre" à l'intérieur de la balle verte au step N, mais sa vitesse de rebond n'est plus suffisante pour en "ressortir" au step N+1. Elle reste donc collé dedans.

    Lorsque tu calcul ton intersection, avant de calculer ta vitesse de rebond il faut que tu remette ta balle rouge au point de contact avec la balle verte pour éviter ce genre de problème "d'aliasing".
    La perfection est atteinte, non pas lorsqu’il n’y a plus rien à ajouter, mais lorsqu’il n’y a plus rien à retirer. - Antoine de Saint-Exupéry

  4. #4
    Membre du Club Avatar de CompuTux
    Homme Profil pro
    Développeur Python et Django
    Inscrit en
    Août 2004
    Messages
    82
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 45
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Développeur Python et Django
    Secteur : Conseil

    Informations forums :
    Inscription : Août 2004
    Messages : 82
    Points : 68
    Points
    68
    Par défaut
    Salut et merci pour le coup de pouce !

    Ce problème de collision disque/disque est plutôt difficile, je trouve, mais j'en apprends pas mal sur la programmation, surtout en algorithmique, en essayant de le coder.

    En effet, je constate que, bien qu'il soit analytiquement simple, il réserve des surprises numériques comme celui que j'ai décrit précédemment. Pire. En changeant la vitesse initiale, je constate qu'il arrive que le disque se colle à un vert, puis tourne autour de celui-ci, puis se détache complètement pour continuer sa trajectoire et ses collisions....

    J'ai retravaillé mon code qui était bien cochon et voici une version procédurale du script :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    ###### BALLE REBONDISSANTE PAR CEDRIC B ######
     
    import pygame
    from math import sqrt
    from pygame.locals import *
     
    pygame.init()
     
    # Defining some colors
    black = (0,0,0)
    white = (255,255,255)
    green = (0,255,0)
    red = (255,0,0)
    gray=(115,115,115)
     
    # Defining screen dimension constants
    WIDTH = 900
    HEIGHT = 650
     
    # Defining initial position and initial speed
    position=[150,325]
    speed=[25,29]
     
    # Defining balls
    redBall=(position, speed)
    greenBall1=((300,275), 70)
    greenBall2=((600,275), 70)
    greenBall3=((450,450), 70)
     
     
    # Set the height and width and title of the screen
    size=[WIDTH,HEIGHT]
    screen=pygame.display.set_mode(size, pygame.HWSURFACE)
    pygame.display.set_caption("Collisions")
     
    #Loop until the user clicks the close button
    done=False
     
    # Used to manage how fast the screen updates
    clock=pygame.time.Clock()
     
    def Draw(redBall, greenBall1,greenBall2,greenBall3):
        screen.fill(white)
        pygame.draw.circle(screen, red, (redBall[0][0],redBall[0][1]) ,20,0)
        pygame.draw.circle(screen, green, greenBall1[0],greenBall1[1] ,0)
        pygame.draw.circle(screen, green, greenBall2[0],greenBall2[1],0)
        pygame.draw.circle(screen, green, greenBall3[0],greenBall3[1],0)
     
    def CircularCollide(position, speed, center, radius):
        collideSquaredDistance=(center[0]-position[0])**2+(center[1]-position[1])**2
        if (collideSquaredDistance<(20+radius)**2):
            pygame.draw.circle(screen, red, center, radius,0)
            unitaryNormalVect=[(position[0]-center[0])/sqrt(collideSquaredDistance),(position[1]-center[1])/sqrt(collideSquaredDistance)]
            unitaryTangentVect=[-unitaryNormalVect[1],unitaryNormalVect[0]]
            normalSpeed=unitaryNormalVect[0]*speed[0]+unitaryNormalVect[1]*speed[1]
            tangentSpeed=unitaryTangentVect[0]*speed[0]+unitaryTangentVect[1]*speed[1]
            normalSpeed=(-99*normalSpeed)/101
            normalSpeedVect=[normalSpeed*unitaryNormalVect[0],normalSpeed*unitaryNormalVect[1]]
            tangentSpeedVect=[tangentSpeed*unitaryTangentVect[0],tangentSpeed*unitaryTangentVect[0]]
            resultSpeed=[normalSpeedVect[0]+tangentSpeedVect[0],normalSpeedVect[1]+tangentSpeedVect[1]]
            return resultSpeed
        else:
            return speed
     
    def RectangularCollide(position, speed):
        # rectangular collision with screen boundaries
        if (position[0]>880 and speed[1]>0):
            return (880, position[1],-speed[0],speed[1])
        elif (position[0]>880 and speed[1]<0):
            return (880,position[1],-speed[0],speed[1])
        elif (position[1]>630 and speed[0]>0):
            return (position[0], 630,speed[0],-speed[1])
        elif (position[1]>630 and speed[0]<0):
            return (position[0], 630,speed[0],-speed[1])
        elif (position[0]<20 and speed[1]>0):
            return (20, position[1],-speed[0],speed[1])
        elif (position[0]<20 and speed[1]<0):
            return (20, position[1],-speed[0],speed[1])
        elif (position[1]<20 and speed[0]>0):
            return (position[0], 20,speed[0],-speed[1])
        elif (position[1]<20 and speed[0]<0):
            return (position[0], 20,speed[0],-speed[1])
        else:
            return (position[0],position[1], speed[0],speed[1])
     
     
     
     
    # -------- Main Program Loop ---------
    while done==False:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                done=True
        Draw(redBall, greenBall1,greenBall2,greenBall3)
     
        position[0]+=speed[0]
        position[1]+=speed[1]
     
        rectCollideResult=RectangularCollide(position,speed)
        position[0]=rectCollideResult[0]
        position[1]=rectCollideResult[1]
        speed[0]=rectCollideResult[2]
        speed[1]=rectCollideResult[3]
     
        speed=CircularCollide(position, speed, greenBall1[0], greenBall1[1])
        speed=CircularCollide(position, speed, greenBall2[0], greenBall2[1])
        speed=CircularCollide(position, speed, greenBall3[0], greenBall3[1])
     
        clock.tick(30)
        pygame.display.update()
     
    pygame.quit()
    @ Pyros > Je ne m'y connais pas plus que cela en collision, je découvre, et je pense que tu as raison : le disque rouge se positionne dans l'un des disques verts puisque ma condition le lui permet. Par contre je ne vois pas pourquoi le disque peut se replacer à l'extérieur et continuer sa trajectoire. Etrange !

    Aurais-tu une explication stp ?

    De plus j'ai réfléchi toute une après-midi sur comment déterminer la position du disque rouge lorsque je veux le replacer à la surface d'un disque vert. Je connais la position et la vitesse au pas N mais comment faire pour calculer la position au pas N+1 ? En clair, comment supprimer cet effet génant ?

    Merci !

  5. #5
    Membre expérimenté
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mars 2011
    Messages
    576
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Mars 2011
    Messages : 576
    Points : 1 527
    Points
    1 527
    Par défaut
    Aurais-tu une explication stp ?
    Là je vois pas. Mais comme tu es dans un cas qui n'est pas censé arriver (disque à l'intérieur d'une autre), il peut se passer plein de chose. C'est le principe même d'un bug

    comment faire pour calculer la position au pas N+1 ?
    Sans dessin ça vas être un peu compliquer à expliquer, mais je vais essayer quand même:

    Tu détecte une collision entre 2 disque de centre O1 et O2, de rayon R1 et R2. En théorie (en analytique quoi ) la distance [O1, O2] = R1 + R2. Mais là, à cause de la discrétisation du mouvement, [O1, O2] < R1 + R2.
    Tu dois donc repositionner l'un des disque de manière à ce que [O1, O2] = R1 + R2 + eps (+eps pour éviter le problèmes d'imprécisions et être sûr que les 2 disque ne sont pas l'un dans l'autre au moment du rebond).

    Pour ce faire, c'est assez simple. Tu fait juste une translation sur O1 de:
    (R1+R2 - ||O1 - O2|| + eps) * normalize(O1 - O2).
    A vérifier quand même, je fait souvent des erreurs de signe
    La perfection est atteinte, non pas lorsqu’il n’y a plus rien à ajouter, mais lorsqu’il n’y a plus rien à retirer. - Antoine de Saint-Exupéry

Discussions similaires

  1. Pas de grille adéquate: collision disque/balle + demo
    Par carton99 dans le forum Physique
    Réponses: 1
    Dernier message: 17/07/2013, 03h23
  2. algorithme de collision 3D
    Par chetropinchuste dans le forum Algorithmes et structures de données
    Réponses: 3
    Dernier message: 14/02/2010, 14h16
  3. Réponses: 3
    Dernier message: 31/08/2007, 19h31
  4. Partager son disque
    Par tintin22 dans le forum Web & réseau
    Réponses: 2
    Dernier message: 16/09/2002, 01h34
  5. test collisions
    Par tatakinawa dans le forum OpenGL
    Réponses: 5
    Dernier message: 08/06/2002, 07h03

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo