Sommaire Index Rechercher Liens A Propos
[LinuxFocus Image]
[Barre de Navigation]
  Nouveautés   Archives

Le Langage Postscript

par Emre Demiralp


Introduction

Dessiner

Ecrire

Mise en couleur

Engrange la balle (du grain), un jour elle te sera utile.
-Proverbe Turc-.

Introduction

C'est le premier d'une série d'article sur PostScript. Le but de cet article n'est pas appréhender tous les points de détails du langage mais assez d'éléments pour que vous puisez vous faire une idée sur PostScript et de vous amuser a programmer des documents. Cependant nous n'allons pas essayer de vous soumettre un article technique, ou un roman, ni une bible sur le sujet, mais nous allons tenter de vous présenter les informations nécessaires pour bien débuter en PostScript.

Le langage PostScript a été créé il y a 22 ans par John Gaffney de the Evans & Sutherland Computer Corporation. Il était développé par "Design System" au début puis Adobe Systèmes Incorporated continua le développement comme un langage outil indépendant pour le formatage de page. Maintenant il reste le format le plus utilisé bien que la plus part des utilisateurs ne le sachent pas. Ses capacités sont de haut niveau cependant beaucoup d'utilisateurs paresseux qui ne veulent pas entrer dans les détails de ce langage préférez utiliser les autres outils destinés aux utilisateurs de base qui sont principalement basés sur la technique du "What You See Is What You Get". Cependant, beaucoup d'outils WYSIWYG utilisent PostScript comme format de fichier ou comme format d'impression. Ce langage survit toujours tel une aide puissante pour effectuer beaucoup de travaux associé au dessin, de coloriage , de traitement d'image. D'autre part, si vous désirez apprendre ce langage sa structure n'est pas aussi difficile qu'on le dit.

Les commandes PostScript sont exécutées grâce a des interpreteurs. Les deux les plus connus font parti des logiciels libres du domaine public et sont disponible sur internet. Il s'agit de "ghostscript" et "ghostview" de l'entreprise Aladdin. Ils sont disponibles sur l'ensemble des plateformes Linux et la plupart des distributions linux les installent par défaut. nous traitons Ici du programme ghostscript bien qu'on puisse exécuter les exemples par d'autres interpréteur Postscript. Supposez que nous utilisons une plate-forme Linux et que vous vouliez utiliser ghostscript. Le point de départ peut être différent en s'accordant au modèle d'utilisation. Si nous voulons voir les résultats sur l'écran alors nous pouvons avoir deux possibilités: XWindows ou l'affichage direct par la carte graphique. Bien que l'affichage graphique directe par la carte graphique soit disponible sous le linux, il y a certaines limitations à cause de la variété des cartes graphiques. D'autre part si le linux a un serveur X configuré, ghostscript fonctionnera indépendamment du type de la carte. Par conséquent nous supposons que nous lançons le serveur X et qu'une fenêtre xterm est ouverte. Alors nous pouvons utiliser ghostscript en tant qu'interprète pour chaque commande ou groupe de commandes qui seront entrées après le prompt .

Initializing... done. Ghostscript 2.6.2 (4/19/95) Copyright (C) 1990-1995 Aladdin Enterprises, Menlo Park, CA. All rights reserved. Ghostscript comes with NO WARRANTY: see the file COPYING for details.
GS>_


Une fenêtre vide doit apparaître en même temps qu'apparaît le prompt de gohstview. Ce dernier va afficher le résultat de chacune des commandes données après le prompt GS>, puis il affichera de nouveau un prompt dans l'attente d'une nouvelle commande. Si vous voulez sortir de votre session ghostscript, vous devez entrer la commande quit apres le prompt GS>; .

