Publicité
+ Répondre à la discussion
Affichage des résultats 1 à 5 sur 5

Discussion: Collision de disques

  1. #1
    Nouveau Membre du Club Avatar de CompuTux
    Homme Profil pro Cédric Bohnert
    Développeur Python et Django
    Inscrit en
    juillet 2004
    Messages
    78
    Détails du profil
    Informations personnelles :
    Nom : Homme Cédric Bohnert
    Âge : 35
    Localisation : France, Bas Rhin (Alsace)

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

    Informations forums :
    Inscription : juillet 2004
    Messages : 78
    Points : 29
    Points
    29

    Par défaut Collision de disques

    Bonjour,

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

    Code :
    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
    Nouveau Membre du Club Avatar de CompuTux
    Homme Profil pro Cédric Bohnert
    Développeur Python et Django
    Inscrit en
    juillet 2004
    Messages
    78
    Détails du profil
    Informations personnelles :
    Nom : Homme Cédric Bohnert
    Âge : 35
    Localisation : France, Bas Rhin (Alsace)

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

    Informations forums :
    Inscription : juillet 2004
    Messages : 78
    Points : 29
    Points
    29

    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 Expert
    Homme Profil pro
    Inscrit en
    mars 2011
    Messages
    542
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : mars 2011
    Messages : 542
    Points : 1 040
    Points
    1 040

    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
    Nouveau Membre du Club Avatar de CompuTux
    Homme Profil pro Cédric Bohnert
    Développeur Python et Django
    Inscrit en
    juillet 2004
    Messages
    78
    Détails du profil
    Informations personnelles :
    Nom : Homme Cédric Bohnert
    Âge : 35
    Localisation : France, Bas Rhin (Alsace)

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

    Informations forums :
    Inscription : juillet 2004
    Messages : 78
    Points : 29
    Points
    29

    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 :
    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 Expert
    Homme Profil pro
    Inscrit en
    mars 2011
    Messages
    542
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : mars 2011
    Messages : 542
    Points : 1 040
    Points
    1 040

    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

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •