I. Les fonctions initiales de manipulation 2
1.Créer 2
2.Sélectionner 2
3.Détruire 2
4.Paramétrer 2
II.Les fonctions de base 3
1.Ouvrir 3
2.Colorier 3
3.Effacer 4
4.Définir des coordonnées 4
5.Fermer 4
III.Les fonctions de dessin 4
1.Déplacer le curseur graphique 5
2.Dessiner des arcs de cercle 5
3.Dessiner des rectangles 5
4.Dessiner des cercles 5
5.Dessiner des segments 5
6.Dessiner des ellipses 5
7.Tracer des points 6
8.Ecrire un label 6
IV.Les fonctions attributs 6
1.Définir la police dâacirc;€™écriture 7
2.Définir le type des traits utilisés 7
3.Définir les couleurs utilisées 7
V.Le programme de base 8
VI.Les librairies nécessaires 10
VII.Les commandes 10
Les quatre fonctions initiales de manipulation consistent en la création, la sélection puis la destruction du plotter et la fonction de paramétrage : newpl, selectpl, deletepl et parampl
int newpl (const char *type, FILE *in, FILE *out, FILE *err);
Elle crée un plotter dâacirc;€™un type spécifié. Son premier argument type peut être "X", "Xdrawable", "ai", "ps", "fig", "pcl", "hpgl", "tek", or "meta". Le plotter aura un flux de données entrant in, un flux de données sortant out, un flux dâacirc;€™erreur err. Le plus souvent les plotters sont « write only » et le flux entrant est ignoré. X Plotters and X Drawable Plotters trace des graphiques dans une fenêtre X Window plutôt que dans un output stream. Ainsi, si type est "X" ou "Xdrawable" alors out est ignoré. Les éventuels messages dâacirc;€™erreur sont transcrits dans le fichier err, sauf si err est NULL.
La fonction newpl renvoie un entier positif `handle', qui sert à désigner le plotter créé. Une valeur négative indique que le plotter nâacirc;€™a pas pu être créé.
int selectpl (int handle);
Avant dâacirc;€™utiliser un plotter ( avant dâacirc;€™invoquer une opération ) il faut le sélectionner. Selectpl sélectionne le potter désigné par son âacirc;€˜handleâacirc;€™.
Seul un plotter peut être sélectionné à la fois, mais en appelant selectpl, il est possible de passer dâacirc;€™un plotter à un autre.
Si selectpl renvoie un entier négatif, le plotter nâacirc;€™a pas pu être sélectionné.
int deletepl (int handle);
deletepl détruit un plotter, référencé par son handle. Le plotter ne doit pas être sélectionné au moment où il est détruit. Au démarrage, un plotter de type « meta » est automatiquement créé, il est caractérisé par handle =0. Câacirc;€™est ce plotter qui est sélectionné lorsque lâacirc;€™on souhaite détruire notre plotter.
Une valeur négative indique que le plotter nâacirc;€™a pas pu être détruit.
int parampl (const char *parameter, void *value);
il est utile de pouvoir spécifier certains aspects du comportement des plotters au moment où ils sont créés. parampl fixe la valeur du paramètre parameter à value, des plotters créés.
La fonction parampl est appelée autant de fois que nécessaire pour définir les différents paramètres souhaités. Tous les plotters créés après la fonction parampl possèdent les caractéristiques définies par parampl. Un paramètre est desactivé grâce à value NULL.
Les paramètres non définis avec parampl lors de la création de plotter sont fixés à leur valeur par défaut.
Voici les plus importants paramètres :
DISPLAY
(par défaut NULL.) DISPLAY définit le système X Window sur lequel le graphique va sâacirc;€™afficher, comme par exemple âacirc;€˜X windowâacirc;€™. Ce paramètre nâacirc;€™est pris en compte que pour les plotters de type X Windows.
BITMAPSIZE
(fixé par défaut à "570x570".) BITMAPSIZE permet de définir la taille en pixels du graphique. Ce paramètre est uniquement pris en compte pour les plotters de type X Windows.
PAGESIZE
(fixé par défaut à "letter".) PAGESIZE permet de spécifier la taille de la page sur laquelle le graphique va être positionné. Ce paramètre sert uniquement pour les plotters de type Illustrator, Postscript, Fig, PCL, and HP-GL Plotters.
Nâacirc;€™importe quelle taille de page du type "a0"..."a4" peut être donné.
BG_COLOR
(par défaut "white") BG_COLOR permet de définir la couleur de fond initiale du plotter. Ce paramètre nâacirc;€™est pris en compte que pour les plotters de types X Windows. Cette couleur de fond peut être modifiée à nâacirc;€™importe quel moment en invoquant la fonction bgcolor (ou bgcolorname) après la fonction erase.
Les fonctions de base permettent dâacirc;€™ouvrir, dâacirc;€™initialiser ou de fermer un plotter qui vient dâacirc;€™être créé.
Voici les principales, dans lâacirc;€™ordre où elles peuvent être appelées dans un programme.
int openpl ();
La fonction openpl ouvre un plotter. Elle renvoie une valeur négative lorsque le plotter nâacirc;€™a pas pu être ouvert.
Les fonctions bgcolor et bgcolorname permettent de spécifier la couleur de fond du plotter.
int bgcolor (int red, int green, int blue);
La fonction bgcolor utilise le système RGB.
Les arguments red, green, et blue définissent lâacirc;€™intensité des différentes couleurs primaires à utiliser pour créer la couleur de fond. Chaque argument est un entier pris dans lâacirc;€™intervalle 0x0000âacirc;€¦0xffff (câacirc;€™est à dire 0âacirc;€¦.65535). Le choix (0,0,0) correspond à une couleur de fond noire et le choix (65535, 65535, 65535) à du blanc.
int bgcolorname (const char *name);
La fonction bgcolorname fixe la couleur de fond du plotter selon lâacirc;€™argument name.
ATTENTION :
Les effets de ces deux fonctions ne sont pas immédiat. La nouvelle couleur de fond du plotter nâacirc;€™est effective quâacirc;€™après avoir appelé la fonction erase.
int erase ();
La fonction erase efface tous les objets affichés dans le plotter et affiche la couleur de fond (si elle a été spécifiée avec une des fonctions bgcolor ou bgcolorname).
int space (int x0, int y0, int x1, int y1);
int fspace (double x0, double y0, double x1, double y1);
les fonctions space and fspace permettent de relier les coordonnées utilisateur avec celles du plotter. Elles ont pour argument les coordonnées (x0,y0) du coin inférieur gauche et (x1,y1) du coin supérieur droit du plotter.
ATTENTION :
Il est nécessaire dâacirc;€™appeler une des deux fonctions space ou fspace au début de chaque page graphique, câacirc;€™est à dire tout de suite après la fonction oenpl.
int closepl ();
La fonction closepl ferme un plotter. Elle renvoie une valeur négative lorsque le plotter nâacirc;€™a pas pu être fermé.
Voici les principales fonctions suivantes permettant de dessiner des objets.
int move (int x, int y);
int fmove (double x, double y);
Les fonctions move et fmove permettent de placer le curseur en un point de coordonnées (x, y).
int arc (int xc, int yc, int x0, int y0, int x1, int y1);
int farc (double xc, double yc, double x0, double y0, double x1, double y1);
Les fonctions arc et farc permettent de dessiner un arc de cercle définit par les coordonnées du point de départ (x0,y0), du point dâacirc;€™arrivée (x1,y1) et du centre (xc,yc).
int box (int x1, int y1, int x2, int y2);
int fbox (double x1, double y1, double x2, double y2);
Les fonctions box et fbox permettent de dessiner un rectangle définit par son coin inférieur gauche (x1, y1) et son coin supérieur droit (x2, y2). Lorsque le rectangle est tracé, le curseur se positionne au centre du rectangle.
int circle (int xc, int yc, int r);
int fcircle (double xc, double yc, double r);
Les fonctions circle et fcircle permettent de dessiner des cercles définis par leur centre (xc, yc) et leur rayon (r). Lorsque le cercle est tracé, le curseur se positionne en son centre (xc,yc).
int cont (int x, int y);
int fcont (double x, double y);
Les fonctions cont et fcont permettent de tracer un trait entre la position actuelle du curseur et le point de coordonnées (x, y).
int line (int x1, int y1, int x2, int y2);
int fline (double x1, double y1, double x2, double y2);
Les fonctions line et fline take permettent de tracer un trait entre le point de départ (x1, y1) et le point dâacirc;€™arrivée (x2, y2).
int ellipse (int xc, int yc, int rx, int ry, int angle);
int fellipse (double xc, double yc, double rx, double ry, double angle);
Les fonctions ellipse et fellipse permettent de dessiner des ellipses définies par leur centre (xc, yc), la longueur de leur semi-axes (rx et ry), et lâacirc;€™angle entre lâacirc;€™axe des abscisse et le premier semi-axe. Lorsque lâacirc;€™ellipse est tracée, le curseur se positionne en son centre (xc,yc).
int point (int x, int y);
int fpoint (double x, double y);
Les fonctions point et fpoint permettent de tracer un point aux coordonnées (x, y).
int label (const char *s);
La fonction label a un unique argument argument s. Elle écrit la chaîne de caratère s au niveau du curseur. Le texte est justifié à gauche. Le curseur est ensuite positionné à lâacirc;€™extrémité droite de la chaîne.
int alabel (int horiz_justify, int vert_justify, const char *s);
La fonction alabel permet dâacirc;€™écrire une chaîne de caractère justifiée horizontalement horiz_justify, et verticalement vert_justify .
Si horiz_justify est égal à :`l', `c', or `r', alors la chaîne aura une justification horizontale gauche (left), centrée (center) ou droite (right), relativement à la position du curseur. Si la justification est gauche, le curseur est positionné à lâacirc;€™extrémité droite de la chaîne, si la justification est droite, le curseur est positionné à lâacirc;€™extrémité gauche de la chaîne,
Si vert_justify est égal à `b', `x', `c', or `t', alors la chaîne aura une justification verticale de type bottom, baseline, center ou top.
Elles permettent de définir les attributs des objets précédent.
Voici les principales fonctions attributs.
int colorname (const char *name);
La fonction colorname permet de définir la couleur des traits utilisés pour tracer les objets et leur couleur de remplissage.
int fillcolorname (const char *name);
int fillcolor (int red, int green, int blue);
Les fonctions fillcolor et fillcolorname définissent la couleur de remplissage des objets tracés.
int filltype (int level);
La fonction filltype permet de définir lâacirc;€™intensité du remplissage des objets graphiques. La valeur 0 indique que lâacirc;€™objet est transparent (non-rempli). Câacirc;€™est la valeur par défaut.
Un level dans lâacirc;€™intervalle 0x0001...0xffff, câacirc;€™est à dire entre 1 et 65535, indique que lâacirc;€™objet est rempli. Un level de 1 signifie un remplissage normal par la couleur spécifiée avec les fonctions fillcolor ou fillcolorname. Si le level est 0xffff, la couleur de remplissage est blanc. Un level entre 0x0001 et 0xffff est interprétée comme une désaturation de la couleur spécifiée avec les fonctions fillcolor ou fillcolorname.
int fontname (const char *font_name);
double ffontname (const char *font_name);
Les fonctions fontname et ffontname permettent de définir le nom du font utilisé font_name.
int fontsize (int size);
double ffontsize (double size);
Les fonctions fontsize et ffontsize permettent de définir la taille size des lettres.
int linemod (const char *s);
la fonction linemod définit le style des traits utilisés pour dessiner les différents objets. Les différents style de traits sont les suivants :
"solid" --------------------------------
"dotted" - - - - - - - - - - - - - - - -
"dotdashed" ----------- - ----------- -
"shortdashed" -------- --------
"longdashed" ------------ ------------
int linewidth (int size);
int flinewidth (double size);
Les fonctions linewidth et flinewidth permettent de définir lâacirc;€™épaisseur des traits utilisés pour tracer les différents objets graphiques.
int pencolor (int red, int green, int blue);
int pencolorname (const char *name);
Les fonctions pencolor et pencolorname définissent la couleur utilisée pour tracer les objets graphiques.
#include <stdio.h>
#include <plot.h>
#include <stdlib.h>
/*
***************************************************************************************
declarations of functions defined after main()
*/
int init_plotsession(char *display_type, char *bitmap_size);
int end_plotsession(int handle);
/*******************************************************************************
*
* Attention: debut du programme Main ... :-)
*/
int main ()
{
int handle; /* handle pour repïiuml;¿½er le plotter */
char *bitmap_size="500x500"; /* taille en pixels du plotter */
char *display_type = "X"; /* format du plotter crïiuml;¿½ */
handle=init_plotsession(display_type,bitmap_size);
pl_space (0, 0, 499, 499); /* dïiuml;¿½init les coordonnïiuml;¿½s du systïiuml;¿½e*/
pl_linewidth (2); /* ïiuml;¿½aisseur des traits des objets */
pl_pencolorname ("red"); /* les traits sont tracïiuml;¿½ en rouge */
pl_move (250, 300); /* positionne le curseur */
pl_line (250, 300, 450,400);
pl_box (250, 300, 450, 400);
return end_plotsession(handle);
}
/*******************************************************************************
* functions
*/
int init_plotsession(char *display_type, char *bitmap_size)
/* Initialise libplot et renvoie un entier handle pour le dïiuml;¿½igner plotter crïiuml;¿½. */
{
int handle, return_value;
/* dïiuml;¿½init les parameters d'un plotter */
return_value=pl_parampl("BITMAPSIZE", bitmap_size);
if(return_value<0)
{ fprintf(stderr,"Le plotter n'accepte pas les paramïiuml;¿½res spïiuml;¿½ifiïiuml;¿½.\n");
exit(1);
}
handle=pl_newpl(display_type, NULL, stdout, stderr);
if(handle<0)
{ fprintf(stderr,"Le plotter ne peut pas ïiuml;¿½re crïiuml;¿½.\n");
exit(1);
}
return_value=pl_selectpl(handle);
if(return_value<0)
{ fprintf(stderr,"Le plotter n'existe pas ou ne peut pas ïiuml;¿½re sïiuml;¿½ectionnïiuml;¿½\n");
exit(1);
}
return_value=pl_openpl();
if(return_value<0)
{ fprintf(stderr,"Le plotter sïiuml;¿½ectionnïiuml;¿½ne peut pas ïiuml;¿½re ouvert !\n");
exit(1);
}
return handle;
}
/******************************************************************************/
int end_plotsession(int handle)
/* ferme et dïiuml;¿½ruit le plotter, renvoie 0 si tout c'est bien passïiuml;¿½ */
{
int err_status=0, return_value;
return_value= pl_closepl(); /* ferme la session du plotter */
if(return_value<0)
{ fprintf(stderr,"Le plotter ne peut pas ïiuml;¿½re fermïiuml;¿½\n");
/* no exit, because we try to delete the plotter */
err_status +=1;
}
/* sïiuml;¿½ection du plotter par dïiuml;¿½aut (handle=0) pour pouvoir dïiuml;¿½ruire notre plotter */
return_value=pl_selectpl(0);
if(return_value<0)
{ fprintf(stderr,"Default Plotter could not be selected!\n");
err_status +=1<<1;
}
/* destruction de notre plotter */
return_value=pl_deletepl (handle);
if(return_value<0)
{ fprintf(stderr,"Le plotter sïiuml;¿½ectionnïiuml;¿½ne peut pas ïiuml;¿½re dïiuml;¿½ruit !\n");
err_status +=1<<2;
}
return err_status;
}
Plotutils
Gnuplot
Nous les avons installés directement à partier de notre distribution (SuSE, grâce à Yast)
Compiler :
gcc âacirc;€“Wall âacirc;€“ansi-strict programme.c âacirc;€“lm âacirc;€“lplot âacirc;€“o executable
Exécuter (pour piechart.c par exemple) :
./executable lplot âacirc;€“T X
Mathieu SCHREINER
Thibaut
MATHERN
IPST