Nous pouvons aussi utiliser ghostscript comme un compilateur. Dans ce cas nous ouvrons un fichier, par exemple, exemple.ps . Toutes les commandes qui doivent être exécutées par ghostscript ont été écrites dans ce fichier, comme dans le cas d'un programme. Par conséquent ce fichier est un programme de PostScript. L'ensemble de ce programme ou ses commandes individuelles, seront exécutées grâce à ghostscript si nous tapons les commandes suivante au propmt du shell de la fenêtre xterm de Linux

gs sample.ps

alors il y aura l'affichage du résultat du programme sample.ps. En fait, PostScript peut être utilisé pour d'autres buts comme l'arithmétiques ou calculs mathématiques etc... ( Nous en parlerons dans d'autres articles sur le PostSript plus tard) Si le programme produit plusieurs pages alors a l'affichage il y aura la première page et un showpage apparaîtra; le programme ghostscript est en attente de la touche enter pour la prochaine page.

Comment utiliser PostScript pour dessiner?

Nous pouvons commencer par dessiner grâce a PostScript en considérant le géométrie de la page. Les coordonnées des points sur la pages ont comme unité le pixel ( picture element ) qui représente nn soixante douzième de pouce dans le langage PostScript. Le point en bas et à gauche de la page a pour coordonées (0,0) et la taille de la page est horizontalement 612 , et verticalement 792. Ces tailles sont valides pour le type :"letter type". Il y a plusieurs possibilités de définition de tailles de pages comme

note pour 540 et 720 ou
legal pour 612 et 1008 ou
a4 pour 595 et 842 .

La définition de la taille de la page peut être trouvée dans le fichier d'initialisation gs_statd.ps. Vous pouvez définir une taille non standard en modifiant d'une manière approprié ce fichier, nous y reviendrons dans cette série d'articles plus tard. Nous admettrons que nous utilisons le type letter dans cette présentation.

La deuxième étape après ces considérations sur la taille de la page, est de placer le pinceau à la position initiale du tracé. Ceci peut être réalisé par la commande

x y moveto

Ou x et y sont respectivement l'abscisse ( horizontale ) et l'ordonné ( verticale ) ou va être placé le pinceau et ou x et y sont considérés comme des nombres entiers correspondant à des pixels. vous pouvez voir que la structure du langage PostScript est un peu différente des autres langages de programmation. Ici les paramètres de la fonction ou de la commande sont donnés avant la commande elle-même. moveto est la commande qui déplace le curseur à l'emplacement donné par deux nombres qui sont les paramètres. L'interprétation du PostScript se déroule grâce a une machine à registre (la pile). On empile les paramètres puis la commandes dépile le nombre de paramètres dont elle a besoin. Pour la commande moveto, à l'exécution elle va dépiler deux éléments sur la pile qui sont ses paramètres. Bien que le procédé soit presque le même pour les autres langages de programmation, la syntaxe pour l'utilisateur peut paraître différente. Résumons nous, les paramètres d'une fonction sont rangés sur la pile, et sont aussi important que l'appel de cette dernière. De même, l'ordre des paramètres est très importants.

Maintenant nous sommes prêt à tracer une ligne. Commençons avec une figure simple: juste un segment. La commande pour réaliser ceci est

xx yy lineto

xx et yy sont les coordonnées du point correspondant a la fin du segment. Son point de départ est la position courante du pinceau x et y . Maintenant écrivons un programme permettant de dessiner un rectangle. Cela peut être fait avec les informations données ci-dessus. Le programme ci dessous, supposé être dans sample1.ps, a l'allure suivante :

100 100 moveto
300 100 lineto
300 250 lineto
100 250 lineto
100 100 lineto

Bien que nous ayons donné chaque commande dans les lignes séparées, ce n'est pas vraiment nécessaire. Nous pourrions les donner sur la même ligne en insérant un espace vide entre les commandes consécutives. L'écriture d'un programme dépend de l'utilisateur. Cependant, si vous voulez écrire des programmes clairs, la séparation des lignes par un retour à la ligne permet de gagner en clarté. De même, Les commentaires sont également très importants pour éclaircir la structure du programme. la langage PostScript accepte les commentaires comme les autres langages de programmation. Tout ce qui suit un signe de pourcentage dans une ligne est interprété en tant que commentaire. Par conséquent, en utilisant le caractère % vous pouvez mettre beaucoup de messages d'avertissement ou explications dans le programme. Par exemple le programme ci-dessus peut être réécrit comme suit

