TP-TD

Introduction à la Programmation par Objets
(L1-IPO)
TP n° 7, Printemps 2012
Exercice 7.1 Ouvrez le projet Balle. Pour cela, il suffit d’ouvrir dans Processing l’un des
deux fichiers du projet. Vous les trouverez alors automatiquement tous les deux dans les
onglets de la fenêtre Processing qui s’ouvre. Lorsque vous demanderez « Save », Processing
sauvera l’ensemble du projet !
Dans la fonction draw(), le canvas est effacé et ré-initialisé à un fond jaune à chaque
nouvelle image. Une autre manière de faire consiste à utiliser de la transparence pour avoir
une rémanence à l’écran des dernières positions de la balle. Voici comment faire :
- mettez en commentaire (avec un //) l’instruction fill dans la fonction setup(), ainsi
que l’instruction background dans la fonction draw().
- A la suite de background, insérez les trois lignes suivantes :
fill(255,255,0,α);
rect(0,0,width,height);
fill(0,0,255);
où α est l’argument de transparence (cf TP2, exercice 2), dans [0,255] (0 = transparent et
255 = opaque). Le premier fill fixe le mode de remplissage du rectangle qui suit, rect
affiche un rectangle qui va opacifier l’image précédente, et le dernier fill sert à peindre la
balle.
Testez ce nouveau programme avec différentes valeurs de α. Quelle est la valeur qui vous
paraît produire le plus « bel » effet (en toute subjectivité) ?…
Exercice 7.2 Un « système de particules » est une technique graphique numérique utilisée
par les logiciels de 3D ou d'effets vidéo. Elle permet de simuler de nombreux phénomènes
naturels tels que feu, explosion, fumée, eau, nuage, poussière, neige, feux d'artifices, et
animés à l'aide de propriétés telles que la gravité, du vent, l'inertie... (Wikipédia)
Nous allons dans cet exercice simuler un feu d’artifice sous la forme de jets de particules.
L’utilisation de la transparence donnera une véritable illusion de la réalité !
a) Programmez une classe Particule. Une particule sera un objet ayant six champs :
- quatre champs x, y, vx, vy de type float. Au vu du cours 7, vous devinez bien entendu la
signification de ces champs n’est-ce pas ?…
- un champ entier r représentant le rayon de la particule.
- un champ rand représentant un générateur de nombres aléatoires. Oui, il faudra donc
importer la classe Random.
Commencez par déclarer des champs et écrire un constructeur à 5 paramètres (pourquoi 5 ?).
b) Une particule saura réagir à deux messages, un peu comme dans le cours 7 :
- le message afficheToi() qui provoquera le dessin de la particule (un cercle).
- Le message bouge() qui demande à la particule de bouger d’un pas élémentaire pour la
transition d’image. Un peu comme la balle du cours, mais avec en plus la contrainte
suivante : si la particule sort complètement du canvas, elle se régénère à son point de
départ (le « canon » est situé au centre de la fenêtre). On ré-initialisera aussi sa vitesse en
prenant une petite composante horizontale aléatoire, et une composante verticale
aléatoire dirigée vers le haut. Vous trouverez ultérieurement de manière empirique les
valeurs qui donnent le plus bel effet visuel !
c) Cliquez sur le bouton « flèche droite » situé en haut à droite de la fenêtre Processing et
demander « New Tab » (nouvel onglet). Une nouvelle fenêtre d’édition s’ouvre, vous allez
sauver cette fenêtre sous le nom « Animation ». Dans cette fenêtre, vous allez commencer
par déclarer un tableau de 200 particules, puis définir les fonctions setup() et draw(). La
fonction setup() initialise les 200 particules du tableau, et règle le canvas à une dimension
300 x 300 par exemple. Pour la fonction draw(), vous prendrez exemple sur ce qui a été fait
dans l’exercice 1 : prenez un fond d’écran bleu nuit, et affichez les particules, n’oubliez pas
la transparence ! Bon travail…
N.B. Lorsque vous intialisez les vitesses la première fois, à la construction des particules,
provoquez un effet d’explosion en prenant des vitesses verticales élevées ! Jouez avec les
couleurs, dessinez le canon, envoyez un peu de vent de gauche à droite, etc.
Introduction à la Programmation par Objets
(L1-IPO)
TD n° 7, Printemps 2012
Exercice 7.1 On souhaite modéliser un climatiseur par la classe Climatiseur. Un
climatiseur est programmé avec une température exprimée en degré Celsius (un seul champ
enCelsius). Cette consigne de température a une valeur initiale donnée en paramètre du
constructeur. Il est muni de deux commandes (méthodes) pour augmenter() ou diminuer()
la consigne de 1°C à la fois. Ajouter une méthode afficherTemp() qui affiche la température
à la fois en °C et en °F. On rappelle que :
°C = (°F - 32) * 9/5
Exercice 7.2 On veut maintenant améliorer la classe Climatiseur de l’exercice précédent et
créer une classe Climatiseur2 pour ajouter une valeur de température minimale (champ
min), une valeur maximale (champ max) et une valeur d’incrémentation (champ increment).
Les valeurs minimale et maximale sont spécifiées une fois pour toute lors de la construction
de l’objet. La valeur d’incrément est initialisée à 1 par le constructeur. Seules les valeurs
strictement positives d’incrément sont acceptées.
Exercice 7.3 Mon petit frère doit passer le bac à la fin de l’année et il veut que je l’aide à
réviser la résolution des équations du deuxième degré. Comme je suis convaincu qu’il vaut
mieux faire faire les calculs à l’ordinateur que les faire de tête, je décide de réaliser un
programme en Processing. Proposer une classe Poly2 qui modélise un polynôme du second
degré de la forme ax 2 +bx+c (rappel : en maths, la lettre « x » représente une
« indéterminée »). On souhaite disposer des méthodes suivantes :
eval(double x) : double
// retourne la valeur au point x du polynôme
delta() : double
// retourne le discriminant du polynôme
uneRacine() : double
// retourne UNE racine réelle de ce polynôme
toString() : String
// retourne une représentation sous la forme ”ax2+bx+c”
P
P
N.B. i) La racine carrée de x se note en Processing sqrt(x).
ii) Ni Processing ni Java ne connaissent les nombres complexes ! Si l’on essaye de calculer
la racine carrée de –5, le résultat sera un étrange « NaN » qui signifie : Not A Number !
Exercice 7.4 Avec les bonnes résolutions d’un début d’année, on veut se préparer aux
résultats des examens qui viennent toujours trop vite. Pour cela, vous allez écrire une classe
permettant le calcul de la moyenne. Nous ne sommes pas encore en mesure de faire une
belle classe graphique qui imprime un bulletin (et pourquoi pas après tout ?) mais on peut
d’ores et déjà faire une classe un tant soit peu utile. Nous utiliserons des nombres
approchés.
a)
De quoi a-t-on besoin pour calculer une moyenne ?
b)
Proposer une programmation de la classe Moyenne. Cette classe aura au minimum une
méthode saisieNote(note) qui permet d’entrer une nouvelle note et une méthode
moyenne() pour calculer la moyenne des notes entrées jusqu’à présent.