IN Représentation et codage - TD 3 - IUT d'Arles

IUT de Provence, site d’Arles 2010-2011
Département Informatique
LP SIL IN
Imagerie Numérique
Représentation et codage
TD 1 bis
On souhaite ajouter à la classe Image la possibilité de tracer des lignes. On écrira tout
d’abord une fonction utilisant l’équation cartésienne d’une droite. On écrira ensuite une
fonction plus rapide basée sur l’algorithme mis au point par Bresenham.
1. Utilisation de l’équation cartésienne d’une droite
Principe de l’algorithme
On souhaite tracer une droite entre les points de coordonnées (x1,y1) et (x2,y2).
On utilise l’équation cartésienne de la droite : y = a.x + b
y2
− y1
Avec : a = et b = y1 − a.x1
x − x
Question
2
1
1 Ajoutez à la classe Image une méthode ligneCartesienne() de prototype :
void ligneCartesienne( int x1, int y1,
int x2, int y2,
Pixel couleur )
Cette méthode permettra de tracer une ligne grâce à l’équation cartésienne, entre les
points de coordonnées (x1,y1) et (x2,y2) avec la couleur de type Pixel passée en
paramètre.
Remarque
En pratique, une telle fonction s’avère « trop lente » à cause de l’utilisation de réels, d’une
division et de plusieurs multiplications qui sont des opérations coûteuses en temps de calcul
(en particulier, on a une multiplication pour chaque pixel affiché).
Afin de tracer des lignes, on utilise généralement l’algorithme mis au point par Bresenham,
qui est plus rapide car il n’utilise que des entiers et ne fait pas intervenir de division ou de
multiplication pour l’affichage de chaque pixel, mais simplement des additions.
1

2. Utilisation de l’algorithme de Bresenham
Principe de l’algorithme de Bresenham
Pour représenter une ligne sur un écran composé de pixels, il faut allumer les pixels dont le
« centre » passe le plus près possible de la ligne idéale :
B
A
La droite (AB) est la droite idéale. Le problème est de savoir quels pixels allumer pour
s'approcher le plus possible de la droite idéale.
Le principe de l’algorithme de Bresenham est de calculer la distance verticale entre le pixel et
la droite idéale et d'allumer le pixel pour lequel l'erreur est inférieure à 0.5. Par exemple,
considérons la droite d'équation y=ax+b avec a=1/3 :
y2
y1
1 - 0.66
0.33
0.66
x1
x2
Pour le premier pixel, bien entendu, il n'y a aucune erreur, mais pour le deuxième, l'erreur est
égale à 0.33 (a) et au troisième, l'erreur est 0.66, ce qui est supérieur à 0.5, donc on allume le
pixel au-dessus. À chaque pixel, l'erreur augmente de a et lorsqu'elle est supérieure à 0.5, on
allume le pixel du dessus, et l'erreur devient minorée de 1.
On se place dans le cas où on trace une ligne dont la distance sur x est plus grande que celle
sur y et où x1

Il faut donc allumer des pixels entre x1 et x2, en commençant à la ligne y=y1. Il faut tout
d’abord calculer la pente a de la droite, puis utiliser une variable erreur qu’on initialise à 0.
Après chaque pixel allumé, on ajoute a à erreur. Si erreur dépasse 0.5, on fait erreur=erreur-
1 et on incrémente y de 1.
Questions
1 Ajoutez à la classe Image une méthode ligneBresenham(), de prototype :
void ligneBresenham( int x1, int y1,
int x2, int y2,
Pixel couleur )
Cette méthode permettra de tracer une ligne grâce à l’algorithme de Bresenham entre
les points de coordonnées (x1,y1) et (x2,y2) avec la couleur de type Pixel passée en
paramètre.
2 Ajoutez à la classe Image une méthode ligneBresenhamOptimisee(), de
prototype :
void ligneBresenhamOptimisee( int x1, int y1,
int x2, int y2,
Pixel couleur )
Cette méthode permettra de tracer une ligne de manière plus optimisée, en n’utilisant
que des variables entières et pas de flottant.
3 Etendre la méthode de la question 2 de manière à pouvoir tracer une ligne dans
n’importe quelle configuration de position de ses deux extrémités (dans n’importe
lequel des « 8 octants »).
Remarque
Pour comparer la rapidité des différentes méthodes de tracé de ligne, vous pourrez les
chronométrer grâce à la fonction clock() en affichant dans une boucle un nombre très élevé de
lignes (par exemple 100000).
3