% Cursor initialization %
100 100 moveto
% Drawing the rectangle %
300 100 lineto
300 250 lineto
100 250 lineto
100 100 lineto

Cependant nous vous présentons des commentaires sur une ligne, nous pourrions les mettre sur la même lignes qu'une commande, après celle ci.

Si nous tapons maintenant gs sample1.ps au prompt d'un xterm, la fenêtre de ghostscript apparaît mais sans l'affichage désiré du rectangle. La raison de ceci se trouve dans le fait que les commandes ci-dessus sont exécutées virtuellement. En d'autres termes, PostScript regarde leur structure sémantique et se plaint s' il y a quelque chose d'incorrect mais il n'imprime rien sur la page. Les commandes données ci-dessus peuvent être considérées comme l'étape de conception du dessin. La figure conçue doit être imprimée sur la page en donnant une commande PostScript séparée à cette fin. Cette commande est stroke. Si nous l'ajoutons à la fin du dernier programme, alors l'exécution de gs sample1.ps fera apparaître dans une fenêtre une rectangle de largeur 200 et de hauteur 150 unités.

Les lignes ne sont pas obligatoirement horizontales ou verticales. Elles peuvent être placées dans n'importe quelles directions. A titre d'exemple voici le programme du fichier sample2.ps

% Cursor initialization %
200 200 moveto
% Drawing the rectangle %
400 300 lineto
300 300 lineto
200 200 lineto
stroke

Comme vous pourrez le voir, l'affichage résultant de l'interprétation ghostscript sera un triangle. Vous pouvez créer n'importe quelle sorte de figures composée de lignes ( polygones ) en utilisant les commandes moveto et lineto.

Il y a deux autres commandes qui peuvent être utilisées pour construire ainsi des figures. Ce sont rmoveto et rlineto. Elles s'utilisent comme ci-dessous.

x y rmoveto
x y rlineto

Ou x et y sont les distances horizontales et verticales entre les points initiaux et finaux. En d'autres mots la premier commande bouge le curseur par rapport à l'ancienne position de x et de y. La seconde commande agit de même, mais dessine en plus une ligne. Ces commandes prennent le position du curseur comme point d'origine de système de coordonnées.

Tous les exemples utilisent une épaisseur de trait par défaut égale à 1 pour le dessin. Or l'utilisateur peut modifier cette valeur n'importe où dans le programme par la commande:

x setlinewidth
Où x est l'épaisseur du trait, et cette épaisseur sera la même jusqu'à la prochaine commande setlinewidth. Il n'y a pas de limitation à propos de l'épaisseur du trait, par défaut cette épaisseur est égale à 1.

Bien sur, dessiner avec PostScript ne se limite pas à des lignes. Des arcs de cercle peuvent aussi être dessinés. Nous utiliserons alors les commandes suivantes.

x y r a b arc

ou x, y, r, a et b signifient les coordonnées horizontales et verticales du centre de l'arc, r: le rayon de l'arc, a est l'angle trigonométrique correspondant à l'angle de l'arc à tracer. Le sens est le sens des aiguilles d'une montre. Si le point de départ de l'arc ne correspont pas à la position actuelle du curseur, alors une ligne droite est ajoutée entre la position courante du curseur et le point de départ de l'arc. Pour mieux comprendre cette situation, essayez le programme sample3.ps suivant.


3 setlinewidth
200 200 moveto
100 200 100 0 75 arc
stroke
300 300 moveto
400 500 200 20 50 arc
stroke

