Annexe B - Le module Camlgraph▲
Présentation▲
Le module Camlgraph est une adaptation du module graphics livré avec toutes les distributions de Objective Caml. Il reprend les mêmes fonctions avec les mêmes noms. La seule différence réside dans le fait que toutes les fonctions y sont décurryfiées.
Ce module permet de dessiner des points, des segments, des polygones, des cercles et de remplir certaines zones dans une fenêtre graphique. Cette fenêtre graphique peut être considérée comme un tableau de points repérés par leurs coordonnées (cf figure B.1). Ces coordonnées sont des nombres entiers. Seuls les points dont les deux coordonnées sont positives ou nulles et inférieures à la largeur et à la hauteur de la fenêtre sont visibles.
Le programme ci-dessous illustre une utilisation de ce module. Son exécution produit l'image présentée sur la figure B.2.
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.
(* auteur : EW *)
(* date : mai 2009 *)
(* objet : dessin de cercles *)
(* concentriques de *)
(* couleurs aléatoires *)
(* utilise le module Camlgraph *)
open Camlgraph ;;
let largeur = 600 (* largeur de la fenêtre graphique *)
and hauteur = 400 (* hauteur de la fenêtre graphique *) ;;
let n = (hauteur - 20) / 2 (* le nombre de cercles a dessiner *)
and cx = largeur / 2 (* abscisse du centre des cercles *)
and cy = hauteur / 2 (* ordonnée du centre des cercles *);;
begin
Random.init (int_of_float (Unix.time()));
open_graph (" "^string_of_int(largeur)^"x"^string_of_int(hauteur)) ;
set_window_title ("Cercles") ;
for i = 1 to n do
set_color (rgb(Random.int(256),Random.int(256),Random.int(256)));
draw_circle (cx,cy,i)
done;
print_endline "appuyez sur une touche pour terminer";
ignore(read_key ()) ;
close_graph ()
end
Module Camlgraph▲
Auteur(s) : FIL
Gestion des fenêtres graphiques▲
val open_graph : string -> unit
open_graph(s) ouvre une fenêtre graphique dont les dimensions sont indiquées par la chaîne s Pour une ouverture de la fenêtre sur l'écran par défaut, la chaîne doit commencer par un espace.
val close_graph : unit -> unit
close_graph() ferme de la fenêtre graphique.
val set_window_title : string -> unit
set_window_title(s) donne un titre à la fenêtre graphique.
val resize_window : int * int -> unit
- resize_window (w,h) redimensionne la fenêtre graphique w = largeur, h = hauteur.
val clear_graph : unit -> unit
clear_graph() efface le contenu de la fenêtre graphique.
val size_x : unit -> int
size_x() donne la largeur de la fenêtre graphique.
val size_y : unit -> int
size_y() donne la hauteur de la fenêtre graphique.
Gestion des couleurs▲
type color = Graphics.color
- représentation des couleurs.
val rgb : int * int * int -> color
rgb(r,g,b) donne une couleur à partir de ses trois composantes rouge, vert, bleu.
val set_color : color -> unit
set_color(x) fixe la couleur courante.
val background : color
- couleur courante de l'arrière plan.
val foreground : color
- couleur courante de l'avant plan.
Couleurs prédéfinies
2.
3.
4.
5.
6.
7.
8.
val black : color
val white : color
val red : color
val green : color
val blue : color
val yellow : color
val cyan : color
val magenta : color
Point et dessin de lignes▲
val plot : int * int -> unit
plot(x,y) dessine un point de coordonnées (x,y).
val point_color : int * int -> color
point_color(x,y) donne la couleur du point de coordonnées (x,y).
val moveto : int * int -> unit
moveto(x,y) positionne le crayon au point de coordonnées (x,y).
val rmoveto : int * int -> unit
rmoveto(x,y) translate le crayon selon le vecteur de coordonnées (x,y).
val current_x : unit -> int
current_x() donne l'abscisse de la position courante du crayon.
val current_y : unit -> int
current_y() donne l'ordonnée de la position courante du crayon.
val current_point : unit -> int * int
current_point() donne les coordonnées de la position courante du crayon.
val lineto : int * int -> unit
lineto(x,y) trace un segment depuis la position courante jusqu'au point de coordonnées (x,y).
val rlineto : int * int -> unit
rlineto(x,y) trace un segment depuis la position courante selon le vecteur de coordonnées (x,y).
val curveto : (int * int) * (int * int) * (int * int) -> unit
curveto(b,c,d) trace une courbe de Bézier du point courant jusqu'au point d avec les points b et c pour points de contrôle.
val draw_rect : int * int * int * int -> unit
draw_rect(x1,y1,x2,y2) dessine un rectangle dont le coin inférieur gauche a pour coordonnées (x1,y1) et le point supérieur droit (x2,y2).
val draw_arc : int * int * int * int * int * int -> unit
draw_arc(x,y,rx,ry,a1,a2) dessine un arc d'ellipse de centre (x,y), de rayon horizontal rx, de rayon vertical ry, entre les angles a1 et a2.
val draw_ellipse : int * int * int * int -> unit
draw_ellipse(x,y,rx,ry) dessine une ellipse de centre (x,y), de rayon horizontal rx, de rayon vertical ry.
val draw_circle : int * int * int -> unit
draw_circle(x,y,r) dessine un cercle de centre (x,y), de rayon r.
val set_line_width : int -> unit
set_line_width(n) fixe l'épaisseur des traits.
Texte▲
val draw_char : char -> unit
draw_char(c) dessine le caractère c à la position courante.
val draw_string : string -> unit
draw_string(s) dessine la chaîne de caractères s à la position courante.
val set_font : string -> unit
set_font(s) fixe la police pour dessiner les textes.
val set_text_size : int -> unit
set_text_size(n) fixe la taille des caractères pour dessiner les textes.
val text_size : string -> int * int
text_size(s) donne les dimensions du texte s s'il était dessiné avec les polices et tailles courantes.
Remplissage▲
val fill_rect : int * int * int * int -> unit
fill_rect(x,y,w,h) remplit le rectangle dont le coin inférieur gauche a pour coordonnées (x,y), de largeur w et de hauteur w, avec la couleur courante.
val fill_arc : int * int * int * int * int * int -> unit
fill_arc(x,y,rx,ry,a1,a2) remplit l'arc d'ellipse dont le centre a pour coordonnées (x,y), de rayon horizontal rx et de rayon vertical ry, entre les angles a1 et a2, avec la couleur courante.
val fill_ellipse : int * int * int * int -> unit
fill_ellipse(x,y,rx,ry) remplit l'ellipse dont le centre a pour coordonnées (x,y), de rayon horizontal rx et de rayon vertical ry, avec la couleur courante.
val fill_circle : int * int * int -> unit
fill_circle(x,y,r) remplit le cercle dont le centre a pour coordonnées (x,y), de rayon r, avec la couleur courante.
