Exercice langage C: Polygones

Dans cet exercice, vous allez écrire un programme vous permettant de caractériser et de représenter graphiquement un polygone.

  1. Un point dans le plan est défini simplement par ses coordonées x et y. Déclarez une structure Point contenant deux entiers, afin de représenter un point et ses deux coordonnées.
  2. En informatique, une couleur se définit en général par les trois niveaux de rouge, vert et bleu qui la compose. Le niveau de chaque couleur fondamentale est représenté par un réel entre 0 et 1. Par exemple, la couleur blanche vaut (1,1,1), rouge (1,0,0). Écrivez une structure Couleur permettant de représenter une couleur.
  3. Déclarez finalement une structure Polygone. Un polygone peut être représenté par un ensemble de points et une couleur (vous vous servirez des structures Point et Couleur, définies plus haut). Un champ ferme servira à indiquer si le polygone est fermé ou s'il s'agit d'une ligne polygonale (ouvert).
  4. Implémentez une fonction affiche_polygone, dont le but sera d'afficher un polygone dans une fenêtre graphique. Pour cela, vous utiliserez la libraire swindow dont vous vous êtes déjà servi lors de la leçon 10. La fonction prendra un pointeur sur SimpleWindow ainsi qu'un pointeur sur Polygone:
    void affiche_polygone(SimpleWindow * window, Polygone * polygone)
    

    Comme ici window est un pointeur, il faudra utiliser l'opérateur -> plutôt que . pour accéder aux champs et fonctions de window. Par exemple, window->draw_line(...). On rappelle queSimpleWindow est une classe C++, et les classes sont une extension des structures. Comme pour les structures, on utilise donc -> sur un pointeur au lieu du point (.).

  5. Déclarez un Polygone nommé losange dans main et remplissez ses champs, de manière à ce qu'il représente correctement un losange. Initialisez ensuite une nouvelle fenêtre. Vous pouvez utiliser le code suivant à cet usage:
      SimpleWindow window("Polygone", 300, 300);
      window.map();
      window.color(1, 1, 1);
      window.fill();
    

    Dessinez ensuite le losange dans la fenêtre à l'aide de la commande affiche_polygone et faites afficher la fenêtre. Ajoutez le code suivant à la fin de votre programme

      cout << "Appuyez sur une touche pour continuer..." << endl;
      char a = getchar();
    

    afin que le programme ne se termine pas tout de suite et que vous ayez le temps d'admirer votre losange.


 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
#include 
#include "swindow.h"

using namespace std;

struct point {
  int x, y;
};

struct couleur {
  float rouge, vert, bleu;
};

struct polygone {
  point *points;
  int nbr_points;

  couleur coul;
  bool ferme;
};

void affiche_polygone(SimpleWindow *w, polygone *p) {
  w->color(p->coul.rouge, p->coul.vert, p->coul.bleu);

  for (int i=0; i<p->nbr_points-1; i++)
    w->drawLine(p->points[i].x, p->points[i].y, p->points[i+1].x,
		p->points[i+1].y);
  if (p->ferme)
    w->drawLine(p->points[p->nbr_points-1].x, p->points[p->nbr_points-1].y,
		p->points[0].x, p->points[0].y);
}

int main(int argc, char **argv) {
  polygone losange;

  losange.coul.rouge = 1;
  losange.coul.vert = 0;
  losange.coul.bleu = 0;

  losange.ferme = true;

  losange.nbr_points = 4;
  losange.points = new point[4];

  losange.points[0].x = 10;
  losange.points[0].y = 60;
  losange.points[1].x = 100;
  losange.points[1].y = 10;
  losange.points[2].x = 190;
  losange.points[2].y = 60;
  losange.points[3].x = 100;
  losange.points[3].y = 110;

  SimpleWindow window("Polygone", 300, 300);
  window.map();
  window.color(1, 1, 1);
  window.fill();

  affiche_polygone(&window, &losange);

  window.show();

  cout << "Appuyez sur une touche pour continuer..." << endl;
  char a = getchar();

  delete[] losange.points;

  return 0;
}