Nous devons par conséquent faire attention et placer le curseur à la position de départ de l'arc. Toutefois, il y a une autre façon de s'affranchr de cet effet. Le point courant peut avoir des valeurs vides. Il n'y a alors pas de position designée pour le curseur. En d'autre termes, il n'a pas de valeurs de paramètre pour le début du tracé. Une fois le tracé commencé, le point de destination devient le point courant. Avec la commande newpath PostScript efface les coordonées du curseur et considère que le dessin commence à cet endroit du programme. Par conséquent, le programme ci-dessus peut être modifié en remplaçant la cinquième ligne avec une ligne qui ne contient que la commande newpath. Avec ceci, le resultat du programme ci-dessus sera le même sans le segment de ligne supplémentaire.

La commande arc peut aussi dessiner un cercle. Pour cela il suffit de donner comme angle de départ 0 et comme angle de fin 360. Avec newpath on obtient un cercle complet. La commande arc peut aussi être utilisée pour tracer des ellipses. On les obtient en jouant sur les propriétés d'echelles de PostScript. L'utilisateur peut changer indépendamment les unités des échelles horizontales et verticales avec la commande suivante:

x y scale

x et y sont respectivement le facteur horizontal et vertical d'agrandissement. Ceci veut dire que s'ils valent 1 cela n'aurait pas d'effet sur le dessin. L'effet d'agrandissement persiste jusqu'à une autre commande scale. La commande suivante de redimensionnement n'annule pas les effets de la précédente mais les combine avec elle. Supposons que la commande d'échelles précédente avait les coefficients x1, y1 et que la nouvelle a des facteurs x2, y2 , les effets combinés de ces deux commandes seront les facteurs x1*x2, y1*y2. Ce fait doit être gardé présent à l'esprit afin d'éviter des effets indésirables lors de l'affichage tels que des lignes qui sortent du papier. PostScript assume par défaut la non existence de facteurs d'échelle. Le programme PostScript suivant, sauvé dans le fichier sample4.ps illustre ces redimensionnements.

3 setlinewidth
200 200 100 0 360 arc
stroke
newpath
2 1 scale
200 300 50 0 360 arc
stroke
newpath
1 4 scale
100 150 40 0 360 arc
stroke

On peut noter que l'agrandissement affecte chacune des tailles y compris aussi la largeur de ligne. Les largeurs des lignes des ellipses et du cercle créés par le programme ci-dessus sont la conséquence de ce phénomène.

le langage PostScript a deux autres commandes pour dessiner des arcs. Un d'elles, arcn, est principalement la même que arc à l'exception de la direction du dessin. arc de arcn dessine dans le sens des aiguilles d'une montre. La commande du dessin du troisième arc dessine un arc circulaire qui est tangent à deux lignes données aux points extrèmes. Elle peut être écite comme suit.

x1 y1 x2 y2 r arcto xt1 yt1 xt2 yt2

xt1, yt1, xt2, yt2 représentent les coordonnées verticales et horizontales de l'arc tandis que les lignes tangentes ont les valeurs x0, y0, x1, y1 et x1, y1, x2, y2 respectivement et r représente le rayon de l'arc Si le tracé n'est pas neuf ou que le point courant ne coincide pas avec le début de l'arc, alors une ligne joindra le points courant avec avec le début de l'arc. A la fin du tracé, le point courant devient xt2,yt2. Bien que l'arc soit circulaire malgré l'utilisation de facteurs d'échelles non uniformes (facteurs horizontaux et verticaux différents), il peut être convertit en arc d'ellipse.

Le langage PostScript possède aussi une commandes permettant de tracer des courbes de Béziers qui sont efficaces pour tracer des courbes d'interpolation ou d'extrapolation de points. La commande PostScript est curveto et peut être utilisée pour créer un courbe d'interpolation ou d'extrapolation de points, son utilisation est la suivante:

x1 y1 x2 y2 x3 y3 curveto

