Sommaire

Introduction
Le pixel
La ligne
Le cercle

Introduction

Pour vous faciliter l'essais des instructions graphiques, nous utiliserons le QBasic. Il présente l'avantage d'avoir un interpréteur (pas la peine de compiler) et d'être facilement compréhensible même pour les débutants, mais vous pouvez biensûr traduire les procédures dans le langage de votre choix. Le Qbasic possède de nombreuses instructions graphiques pour dessiner points, droites et cercles. Nous ne nous en servirons pas car nous allons redécouvrir comment ce programme ces instructions graphiques... en se servant du mode texte !

Pour reproduire les dessins des courbes, on utilisera la géométrie analytique. La difficulté tiendra dans le fait que les courbes, du plan qui est un ensemble infini se retrouveront représentés dans un ensemble finis de taille 40 × 20. Il y aura donc une perte de la précision et on devra arranger notre programme pour obtenir les meilleurs courbes.

Le fait de savoir calculer les coordonnées des courbes nous sera utile pour d'autres choses que de dessiner à l'écran. En appelant une procédure pour chaque coordonnées de la courbe, le programmeur pourra tracer lignes ou cercles multicolores, faire qu'un objet ait pour trajectoire la courbe...

Le pixel

Le pixel est l'élément de base de nos instructions, il va permettre de faire un « point ». Voici la procédure QBASIC :

SUB AffPixel (x, y)
  IF (x < 0 OR x > 39 OR y < 0 OR y > 19) THEN EXIT SUB
  LOCATE 1 + y, 1 + x * 2: COLOR 15: PRINT CHR$(219) + CHR$(219)
END SUB

La première ligne vérifie que le pixel n'est pas en dehors de l'écran. On ne peut donc que rentrer des coordonnées de 0 à 39 pour l'abscisse et de 0 à 19 pour l'ordonnée (rappel : la taille decidée est 40 × 20).
La deuxième ligne affiche 2 caractères pleins pour former un carré blanc.

On appelle la procédure : CALL AffPixel(19, 10) et on obtient un carré blanc à peu près au centre de l'écran : on a crée notre instruction graphique qui affiche un pixel.

Remarque : on pourrait imaginer d'autres instructions tel que EffPixel(x,y) qui effacerait un pixel, ChgPixel(x,y) qui changerait le pixel en l'affichant ou l'effaçant selon que le pixel est affiché ou non. Une fonction interessante serait ValPixel(x,y) qui retournerait 1 si le pixel est affiché et 0 dans le cas contraitre.

La ligne

L'équation d'une droite est $A x + B y + C = 0$ . Pour tracer la ligne, on envoie deux coordonnées à la procédure soient $(x_{1}, y_{1})$ et $(x_{2}, y_{2})$ .

Puisqu'ils appartiennent à la droite, on a $A x_{1} + B y_{1} + C = 0$ et $A x_{2} + B y_{2} + C = 0$ . D'où $A (x_{1} - x_{2}) + B (y_{1} - y_{2}) = 0$ . On a alors trois cas possible :

$x_{1}$ n'est pas égale à $x_{2}$
On déduit de la dernière égalité $A = - B \frac{(y_{1} - y_{2})}{(x_{1} - x_{2})}$ . On exclut le cas $B = 0$ car alors on aurait $A = B = 0$ et l'équation serait celle d'un plan ou du vide. En reportant dans l'équation de la droite, on obtient alors :
$- B \frac{(y_{1} - y_{2})}{(x_{1} - x_{2})} x + B y + C = 0$ et $y = \frac{(y_{1} - y_{2})}{(x_{1} - x_{2})} x - \frac{C}{B}$

