Manipulation à la souris d'un graphe sans circuit (avec la librairie pygame)
Soyez le premier à donner votre avis sur cette source.
Snippet vu 6 693 fois - Téléchargée 20 fois
Contenu du snippet
Dans l'optique de manipuler un assemblage d'images à la manière d'un pantin articulé, j'ai commencé par implémenter l'idée avec un graphe sans circuits, sous forme de segments articulés.
Ce module permet de déplacer à la souris chaque sommet du graphe, les distances entre les sommets sont respectées.
Le code est volontairement dépouillé afin de vous permettre de l'utiliser dans vos propres projets.
La partie la plus importante est l'algo qui calcule les nouvelles coordonnées des points.(methode move).
- La fonction s'appelle elle-même (récursivité). les nouvelles coordonnées des prédecesseurs et successeurs du point déplacé sont calculées récursivement avant la modification éffective du point. Cela évite d'implémenter une structure de données "pile" puisque les appels récursifs utilisent nativement une pile qui sauvegarde le contexte à la focntion lors de chaque appel.
- Le principe du calcul d'une nouvelle position d'un point A vers une position A' est le suivant :
pour chaque prédecesseur B du point A
calculer les coordonnées du point A de manière que B A et A' soient alignés et l'ancienne distance BA soit respectée
calculer en x et y les distances restant à parcourir au point A pour rejoindre la position A'.
Apliquer ce déplacement au point B
Enfin :
Amusez-vous avec, ajoutez des points modifier le graphe, mes gosses ont "bloqué" dessus pendant une heure !!
...A venir, une appli de création de séquences animées basées sur une succession de postures données à un pantin articulé dont les différentes parties sont des images.
Je planche également sur une solution pour appliquer l'algo avec un graphe dans lequel il y a des cycles.
Ce module permet de déplacer à la souris chaque sommet du graphe, les distances entre les sommets sont respectées.
Le code est volontairement dépouillé afin de vous permettre de l'utiliser dans vos propres projets.
La partie la plus importante est l'algo qui calcule les nouvelles coordonnées des points.(methode move).
- La fonction s'appelle elle-même (récursivité). les nouvelles coordonnées des prédecesseurs et successeurs du point déplacé sont calculées récursivement avant la modification éffective du point. Cela évite d'implémenter une structure de données "pile" puisque les appels récursifs utilisent nativement une pile qui sauvegarde le contexte à la focntion lors de chaque appel.
- Le principe du calcul d'une nouvelle position d'un point A vers une position A' est le suivant :
pour chaque prédecesseur B du point A
calculer les coordonnées du point A de manière que B A et A' soient alignés et l'ancienne distance BA soit respectée
calculer en x et y les distances restant à parcourir au point A pour rejoindre la position A'.
Apliquer ce déplacement au point B
Enfin :
Amusez-vous avec, ajoutez des points modifier le graphe, mes gosses ont "bloqué" dessus pendant une heure !!
Source / Exemple :
# -*- coding: cp1252 -*-
#Jean-Christophe Bouvard Juillet 2007
#nekochat@gmail.com
#déplacement graphique d'un graphe sans circuits
#a la manière d'un pantin articulé
#le graphe peut contenir des sous-graphes non connexes
import math
import os
import getopt
import pygame
from pygame.locals import *
class SimpleGraph:
def __init__(self,points ,arcs):
#liste de couples (x,y) convertis en float pour conserver la précision
self.points=points
for p in range(0,len(self.points)-1):
self.points[p] =intpoint2floatpoint(self.points[p])
#liste de tuples représentant l'ensemble des index de points adjacents
self.arcs=arcs
self.taglist=[]
#déplacer un point en déplacant l'ensemble des sommets de manière récursive
def move(self,pointindex, newpos):
mynewpos=intpoint2floatpoint(newpos)
self.taglist=[]
self.internalmove(pointindex, mynewpos)
self.taglist=[]
def internalmove(self,pointindex, mynewpos):
if not pointindex in self.taglist:
self.taglist.append(pointindex)
#parcours des successeurs.
for i in self.arcs[pointindex]:
#calcul des coordonnées du prédecesseur
#d'abord rotation du point autour du prédecesseur (en gardant la même distance) pour l'aligner
#avec la postion de destination
if i==pointindex:
print "redondance !" + str(i)
ivector=vectorfrom2points(self.points[i],mynewpos)
#rotatepoint=rotatesegment(self.points[i],mynewpos,ivector[0])
dist=distance(self.points[i],self.points[pointindex])
rotatepoint=(self.points[i][0]+ math.cos(ivector[0])*dist,self.points[i][1]+ math.sin(ivector[0])*dist)
#ensuite calcul des distances dx et dy à parcourir pour atteindre la position finale
deltapoint=(mynewpos[0]-rotatepoint[0],mynewpos[1]-rotatepoint[1])
#ajouter le mouvement de ce nouveau point dans la pile par un appel récursif à la fonction move
self.internalmove(i,(self.points[i][0]+deltapoint[0],self.points[i][1]+deltapoint[1]))
#parcour des predecesseurs
for i in range(0, len(self.points)):
if pointindex in self.arcs[i]:
#calcul des coordonnées du prédecesseur
#d'abord rotation du point autour du prédecesseur (en gardant la même distance) pour l'aligner
#avec la postion de destination
ivector=vectorfrom2points(self.points[i],mynewpos)
dist=distance(self.points[i],self.points[pointindex])
rotatepoint=(self.points[i][0]+ math.cos(ivector[0])*dist,self.points[i][1]+ math.sin(ivector[0])*dist)
#ensuite calcul des distances dx et dy à parcourir pour atteindre la position finale
deltapoint=(mynewpos[0]-rotatepoint[0],mynewpos[1]-rotatepoint[1])
#ajouter le mouvement de ce nouveau point dans la pile par un appel récursif à la fonction internalmove
self.internalmove(i,(self.points[i][0]+deltapoint[0],self.points[i][1]+deltapoint[1]))
#... et enfin deplacer le point
self.points[pointindex]=mynewpos
#recherche du sommet le plus proche d'une position donnée (surtout utilisée pour le pointage à la souris)
def nearestpoint(self,point):
best=0
for i in range(0, len(self.points)):
if distance(self.points[i],point)<distance(self.points[best],point):
best=i
return best
#Classe qui dessine une représentation d'une instance de notre SimpleGraph
class SimpleGraphDrawing:
def __init__(self,screen,simplegraph,arccolor=(0,0,0),pointcolor=(0,0,0)):
self.screen=screen
self.arccolor=arccolor
self.pointcolor=pointcolor
self.graph=simplegraph
#dessiner le graphe
def draw(self):
for point in self.graph.points:
indice=self.graph.points.index(point)
for arc in self.graph.arcs[indice]:
pygame.draw.line(self.screen, self.arccolor, floatpoint2intpoint(point),floatpoint2intpoint(self.graph.points[arc]), 1)
#un petit cercle autour de notre sommet pour faire joli
pygame.draw.circle(self.screen, self.pointcolor, floatpoint2intpoint(point), 5, 1)
#-----------------------------------------------------------------------------------------------
#Fonctions utiles dans la manipulation des sommets
#transformer un coupe d'entier en un couple de float
def intpoint2floatpoint(point):
return (float(point[0]),float(point[1]))
#...et un couple de float en entiers
def floatpoint2intpoint(point):
return (int(round(point[0])),int(round(point[1])))
#le point1 est le centre du cercle, le point2 est sur le cercle
#renvoie les coordonnées du point2 "déplacé" sur le cercle en accord avec l'angle
def rotatesegment(point1,point2,angle):
d=distance(point2,point1)
return (point1[0]+math.cos(angle)*d,point1[1]+math.sin(angle)*d)
#calculer la distance entre 2 points
def distance(floatpoint1,floatpoint2):
return abs(math.sqrt(math.pow(floatpoint2[0]-floatpoint1[0],2)+ math.pow(floatpoint2[1]-floatpoint1[1],2)))
#le point1 est le centre du cercle, le point2 est sur le cercle
#on renvoie les coordonnées polaires (angle, distance entre les 2 points)
def vectorfrom2points(floatpoint1,floatpoint2):
mydistance=distance(floatpoint1,floatpoint2)
point=(floatpoint2[0]-floatpoint1[0],floatpoint2[1]-floatpoint1[1])
if mydistance!=0.0:
if point[0]==0.0:
angle=(point[1]/abs(point[1]))*math.pi/2
else:
angle=math.atan(point[1]/point[0])
if point[0]<0.0:
angle=math.pi+angle
else:
print "distance=0 !"
angle=0
mydistance=0
return (angle,mydistance)
#-----------------------MAIN------------------------------------------------------------------------------------------------
def main():
pygame.init()
screen = pygame.display.set_mode((640, 480))
pygame.display.set_caption("manipuler un pantin")
#Création du fond
background = pygame.Surface(screen.get_size())
background = background.convert()
background.fill((250, 250, 250))
#données du graphe
points=[(75,125),(100,125),(150,175),(175,225),(200,175),(150,75),(200,100),(200,50), (320,250),(400,300),(425,450)]
arcs=[[1],[2,5],[3,4],[],[],[6,7],[],[],[9],[10],[]]
#création du graphe
mongraphe=SimpleGraph(points,arcs)
graphdraw=SimpleGraphDrawing(screen,mongraphe,(0,0,0),(250,45,45))
graphdraw.draw()
#Afficher le fond
screen.blit(background, (0, 0))
pygame.display.flip()
#Préparation...
clock = pygame.time.Clock()
#Main Loop--------------------------------------------------------------
#flag pour signifier que le déplacement d'un sommet est en cours
mousedown=False
while 1:
clock.tick(60)
#gestion des evennements
for event in pygame.event.get():
if event.type == QUIT:
return
#le bouton de la souris est enfoncée
#si il était levé on selectionne le sommet le plus proche
#qui suivra les mouvements de la souris jusqu'à qu'il soit relâché
elif event.type==MOUSEBUTTONDOWN:
if mousedown==False:
selectpoint=graphdraw.graph.nearestpoint(pygame.mouse.get_pos())
mousedown=True
elif event.type==MOUSEBUTTONUP:
mousedown=False
if mousedown==True:
graphdraw.graph.move(selectpoint,pygame.mouse.get_pos())
#Re-dessiner tout
screen.blit(background, (0, 0))
graphdraw.draw()
pygame.display.flip()
#------------------------------------------------------------------------------
#Appel de la fonction main lorsque le module est exécuté
if __name__ == '__main__': main()
Conclusion :
...A venir, une appli de création de séquences animées basées sur une succession de postures données à un pantin articulé dont les différentes parties sont des images.
Je planche également sur une solution pour appliquer l'algo avec un graphe dans lequel il y a des cycles.
A voir également
- Manipulation à la souris d'un graphe sans circuit (avec la librairie pygame)
- Position souris - Conseils pratiques -Javascript
- Librairie api - Forum C
- Différence entre bibliothèque et librairie ✓ - Forum C / C++ / C++.NET
- Dessin souris - Forum C# / .NET
- Graphe connexe - Forum Java
30 août 2009 à 18:16
Il y a t il une avancée dans ce projet (jeu ou animation quelconque ???)
13 juil. 2007 à 23:15
10 juil. 2007 à 18:01
Pour la méthode nearestpoint, tu devrais mettre une limite de proximité, car tu pourrais cliquer très loin d'un point et quand même en sélectionner un.
L'usage voudrait qu'on ne vérifie cette proximité que dans un rayon restreint.
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.