Cycle ingénieur
Master géomatique
1ère année
Programmation orientée objet
avec python
cbnd
Marie-Dominique Van Damme
2023-2024
Table des matières
1 Exercice de programmation orientée objet 3
1.1 Point . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Triangle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 Quelques opérations supplémentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3.1 Affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3.2 Distances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3.3 Égalité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3.4 Opération In . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2 Simulation d’un banc de poissons 6
2.1 Classe Poisson : les caractéristiques de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2 Classe Banc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3 Classe Poisson : les comportements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.4 Classe Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1
Programmation orientée objet avec python
Planning
∼ Paradigme de la POO
mercredi 28/02 matin ∼ Classes, objets, constructeurs
∼ Exo du triangle
∼ Surcharge de méthodes
mardi 5/03 matin
∼ Exos
mardi 5/03 après-midi ∼ Exo banc de poisson
∼ Héritage, encapsulation, polymorphisme
mardi 12/03 matin
∼ Exos
∼ Classes abstraites, interfaces
vendredi 15/03 matin
∼ Exo itinéraires de randonnées
vendredi 22/03 matin ∼ Exos
∼ Qt
lundi 25/03 matin ∼ Dessin, composants graphiques
∼ Evenement
vendredi 29/03 ∼ TP Noté
après-midi ∼ sans internet - cours et exos autorisés
Table 1 – Programme prévisionnel
2
Exercice de programmation orientée objet
1
1.1 Point
Définir une classe Point (dans un fichier [Link]) possédant les éléments suivants :
} données : deux attributs, les coordonnées x et y (flottants) du point
} méthodes :
un constructeur qui permet de créer des objets Point
une méthode plot qui permet d’afficher l’instance du Point dans un graphique. Elle prend en paramètre
un attribut style qui spécifie la couleur du tracé (g = green, r = red, b = blue, k = black, etc.) et le symbole
d’affichage ('o'= rond, 'x'= croix, '∧ '= triangle, etc.)
une méthode translate qui translate l’instance du Point suivant un vecteur (dx, dy)
une méthode duplic_translate qui réplique l’instance du Point puis le translate
Dans le programme principal ([Link]), instancier 3 objets de la classe Point (par exemple P1 (0.3, 0.1), P2 (0.6,
0.2), P3 (0.2, 0.5)) et invoquer la méthode plot pour chacun d’eux
1.2 Triangle
Définir une classe Triangle (dans un fichier [Link]) possédant les éléments suivants :
} données : trois attributs de type Point : les 3 sommets p1, p2 et p3 du triangle
} méthodes :
un constructeur qui permet de créer des objets Triangle en fonction de 3 points (vérifier que les 3
points ne sont pas alignés)
une méthode plot qui permet d’afficher l’instance du Triangle dans un graphique. Cette méthode prend
en paramètre un attribut style défini de la même façon que celui de la méthode plot du Point.
une méthode translate qui translate l’instance du Triangle suivant un vecteur (dx, dy). (Indication :
penser à utiliser la méthode translate de la classe Point).
une méthode duplic_translate qui réplique l’instance du Triangle puis le translate. (Indication : penser
à utiliser la méthode duplic_translate de la classe Point).
une méthode centroid qui retourne la position du centre du triangle sous le format Point.
une méthode contains permettant de savoir si un point est inclus dans le triangle au sens géometrique.
Cette méthode est une fonction qui retourne True si inclusion, False sinon. (Indication : penser au
produit vectoriel)
3
Programmation orientée objet avec python
Dans le programme principal ([Link]), instancier un objet t1 de la classe Triangle dont les 3 sommets
correspondent aux points définis dans la question précédente. Construire un 2ème objet t2 de la classe Triangle
en translatant t1 suivant le vecteur (0.10, 0.15). Tracer les points associés à t2 . Afficher t1 et t2 dans le même
graphique. Représenter les centres de ces 2 triangles.
Tirer au hasard un nombre N (par exemple 5000) et construire N objets de type Point dans l’emprise [0,1] x [0,1].
Afficher tous les points qui sont à la fois contenus dans le premier triangle et à l’extérieur du second triangle.
4
Programmation orientée objet avec python
1.3 Quelques opérations supplémentaires
1.3.1 Affichage
Écrire la méthode qui permet d’afficher dans la console, les informations pertinentes d’un objet Point et d’un objet
Triangle de façon agréable.
1.3.2 Distances
Écrire une méthode, non statique, distance, qui calcule la distance euclidienne en dimension 2 de l’objet de type
Point avec un autre objet de type Point.
Ajouter une méthode statique, distancePointToPoint, qui calcule la distance euclidienne en dimension 2 entre
deux objets de type Point.
1.3.3 Égalité
Écrire une méthode qui permet de dire quand est-ce que deux objets de type Point ont les mêmes coordonnées.
1.3.4 Opération In
Actuellement, pour afficher uniquement les points tirés au sort qui sont inclus dans le triangle T1 mais pas dans
le triangle T2, les tests utilisaient la méthode contains du triangle comme illustré dans le code ci-dessous.
if [Link](p):
continue
if [Link](p):
[Link]('bx')
Question : modifier le code pour que les instructions des tests correspondent dorénavant à celles-ci :
if p not in t2:
continue
if p in t1:
[Link]('bx')
5
Simulation d’un banc de poissons
2
Le paradigme de la programmation orientée objet est tout à fait adaptée pour des systèmes multi-agents. Dans
ces systèmes, des agents, aux comportements individuels simples, vont travailler de concert pour résoudre des
problèmes plus complexes. Nous les verrons dans un cas simple : le cas d’un banc de poissons.
Vous pourrez remarquer qu’on ne va pas modéliser un banc de poisson, mais le comportement d’un seul
poisson vis à vis des autres ! On fera une simulation pour observer dans une animation quand il y a plein
de poissons en même temps et qui obéissent tous aux mêmes règles.
Les poissons ont des comportements différents liés à la présence d’autres individus suivant trois cercles
concentriques : la zone de répulsion (évitement), la zone d’alignement et la zone d’attraction.
Le modèle s’appuie sur 3 règles comportementales :
} si un poisson dans le banc a un poisson très proche de lui, il va changer de direction pour essayer de l’éviter
} s’il y a un autre poisson dans un distance raisonnable, il va essayer de s’aligner dans la direction de cet
autre poisson
} s’il y a un autre poisson qui est encore plus loin, il va essayer de s’en approcher.
2.1 Classe Poisson : les caractéristiques de base
Définir une classe Poisson (dans un fichier [Link] au même niveau que les deux précédents fichiers créés lors du
précédent TP) possédant les éléments suivants :
} données : deux attributs :
sa position de type Point
un vecteur vitesse sous la forme d’un tuple de dimension 2
} méthodes :
un constructeur qui permet de créer des objets Poisson. Pour tester, on construira une fonction qui
tirera au hasard les coordonnées et la vitesse.
une méthode, non statique, distance, qui calcule la distance euclidienne en dimension 2 de l’objet de
type Poisson avec un autre objet de type Poisson
une méthode qui permet de comparer si deux poissons sont positionnés au même endroit.
une méthode qui met à jour la position du poisson.
6
Programmation orientée objet avec python
une méthode qui permet d’indiquer si deux poissons sont alignés, c’est à dire s’ils sont tous deux situés
à proximité mais sans être dans une zone d’évitement ni dans la zone de cohésion.
une méthode qui normalise la vitesse pour faire en sorte que les vitesses des poissons soient constantes
dans le temps.
Pensez à utiliser des attributs statiques pour stocker certaines informations
2.2 Classe Banc
Définir une classe Banc (dans le fichier [Link]) possédant les éléments suivants :
} données : un attribut :
liste de poissons
} méthodes :
un constructeur qui permet d’initialiser la liste des poissons. Assurez-vous que vous n’ajoutez pas
deux poissons identiques.
ajouter les méthodes qui permet de rendre la classe Banc comme un conteneur de Poisson
Pensez à utiliser des attributs statiques pour stocker certaines informations
2.3 Classe Poisson : les comportements
Ajouter les méthodes qui modélisent le comportement des objets Poisson.
} La méthode qui permet aux poissons d’éviter les murs. Pour cela, il faut tout d’abord s’arrêter au mur.
Ensuite on modifie la direction du poisson en fonction du mur : les murs horizontaux modifient la vitesse
horizontale sans modifier la vitesse verticale, de manière à faire tourner le poisson tout en conservant
globalement sa direction actuelle. On termine la méthode en normalisant le nouveau vecteur. La méthode
retourne Vrai si on a détecté un mur.
} Pour éviter les poissons trop proches, on calcule le vecteur unitaire entre le poisson et le poisson le plus
proche, que l’on retranche à sa propre direction (en réalité, on retranche le quart de la différence). On
termine en normalisant le vecteur vitesse et on retourne Vrai si un poisson a été évité.
} Le dernier comportement est le comportement d’alignement. Pour cela, il faut identifier tous les poissons
dans la zone d’alignement. La nouvelle direction du poisson est une moyenne entre la direction des autres
poissons et sa direction actuelle. On termine en normalisant le vecteur vitesse.
} La dernière méthode est celle permettant de mettre à jour les poissons et qui correspond à leur
comportement global. Pour cela, on cherche d’abord si on doit éviter un mur et sinon un autre poisson.S’il
n’y a pas eu d’évitement, c’est le comportement d’alignement qui est appliqué. Enfin quand la nouvelle
direction est calculée, on l’applique en calculant la nouvelle position.
7
Programmation orientée objet avec python
2.4 Classe Simulation
Pour visualiser le banc de poisson, la classe Simulateur appelle la fonction d’animation de la librairie Pyplot. La
classe Simulateur contient un attribut représentant le banc de poissons. Compléter le code.
from [Link] import FuncAnimation
class Simulateur:
def __init__(self):
?????
def update(self, i):
COORDS = [] # Liste des positions [xi, yi]
?????? remplir COORDS
[Link].set_offsets(COORDS)
[Link]().relim()
[Link]().autoscale_view()
return [Link],
def start_simulation(self):
[Link] = [Link](figsize=(8, 5))
ax = [Link].add_axes([0.0, 0.0, 1.0, 1.0], frameon=True)
????? dessiner les positions initiales des poissons
[Link] = [Link](X, Y, s=30, facecolor="red", alpha=0.8)
[Link] = FuncAnimation([Link], [Link], interval=100)
ax.set_xlim(0, [Link])
ax.set_ylim(0, [Link])
[Link]()