Pour tracer notre « segment », on va donc représenter graphiquement la fonction affine de la forme $f (x) = a x + b$ sur « l'intervalle » $[x_{1}; x_{2}]$ (ou $[x_{2}; x_{1}]$ selon l'ordre de $x_{1}$ et $x_{2}$ ). Pour cela, on fait une boucle où $x$ prend les valeurs entières de $x_{1}$ à $x_{2}$ (ou de $x_{2}$ à $x_{1}$ selon l'ordre de $x_{1}$ et $x_{2}$ ).
Le coefficient directeur est donc $a = \frac{(y_{1} - y_{2})}{(x_{1} - x_{2})}$ et l'ordonnée à l'origine se calcule à l'aide d'une des coordonnées envoyées : $b = y_{1} - a x_{1}$ par exemple.
$x_{1} = x_{2}$ et $y_{1}$ n'est pas égale à $y_{2}$
Puisque $x_{1} = x_{2}$ , $A (x_{1} - x_{2}) + B (y_{1} - y_{2}) = 0$ devient $B (y_{1} - y_{2}) = 0$ , ce qui implique que B est nul (puisque $y_{1} - y_{2}$ n'est pas nul). Donc l'équation de la droite devient $Ax + C = 0$ c'est-à-dire $x = - \frac{C}{A}$ (on exclut le cas $A \neq 0$ qui ne correspond pas à une droite). Pour tracer notre « segment », on va faire une boucle qui affiche les pixels de coordonnés $(x; y)$ avec $x = - \frac{C}{A}$ et $y$ prendra les valeurs entières de $y_{1}$ à $y_{2}$ (ou de $y_{2}$ à $y_{1}$ selon l'ordre de $y_{1}$ et $y_{2}$ ).
Si $x_{1} = x_{2}$ et $y_{1} = y_{2}$ , c'est à dire si les points sont confondus.
Il y a alors une infinité de droites possibles. Pour notre programme, on ne décidera donc de ne pas tracer un segment mais juste un « point » : CALL AffPixel(x1, y1).

Voila pour le coté théorique, maintenant, vérifions par la pratique :

SUB Ligne (x1, y1, x2, y2)

IF x1 = x2 AND y1 = y2 THEN CALL AffPixel(x1, y1): EXIT SUB
IF (x1 = x2) THEN
  FOR y = y1 TO y2 STEP SGN(y2 - y1)
  CALL AffPixel(x1, y)
  NEXT y
ELSE
  a = (y1 - y2) / (x1 - x2): b = y1 - x1 * a
  FOR x = x1 TO x2 STEP SGN(x2 - x1)
  CALL AffPixel(x, a * x + b)
  NEXT x
   END IF

END SUB

Et voici ce que l'on obtient (on ne s'intéresse qu'aux fonctions affines car les autres cas ne posent pas de problèmes) :

Lorsque l'on observe les résultats, on voit que même si les fonctions affines sont bijectives, lorsque l'on fait leur représentation à l'écran, ce n'est pas toujours le cas à cause des arrondis.

1^er cas : application injective.
2^ème cas : application bijective.
3^ème cas : application surjective.

Cela a pour conséquence que l'on a des « trous » lorsque l'application est injective. Pour résoudre ce problème, on va s'arranger pour n'obtenir que des applications surjectives.

$∣ x_{1} - x_{2} ∣ > ∣ y_{1} - y_{2} ∣$ avec des points non confondus.
$y = \frac{(y_{1} - y_{2})}{(x_{1} - x_{2})} x - \frac{C}{B}$
On fait la représentation de $y = a x + b$ avec $a = \frac{(y_{1} - y_{2})}{(x_{1} - x_{2})}$ et $b = y_{1} - a x_{1}$ .
$∣ y_{1} - y_{2} ∣ \geq ∣ x_{1} - x_{2} ∣$ avec des points non confondus.
$x = \frac{(x_{1} - x_{2})}{(y_{1} - y_{2})} y - \frac{C}{A}$
On fait la représentation de $x = a y + b$ avec $a = \frac{(x_{1} - x_{2})}{(y_{1} - y_{2})}$ et $b = x_{1} - a y_{1}$ .
Si $x_{1} = x_{2}$ et $y_{1} = y_{2}$ , c'est à dire si les points sont confondus.
On fait CALL AffPixel(x1, y1).

Voici donc finalement la fonction Ligne avec les corrections :

SUB Ligne (x1, y1, x2, y2)

IF x1 = x2 AND y1 = y2 THEN CALL AffPixel(x1, y1): EXIT SUB

  IF ABS(x1 - x2) > ABS(y1 - y2) THEN
    a = (y1 - y2) / (x1 - x2): b = y1 - x1 * a
    FOR x = x1 TO x2 STEP SGN(x2 - x1)
    CALL AffPixel(x, a * x + b)
    NEXT x
  ELSE
    a = (x1 - x2) / (y1 - y2): b = x1 - y1 * a
    FOR y = y1 TO y2 STEP SGN(y2 - y1)
    CALL AffPixel(a * y + b, y)
    NEXT y
  END IF

END SUB

Le cercle

L'équation du cercle de centre $(a; b)$ et de rayon $r$ est ${(x - a)}^{2} + {(y - b)}^{2} - r^{2} = 0$ . Pour simplifier, on considerera le centre du cercle comme l'origine du repère. L'égalité devient alors $x^{2} + y^{2} - r^{2} = 0$ . On a donc $y = \pm \sqrt{r^{2} - x^{2}}$ . On va biensûr travailler sur « l'intervalle » $[- r, + r]$ . Pour éviter les « trous » on peut maintenant relier les points entre eux grâce à l'instruction Ligne. D'où la procédure suivante :

SUB Cercle (a, b, r)
  FOR x = -r + 1 TO r
    CALL Ligne(a + x - 1, b + H(x - 1, r), a + x, b + H(x, r))
    CALL Ligne(a + x - 1, b - H(x - 1, r), a + x, b - H(x, r))
  NEXT x
END SUB

FUNCTION H (x, r)
  H = SQR(r ^ 2 - x ^ 2)
END FUNCTION

Lorsque l'on appelle la procédure (CALL Cercle(15,10,9)) on obtient ceci :
Résultat de la procédure Cercle

Cette page est conforme aux normes du W3C - Auteur : Frédéric WANG - Dernière mise à jour : mardi 17 juin 2003