où la courbe commence au point courant dont les coordonnées sont considérées être x0, y0. Elle est tangente à la ligne entre les points x0,y0 et x1, y1 au point de départ. La courbe se termine au point x3, y3 et est tangente à la ligne entre les points x2, y2 et x3, y3. Par défaut cesw quatre points sont considérés comme différents et ils déterminent la forme de la figure. the curve starts at the current point whose coordinates are assumed to be x0, y0 . It is tangent to the line between the points x0, y0 and x1, y1 at the beginning point. The curve ends at the point x3, y3 and is tangent to the line between x2, y2 and x3, y3 . By default all these four points are assumed to be different and they determine the shape of the figure.

La possibilité caligraphique de PostScript

PostScript a plusieurs fontes standards qui sont utilisée pour la PAO. Il a aussi des possibilités de création de fontes auxquelles on peut accèder en définnissant des bibliothèques. Le programme PostScript suivant (sample5.ps) en illustre l'utilisation.

/Times-Roman findfont
15 scalefont
setfont
100 500 moveto
(I love PostScript!) show
/Times-Italic findfont
20 scalefont
setfont
100 450 moveto
(I love PostScript!) show
/Times-Bold findfont
25 scalefont
setfont
100 400 moveto
(I love PostScript!) show
/Helvetica findfont
30 scalefont
setfont
100 350 moveto
(I love PostScript!) show
/Courier findfont
35 scalefont
setfont
100 300 moveto
(I love PostScript!) show
/Helvetica-Bold findfont
40 scalefont
setfont
100 250 moveto
(I love PostScript!) show
showpage

Comme vous pouvez le voir dans ce programme la commande findfont permet de charger la fonte désirée. Le nom de la fonte avec / est donné à la commande comme paramètre. le nombre avant la commande scalefont est le facteur d'agrandissement, paramètre de cette commande. Ensuite, la commande setfont charge la fonte qui est alors prête pour sa future utilisation dans le programme. Après le positionnement du curseur grâce à la commande movetoavec des paramètres appropriés, le texte à afficher est entre parenthèses; ce dernier est le paramètre de la commande show. La commande showpage finalise le travail en réalisant l'affichage, ou impression. Le programme ci-dessus montre l'utilisation de diverses fontes de types et tailles différentes. Le nombre de fontes disponible pour PostScript peut être trouvé en recherchant les emplacements des fontes dans les répertoires linux par la commande locate. Le texte peut suivre une ligne, une courbe ou tout autre tracé. Ainsi tous les délires artistiques sont permis et même favorisés.

La mise en couleur grâce à PostScript

Le langage PostScript a plusieurs commandes pour peindre des figures ou créez les images colorées. Commençons par mentionner les commandes de coloriage. Par défaut, PostScript utilise le noir comme couleur de remplissage. Par conséquent la sortie des tous les programmes précédents était en noir et blanc Pour utiliser la couleur avec PostScript, on a le choix entre trois types de commandes différentes. Le premier est basé sur le format rgb. Dans ce format on décrit chaque couleur par sa composante rouge, vert et bleu. Les composantes de couleur peuvent prendre les valeurs 0 à 256. Les intensités peuvent être des valeurs fractionnaires décimales jusqu' à la précision de trois chiffres comme par exemple 111,223. La commande setrgbcolor doit être appelé comme suit.

x y z setrgbcolor

x, y, z sont les paramètres d'intensité pour le rouge, vert et bleus et setrgbcolor est la commande. Dans cette convention 1 0 0 est la couleur rouge du setrgbcolor tandis que 0 1 0 setrgbcolor est le vert. Le noir correspond au cas où toutes les valeurs sont égales à 1. L'affectation d'une couleur au tracé par cette commande perdurera jusqu' à la prochaine commande de changement de couleur. Quand ceci se produit l'effet de la première configuration disparaît complètement et la nouvelle configuration est utilisée . Vous pouvez changer autant de fois la couleur que vous voulez. En utilisant finement les couleurs, vous pouvez créez vos images juste comme vous voulez.

