Consignes

Vous devrez utiliser l'interface TPLab pour envoyer vos TP aux encadrants de TP.

La note ne valide pas seulement le résultat de votre programme, mais également son style :

Vérifiez ces points avant de demander à votre intervenant de valider votre code.

Attention : les points suivants ne rapportent rien, mais ne pas les respecter pourra retrancher jusqu'à 10 points sur la note finale :

Liens utiles

1. Images, utiliser la bibliothèque fournie

Attention : les formats d'image utilisés dans ce TP (plain PBM, plain PGM et plain PPM) ne sont pas reconnus nativement par Windows XP. Pour visualiser vos images sous Windows, vous pouvez installer de petit utilitaire IrfanView téléchargeable ici.

Si vous utilisez Linux les images devraient être reconnues automatiquement.

La petite bibliothèque images.py permet de créer, ouvrir, modifier et sauver des images simples aux format "PBM", "PGM" ou "PPM". Vous devez télécharger le fichier images.py et le mettre dans le même répertoire que votre propre fichier.

Voici par exemple un morceau de programme Python qui déclare une image, dessine un point gris au milieu et sauve l'image dans "test.pgm": 

from images import *

image = Image("PGM", 7, 11)
image.change_pixel(image.largeur//2, image.hauteur//2, 127)
image.sauve("test")

Voici, avec des détails, ce qu'il se passe :

  1. image = Image("PGM",7,11) : on initialise une image image. Les 3 arguments obligatoires sont :
    • le type d'image : "PBM" (noir et blanc), "PGM" (niveaux de gris) ou "PPM" (couleurs),
    • les dimensions largeur (ici, 7) et hauteur (ici, 11),
    On peut également donner un troisième argument pour la couleur de fond de l'image. (blanc par défaut)

  2. image.change_pixel(x, y, couleur) est une méthode associée à chaque image. Elle permet de changer la couleur d'un pixel. Ici, la couleur est 127, c'est à dire gris. En général, la couleur doit être :
    • 0 (blanc) ou 1 (noir) pour une image PBM (noir et blanc),
    • un entier entre 0 (noir) et 255 (blanc) pour une image PGM (niveaux de gris),
    • un triplet d'entiers entre 0 et 256 pour une image PPM (couleurs). Chaque entier représente une composante : rouge, vert et bleu.

  3. image.largeur permet de récupérer la largeur de l'image lorsque l'on ne l'a pas créée nous même. Dans notre cas, image.largeur donne simplement 7. image.hauteur est la hauteur de l'image...

  4. image.sauve(nom) est une autre méthode associée aux images. Cette méthode permet de sauvegarder l'image dans un fichier. Attention :
    • nom doit être une chaîne de caractères,
    • l'extension du fichier est ajoutée automatiquement : dans ce cas, le nom du fichier sera test.pgm.

Remarques : vous pouvez obtenir un petit message d'aide pour chaque fonction avec "help(nom_de_la_fonction)".

2. Rectangles et dégradés

  1. Téléchargez le fichier squelette, changer le nom du fichier et modifiez la valeur de la variable nom tout en haut du fichier...

  2. N'oubliez pas de télécharger également la petite bibliothèque images.py que vous devrez sauvegarder dans le même répertoire que votre fichier tp1-___.py.

  3. Pour ce TP, vous devez écrire des fonctions, et les tests sont fait automatiquement par la fonction tp1(). Autrement dit, à chaque modification, vous devrez sauvez votre fichier et le charger dans Idle (avec la touche F5 par exemple), et lancer la fonction tp1() : 

    >>> tp1()
    Cette fonction appelera les fonctions demandées pour le TP, et créera des fichiers images que vous pourrez visualiser pour vérifier que vos fonctions sont correctes. (Vous pouvez également modifier les tests dans la fonction tp1 si vous le souhaiter...)

2.1. Rectangles et carrés

Écrivez le corps de la procédure suivante : 

def rectangle(image, x0, y0, largeur, hauteur, couleur):
    """Dessine un rectangle plein dans l'image "image".
Les arguments "x0" et "y0" désignent le point en haut à gauche du rectangle,
l'argument "largeur" sa largeur, l'argument "hauteur" sa hauteur et l'argument
"couleur" sa couleur.
Attention, si le rectangle ne tient pas dans "image", il ne faudra dessiner
qu'un bout du rectangle..."""

Attention : cette procédure modifie une image existante qui lui est passé en paramètre. La procédure rectangle ne crée pas une nouvelle image et n'utilise donc ni la fonction "Image(...)" ni la méthode "save". C'est la procédure de test qui le fait...

Vérifiez que votre fonction fait ce qu'il faut en :

2.2. Dégradés

Le but est maintenant de dessiner un rectangle contenant un dégradé vertical.

Le cas le plus simple est un rectangle dégradé en gris qui va du noir au blanc avec une ligne pour chage niveau de gris : la ligne i du rectangle à le niveau de gris i. Dans ce cas, le rectangle a une hauteur de 256 pixels.

Lorsque le rectangle est moins haut, il faut « sauter des lignes ». Par exemple, pour un rectangle de hauteur 128, la ligne i aura le niveau de gris 2 * i.

Lorsque le rectangle est plus haut que 256, il faut répéter des lignes. Par exemple, dans le cas d'une hauteur de 512, la ligne i du rectangle à la couleur i // 2.

Lorsqu'on doit créer un dégradé entre deux couleurs arbitraire, il y a plusieurs difficultés supplémentaires :

Écrivez la procédure : 

def rectangle_degrade(image, x0, y0, largeur, hauteur, couleur_haut, couleur_bas):
    """Dessine un rectangle dans l'image "image" qui est forcément au format
"PPM" (couleurs RGB).
Les coordonnées du point haut/gauche du rectangle sont "x0" et "y0" ; et ses
dimensions sont "largeur" et "hauteur".
Le rectangle contient un dégradé de couleurs : de "couleur_haut" en haut du
rectangle, jusqu'à "couleur_bas" en bas du rectangle.
"""

Consignes : expliquez (en commentaires) comment vous faites pour calculer la couleur d'un point du rectangle.

Voici un exemple de résultat : 

im = Image("PPM", 100,100, (0,0,0))
rectangle_degrade(im, 25,30, 45, 70, (0,200,0), (0,20,127))
im.sauve("test-degrade")

3. Disques et cercles

Réfléchissez à une méthode pour dessiner un disque plein sur une image. Programmez ensuite la procédure : 

def disque(image, x0, y0, rayon, couleur):
    """Dessine un disque dans l'image "image".
Les arguments "x0" et "y0" désignent le centre, l'argument "rayon" le rayon
et "couleur" sa couleur."""

Rappel : le disque de centre (x0,y0) et de rayon r est constitué de l'ensemble des points de coordonnées (x,y) qui vérifient (x-x0)2 + (y-y0)2 ≤ r2.

Essayez maintenant de dessiner un cercle sur une image : 

def cercle(image, x0, y0, rayon, couleur):
    """Dessine un disque dans l'image "image".
Les arguments "x0" et "y0" désignent le centre, l'argument "rayon" le rayon
et "couleur" sa couleur."""

Rappel : le disque de centre (x0,y0) et de rayon r est constitué de l'ensemble des points de coordonnées (x,y) qui vérifient (x-x0)2 + (y-y0)2 = r2.

Testez votre fonction et commentez ce que vous voyez et essayer de corriger.

4. Segments (difficile)

Programmez la procédure 

def segment(image, x1, y1, x2, y2, couleur):
    """Dessine un segment dans l'image "image".
Les arguments "x1", "y1" et "x2","y2" désignent les coordonnées des extrémités du segment."""

Par exemple : 

>>> im = Image("PBM", 50, 50, 1)
>>> segment(im, 0,0 , 49,13 , 0)
>>> im.sauve("test-segment")

donne :

5. Art moderne ??

En utilisant le module random, écrivez une procédure art_moderne qui génère une image aléatoire contenant des disques et des rectangles. Choisissez des arguments pertinents pour pouvoir choisir les paramètres de votre image finale.

Voici un exemple de ce que vous pourriez obtenir :

Attention : cette procédure doit créer une nouvelle image. Elle doit donc faire un "im = Image(...)" et un "im.save(...)".