Le deuxième type est basé sur un format à quatre composantes. Celui s'appelle le format cmyk. Les quatre couleurs de base sont, alors, cyan, magenta, jaune et noir. Chaques composantes contribuent à la couleur finale avec une intensité allant de 0 à 1. La commande correspondante au changement de couleur grâce au format cmyk est setcmykcolor.

w x y z setcmykcolor

w, x, y, z sont les paramètres d'intensité pour la couleur : composantes cyan, magenta, jaunes et noirs respectivement. Les valeurs flottantes peuvent également être utilisées pour des paramètres d'intensité. Cette commande s'applique également jusqu'à l'émission de la prochaine commande. Quand ceci est fait les nouvelles couleurs changent le réglage précédent. Il n'y a pas de limitation de changement de couleur.

La Troisième commande peut être utilisé comme ceci :

x y z sethsbcolor

x, y, z correspondent aux intensités de trois composantes de la couleur. Le Premier correspond à hue qui détermine l'emplacement de la couleur dans le spectre de la lumière. Le second, saturation et le troisième, brightness corresponds à la saturation et l'éclat de la couleur. Ce format est souvent préféré quand l'emplacement de la couleur dans le spectre par l'intermédiaire d'une boucle ou de l'éclat et/ou de la saturation deviennent les propriétés à contrôler.

Deux commandes importantes du langage PostScript pour le dessin sont fill et closepath. L'exemple suivant (sample6.ps ) va vous éclairer sur ces commandes de remplissage et de coloriage avec PostScript.

1 1 0 0 setcmykcolor
100 100 moveto
300 100 lineto
300 250 lineto
100 250 lineto
100 100 lineto
stroke
1 0.5 0.8 0 setcmykcolor
5 setlinewidth
200 200 moveto
400 300 lineto
300 300 lineto
closepath fill
stroke
1 0 0 setrgbcolor
3 setlinewidth
200 200 moveto
100 200 100 0 75 arc
stroke
%300 300 moveto
newpath
400 500 200 20 50 arc
stroke
0 0 1 0.2 setcmykcolor
3 setlinewidth
200 200 100 0 360 arc
stroke
1 0 0 setrgbcolor
newpath
2 1 scale
200 300 50 0 360 arc
fill
stroke
0 1 0 setrgbcolor
newpath
1 4 scale
100 150 40 0 360 arc
fill
stroke

Où la commande closepath ferme un chemin en joignant deux extrémités par une ligne droite tandis que fill sert à remplir l'intérieur d'un chemin fermé avec la couleur courante.

PostScript peut aussi créer les tonalités du gris. Ceci peut être fait grâce a la commande

x setgray

x est l'intensité du niveau de gris et sa valeur va de de 0, qui correspond au noir, à 1 qui correspond au blanc. Le programme suivant ( sample7.ps ) en fait la démonstration.

0.2 setgray
10 setlinewidth
100 700 moveto
200 0 rlineto
stroke
newpath
0.3 setgray
10 setlinewidth
100 600 moveto
200 0 rlineto
stroke
newpath
0.4 setgray
10 setlinewidth
100 500 moveto
200 0 rlineto
stroke
newpath
0.5 setgray
10 setlinewidth
100 400 moveto
200 0 rlineto
stroke
newpath
0.6 setgray
10 setlinewidth
100 300 moveto
200 0 rlineto
stroke
newpath
0.7 setgray
10 setlinewidth
100 200 moveto
200 0 rlineto
stroke
newpath
0.8 setgray
10 setlinewidth
100 100 moveto
200 0 rlineto
stroke

Après la lecture de cet article, vous pouvez écrire des programmes compliqués et complets pour les utilisateurs qui trouvent PostScript enthousiasmant. Dans les prochains articles, nous traiterons plus à fond les détails du langage PostScript. Toutes les questions et recommandations sont les bienvenues.


Traduit en français par Charles Vidal


© 1998 Emre Demiralp
Ce site Web est maintenu par Miguel A Sepulveda.