original in en Emre Demiralp
en to nl Emile Aben
Emre is de leider van de Turkse LinuxFocus.
Bewaar het kaf, er komt een dag dat je het nodig hebt.-Turks gezegde-.
Dit is het eerste artikel in een serie over PostScript. Het voornaamste doel van de serie is niet om elk detail van de software te leren kennen maar om mensen die Postscript een interessante en plezierige programmeertaal vinden genoeg materiaal te geven om documenten te kunnen maken. Alhoewel we niet tot doel hebben een technisch document, een boek of een bijbel over dit onderwerp te schrijven, zullen we proberen om voldoende noodzakelijke informatie te leveren over PostScript.
De basis van PostScript werd 20 jaar geleden gelegd door John Gaffney en de Evens & Sutherland Computer Corporation. Het stond in het begin bekend als "Design System" maar werd later door Adobe Systems Incorporated ontwikkeld onder de naam PostScript tot een platform- en apparaatonafhankelijke applicatie voor het ontwerpen van pagina's. Adobe Systems Incorporated werd opgericht in 1982 door Chuck Geschke en John Warnock. Dit tweetal herimplementeerde de taal en gaf het een nieuw ontwerp, waarbij Doug Brotz, Billi Paxton en Ed Taft grote bijdragen leverden. Tegenwoordig is het een van de meest gebruikte applicaties voor het ontwerpen van pagina's, hoewel het door de meeste gebruikers niet direct wordt gebruikt. De capaciteiten van PostScript zijn van hoog niveau maar veel luie gebruikers die de details van deze krachtige programmeertaal niet willen kennen, gebruiken liever eindgebruikersgeoriënteerde applicaties die voornamelijk gebaseerd zijn op de "What You See Is What You Get" filosofie. Eerlijk gezegd gebruiken veel WYSIWYG applicaties PostScript bestandsformaten voor het bijhouden van documentatie of gebruiken het als tussenstation voor dingen als printen. Op deze manier overleeft PostScript als ons hulpje dat een krachtige assistent is voor veel computerkarweitjes die gerelateerd zijn aan tekenen, kleuren, het bewerken van plaatjes, kleurscheiding, simulatie en animatie, zelfs als het niet expliciet te zien is. Aan de andere kant is PostScript, als je het wilt leren, helemaal niet zo moeilijk.
De PostScript commando's worden uitgevoerd door zogenaamde interpreters, waarvan er enkele vrij verkrijgbaar zijn op het internet. Een daarvan is "ghostscript" van Aladdin Enterprise. Er is ook een grafische interface, "ghostview", van dezelfde organisatie. Het GNU-project heeft zijn eigen versies van ghostscript. Al deze programma's zijn beschikbaar voor alle Linux platforms en alle grote Linux distributies bevatten de programma's in hun standaard installaties. We zullen hier dieper ingaan op ghostscript en de speciale structuren en eigenschappen van ghostscript, alhoewel de voorbeeldprogramma's ook met andere interpreters uitgevoerd kunnen worden. We gaan uit van een geactiveerde X Window server en een open xterm venster. Als we ghostscript willen gebruiken dan zullen we commando's moeten geven op de command-prompt die we krijgen als we het commando "ghostscript" uitvoeren:
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>
Een blanco pagina zal tegelijk met het verschijnen van de command-prompt worden geopend. Het enige dat we hoeven te doen om de ghostscriptsessie te stoppen is het quit commando geven op de GS> prompt. EOF (Control-D) geeft hetzelfde effect.
Ghostscript kan ook commando's uitvoeren die in een bestand staan. In het volgende voorbeeld hebben we een bestand dat sample.ps heet geopend. Alle commando's die door ghostscript uitgevoerd worden staan in dit bestand, daarom noemen we de inhoud van het bestand een PostScript programma. De hele inhoud van hetprogramma of de individuele commando's worden na elkaar uitgevoerd door ghostscript als we het volgende commando geven op de shell-prompt van het xterm venster:
gs sample.ps
en het resultaat zal te zien zijn in het ghostscript venster (als het programma tenminste tot doel heeft een resultaat weer te geven in een venster; PostScript kan namelijk ook gebruikt worden voor wiskundige berekeningen, stack-operaties enzovoorts, maar daar zullen we op ingaan in de komende artikelen in deze reeks). Als het programma meerdere pagina's als resultaat produceert, zal het eerste venster te zien zijn en een showpage prompt zal op de ghostscript commandline verschijnen met het verzoek press <return> to continue voor de volgende pagina.
PostScript gebruikt Reverse Polish Notation (RPN - zoals sommige HP
rekenmachines). Hierbij worden de parameters voor een commando gegeven
voordat het commando zelf gegeven wordt. De commando's worden gescheiden
door lege ruimten. Er worden stack operaties gebruikt voor het verwerken
van data en uitvoeren van commando's. Er zijn vier stacks (een stack is
een soort 'stapel' waarvanaf je alleen de bovenste waarde kunt lezen)
die in PostScript gebruikt worden: de operand, dictionary, execution
en graphics state stacks. De operand stack bevat willekeurige
PostScript objecten die de operanden en resultaten zijn van de
PostScript commando's die worden uitgevoerd. We zullen enkele
voorbeelden geven voor wiskundige operaties:
20 30 add 10 sub
We kunnen afbeeldingen maken in PostScript door de geometrische structuur van hetgeen op de pagina moet komen te staan onder de loep te nemen. De locatie van de punten op een pagina worden beschreven door pixel eenheden die 1/72ste inch groot zijn in PostScript. De linkeronderkant van de rechthoekige pagina is de oorsprong (0,0) en de horizontale en vertikale zijden van de pagina zijn standaard 612 en 792 pixels groot respectievelijk. Deze groottes zijn de waarden voor pagina's van het type 'letter' (brief). Er zijn andere mogelijkheden voor de definitie van de paginagrootte zoals
note voor 540 bij 720 en
legal voor 612 bij 1008 en
a4 voor 595 bij 842.
Dit zijn gewone gs commando's, het commando 'a4' zal de pagina waarop getekend wordt aanpassen naar de gewenste grootte.
De definitie van de paginagrootte is te vinden in het initialisatiebestand dat gs_statd.ps heet. In de Slackware distributie is dit bestand te vinden in /usr/lib/ghostscript. Je kunt in dit bestand zelf niet-standaard paginagroottes definiëren, we gaan daar in een volgend artikel verder op in. We gaan er verder in dit artikel van uit dat het standaard paginatype op letter staat.
De tweede stap voor het maken van een afbeelding, na het definiëren van de pagina, is de cursor op de juiste plaats neerzetten op de pagina. Dit kan gedaan worden door het volgende commando te geven:
x y moveto
waarbij x en y respectievelijk de horizontale en de verticale coördinaat zijn van het punt waar de cursor moet komen te staan. x en y zijn hele getallen en vertegenwoordigen pixeleenheden. Zoals je ziet is de functionele structuur van PostScript anders dan die van andere programmeertalen zoals C en Fortran. moveto is het commando dat een actie uitvoert, met andere woorden: het verplaatst de cursor naar de plaats die de coördinaten x en y heeft. Omdat PostScript een stack gebruikt worden de parameters eerst opgegeven, daarna pas wordt het commando gegeven. Als het commando in de stack wordt gezet, neemt het de twee laatste waarden die in de stack zijn gezet, als parameters. Deze syntax is dus anders dan gebruikers gewend zijn uit programmeertalen als C en Fortran. Daarom hebben we hier enige nadruk op dit onderwerp gelegd. Samenvattend kunnen we zeggen dat elk commando dat parameters nodig heeft, pas gegeven moet worden nadat de parameters gegeven zijn.
Nu zijn we klaar om een afbeelding te maken. We gaan beginnen met een eenvoudig voorbeeld, een lijnstuk. Het enige dat nodig is om deze te tekenen is het volgende commando:
xx yy lineto
waarbij xx en yy de locatie zijn van het eindpunt van het lijnstuk zijn. Het beginpunt is de huidige locatie van de cursor, x en y. Hierdoor wordt door dit commando een lijnstuk gemaakt van x y naar xx yy. Voor het tekenen zelf zijn de commando's newpath en stroke noodzakelijk. Nu kunnen we, met de hier gegeven informatie, een PostScript programma schrijven om een rechthoek te tekenen. Het programma, dat we opslaan als sample1.ps ziet er als volgt uit:
newpath
100 100 moveto
300 100 lineto
300 250 lineto
100 250 lineto
100 100 lineto
stroke
Het is niet noodzakelijk om alle commando's op aparte regels te geven. We zouden ze ook allemaal op dezelfde regel kunnen geven, als we tenminste tussen alle commando's een spatie open laten, zoals we al eerder aangegeven hebben.
PostScript heeft, net als andere programmeertalen, ook een mogelijkheid voor het geven van commentaar. Alles dat op een regel na een procent-teken komt wordt door de interpreter opgevat als commentaar.
newpath
% Cursor initializatie
100 100 moveto
% De rechthoek tekenen
300 100 lineto
300 250 lineto
100 250 lineto
100 100 lineto
stroke
Als we nu het commando gs sample1.gs geven in een xterm
venster zal het gebruikelijke ghostscript venster verschijnen waarin
de door ons gewenste rechthoek getekend staat. We hoeven de gs
interpreter niet elke keer op te starten als we iets willen weergeven.
Als we op de GS> prompt het commando:
(sample1.ps) run
geven, zal dezelfde pagina weergegeven
worden.
Het stroke commando geeft een seintje aan de interpreter om de gewenste afbeelding te tekenen. In het bovenstaande voorbeeld zal het ghostscript venster een rechthoek laten zien met zijden van 200 pixels horizontaal en 150 pixels verticaal.
De lijnstukken hoeven niet noodzakelijkerwijs horizontaal of verticaal te zijn. Ze kunnen in elke gewenste richting geplaatst worden.
Als we uit het vorige voorbeeld de eerste lineto regel weglaten zal het programma een driehoek laten zien in het ghostscript venster. Op deze manier kun je, met de moveto en lineto commando's, allerlei afbeeldingen maken die opgebouwd zijn uit lijnstukken.
Er zijn nog twee andere commando's die ons kunnen helpen bij het maken van dergelijke afbeeldingen; de rmoveto en rlineto commando's. Deze commando's hebben beide twee parameters nodig en kunnen als volgt gebruikt worden:
x y rmoveto
x y rlineto
waarbij x en y de horizontale en verticale afstanden tussen begin- en eindpunten van iedere actie zijn. De 'r' in rmove en rlineto staat dan ook voor 'relatief'. Anders gezegd, wordt de cursor door het eerste commando x eenheden horizontaal naar rechts en y eenheden omhoog verplaatst. Het tweede commando gedraagt zich hetzelfde, maar trekt ook een lijn tussen begin- en eindpunt. Het zijn refererende commando's en de parameters die gegeven worden nemen de oorspronkelijke locatie als referentiepunt.
Alle bovenstaande voorbeelden gebruiken de standaard lijndikte bij het tekenen. Deze standaard waarde is 1 pixel. De gebruiker kan deze lijndikte overal in zijn programma aanpassen. Dat kan gedaan worden door het volgende commando te geven:
x setlinewidth
waarbij x de lijndikte in pixels is. Het effect van dit commando is blijvend totdat er een ander commando gegeven wordt dat de lijndikte verandert. Er is geen limiet aan het aantal commando's dat de lijndikte zet in een programma.
Natuurlijk is het tekenen in PostScript niet beperkt tot rechte lijnen alleen. Krommen kunnen ook gemaakt worden. Hiervoor moet het volgende commando gegeven worden:
x y r a b arc
waarbij x, y, r, a, en b respectievelijk de horizontale (x) en verticale coödinaten (y) en de straal (r) van de cirkel waarop de kromme ligt, de hoek tussen horizontale as en de straal door het beginpunt van de kromme (a) en de hoek tussen de horizontale as en de straal door het eindpunt van de kromme (b) zijn. De hoeken worden tegen de klok in gemeten. Als het beginpunt van de kromme niet de huidige locatie van de cursor is, wordt er een rechte lijn getrokken tussen de locatie van de cursor en het beginpunt van de kromme. Om het geheel wat beter te begrijpen kun je kijken naar de uitvoer van het volgende PostScript programma:
3 setlinewidth
200 200 moveto
100 200 100 0 75 arc
stroke
300 300 moveto
400 500 200 20 50 arc
stroke
We zullen de cursor zorgvuldig moeten plaatsen op het beginpunt van de kromme om te voorkomen dat we een extra lijn krijgen zoals hierboven genoemd. Er is echter een andere manier om van dit effect af te komen. De waarde van de plaats van de cursor kan gewist worden, of in ander woorden aan het begin het daaropvolgende commando heeft is er geen 'huidige cursorpositie'. Nadat er een tekencommando is gegeven zal het eindpunt van dit commando de waarde van de huidige cursorpositie worden. Als we het newpath commando geven dan zal PostScript de waarden van de huidige cursorpositie wissen en zich verder gedragen alsof het opnieuw is begonnen met tekenen. Het bovenstaande programma kan gewijzigd worden door de vijfde regel te vervangen door een regel die alleen het newpath commando bevat. Dit zal dezelfde uitvoer geven als voor de verandering, behalve dan dat de extra lijn naar het beginpunt van de kromme niet weergegeven zal worden.
Een 'pad' (een aaneengesloten geheel van lijnen, krommen etc.) wordt begonnen door de newpath operatie uit te voeren. Hierdoor wordt het huidige pad op nul gezet. Het pad wordt daarna opgebouwd door het uitvoeren van commando's die segmenten toevoegen aan het huidige pad.
Het arc commando kan gebruikt worden om een hele cirkel te tekenen. Hiervoor moeten de begin- en eindhoek op 0 en 360 gezet worden. Als dit gedaan wordt na een newpath wordt een volledige cirkel getekend. Het arc commando kan ook gebruikt worden om ellipsen te tekenen. Dit kan gedaan worden door de vergrotings en verkleiningsmogelijkheden van PostScript te benutten. De gebruiker kan de horizontale en verticale eenheden apart vergroten en verkleinen met het volgende commando:
x y scale
waarbij x en y de vergrotingsfactor zijn op de horizontale en verticale as. Dit betekent dat, als deze factoren gelijk aan 1 zijn dit geen effect op de tekening heeft. Het effect van deze factoren blijft gehandhaafd totdat een volgend commando dat vergroting/verkleining veroorzaakt wordt gegeven. Dit volgende commando zorgt er niet voor dat het effect van het commando ervoor teniet gedaan wordt, maar het combineert zijn eigen effect met het effect van het vorige commando. Als we aannemen dat het vorige commando de vergrotingsfactoren x1, y1 had, en het daaropvolgende commando de factoren x2, y2 dan zal het gecombineerde effect van deze commando's de vergrotingsfactor x1*x2, y1*y2 hebben. Om ongewenste resultaten, zoals het van de pagina verdwijnen van lijnen, te vermijden moet dit effect zeker in de gaten gehouden worden. Standaard neemt PostScript aan dat er geen vergroting plaatsvindt. Het volgende PostScript programma sample4.gs is een voorbeeld van het gebruik van vergroting:
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
Zoals je merkt, heeft het vergroten effect op elke grootte, dus ook de lijndikte. De lijndikte van de ellipsen en cirkels uit het vorige voorbeeld verschillen hierdoor van elkaar.
Postscript heeft nog twee andere commando's voor het tekenen van krommen. Een van deze commando's, arcn is in grote lijnen hetzelfde als arc op de tekenrichting na. arcn tekent de kromme met de klok mee. Het derde commando tekent een kromme die een gegeven raaklijn heeft aan zijn begin en eindpunt. Dit commando wordt als volgt gegeven:
x1 y1 x2 y2 r arcto xt1 yt1 xt2 yt2
waarbij xt1, yt1, xt2, yt2 de horizontale en verticale coördinaten zijn van begin- en eindpunt van de kromme, de eindpunten van de raaklijnen worden gegeven door x1, y1 en x2, y2 en de r staat voor de straal van de kromme. Als het 'pad' niet nieuw is of de plaats van de cursor komt niet overeen met de beginplaats van de kromme, dan zal er een lijn tussen deze twee punten getrokken worden. Aan het einde van het commando zal de cursorpositie xt2, yt2 worden.
PostScript heeft ook een commando, gebaseerd op het Bezier algorithme, dat gebruikt kan worden voor inter- of extrapolatie van data voor grafieken. Dit is het curveto commando en het kan gebruikt worden voor krommen gebaseerd op de inter- of extrapolatie van een gegeven dataset. Het commando wordt als volgt gegeven:
x1 y1 x2 y2 x3 y3 curveto
waarbij de kromme start op de huidige cursorpositie, waarvan we aannemen dat de coördinaten x0, y0 zijn. De getekende kromme raakt in het beginpunt de lijn tussen de punten x0, y0 en x1, y1. De kromme eindigt op punt x3, y3 en raakt daar de lijn tussen x2, y2 en x3, y3. Van alle vier de punten wordt aangenomen dat ze verschillend zijn, waardoor ze de vorm van de kromme bepalen.
PostScript heeft verschillende lettertypen die gebruikt worden als standaard lettertypen bij 'desktop publishing'. Er zijn ook faciliteiten om lettertypen te maken, welke toegankelijk zijn door het definiëren van 'dictionary stacks' waar lettertypen beschikbaar zijn. Het volgende PostScript programma is een voorbeeld:
/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
Uit dit programma valt te halen dat het findfont commando gebruikt wordt voor de toegang tot de gewenste lettertype-structuur. De naam van het lettertype begint met / en wordt ingevoerd voorafgaand aan het commando waarbij / een indicatie aan de 'interpreter' is om de waarde naar de stack te schrijven 'zoals hij is'. Als we wat dieper zijn ingegaan op de details van stack zal deze laatste opmerking een stuk duidelijker worden. Na het selecteren van een lettertype wordt de schaal gedefinieerd door het scalefont commando. De vergrotingsfactor wordt gegeven door de waarde die voorafgaand aan het commando gegeven wordt. Na het vergroten/verkleinen wordt het lettertype klaargemaakt voor verder gebruik in het programma door het setfont commando. Nadat we de cursor plaatsen met het moveto commando met de juiste parameters, wordt de tekst tussen haakjes als parameter meegegeven aan het show commando. Het showpage commando maakt het weergeven van het geschrevene af. Het hierboven beschreven programma gebruikt verschilende lettertypen in verschillende grootten in dezelfde tekst. Het aantal lettertypen dat beschikbaar is in PostScript kan gevonden worden door de locatie van de lettertypen te doorzoeken in de boomstructuur van het linux systeem dat gebruikt wordt. De tekst kan aangepast worden met lijnen, krommen en andere gereedschappen, waardoor alle mogelijke schrijfopdrachten mogelijk worden, het is een kwestie van ontwerp.
PostScript heeft verschillende faciliteiten om figuren in te kleuren en zo kleurrijke plaatjes te maken. Om te beginnen zullen we de commando's om een document kleur te geven bespreken. PostScript gebruikt zwart als standaardkleur als er geen commando gegeven is dat een andere kleur specificeert. Dit is de reden waarom alle voorgaande programma's zwart-wit documenten opleverden. Om kleur te gebruiken in PostScript kunnen drie verschillende commando's gegeven worden. Het eerste commando is gebaseerd op het rgb kleurformaat. In dit formaat wordt elke kleur gedefinieerd als een samenstelling van de drie kleuren rood, groen en blauw. De kleurcomponenten worden gegeven als individuele intensiteiten die waarden hebben tussen 0 en 256. Deze intensiteitswaarden kunnen gegeven worden tot op 3 cijfers na de komma, zoals bijvoorbeeld 111.223. Hierdoor moet het commando als volgt in PostScript ingevoerd worden.
x y z setrgbcolor
waarbij x,y,z de intensiteitswaarden zijn van rood, groen en blauw en setrgbcolor het bijbehorende commando is. Per conventie wordt door 1 0 0 setrgbcolor rood gemaakt terwijl 0 1 0 setrgbcolor overeenkomt met groen. Zwart wordt gemaakt als alle intensiteitswaarden 1 zijn. Dit soort commando's waarin kleuren aangeduid worden blijven gelden totdat een volgend soortgelijk commando wordt gegeven. Als een tweede kleurcommando wordt gegeven doet deze het effect van het eerste kleurcommando volkomen teniet. Het gebruik van kleuren is ongelimiteerd. Door op de juiste manier kleurinstellingen te gebruiken kun je documenten maken zoals je ze bedoeld. Het is een kwestie van kunst en wordt volledig aan jezelf overgelaten.
Het tweede commando voor kleurgebruik is gebaseerd op een viercomponenten kleurformaat, het cmyk formaat. De vier basiskleuren hiervan zijn cyaan, magenta, geel en zwart respectievelijk. Elke kleurcomponent heeft een intensiteitsparameter die ligt tussen 0 en 1. Het PostScript commando dat hierbij hoort is het volgende:
w x y z setcmykcolor
waarbij w,x,y,z de intensiteitswaarden zijn voor de kleuren cyaan, magenta, geel en zwart respectievelijk. Ook fractionele decimale waarden kunnen gebruik worden voor deze intensiteitswaarden. Ook dit commando houdt zijn effect totdat het volgende kleurcommando gegeven wordt, waarna het nieuwe commando de kleurinstellingen compleet opnieuw instelt. Er is geen limiet aan het aantal keren dat dit commando in een programma gegeven kan worden.
Het derde commando kan als volgt gebruikt worden
x y z sethsbcolor
waarbij x,y,z de intensiteitswaarden zijn van drie verschillende eigenschappen van de kleur. De eerste is de zogenaamde tint welke bepaald waar de kleur zich bevind in het spectrum van het licht. De tweede, verzadiging en de derde, felheid komen overeen met de verzadiging en felheid van de kleur. Aan dit formaat wordt de voorkeur gegeven als de locatie van de kleur in het spectrum of de verzadiging en/of de felheid van een kleur gecontroleerd moeten worden, bijvoorbeeld in een programmalus. De lezers die het hsb-kleurformaat niet kennen kunnen eens kijken naar het xfig programma onder linux.
De belangrijkste commando's voor het vullen van vlakken zijn fill en closepath. Het volgende voorbeeld, waarvan aangenomen wordt dat het opgeslagen wordt als sample6.ps verduidelijkt belangrijke aspecten van kleurgebruik en het vullen van vlakken in 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
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
gsave fill grestore stroke
stroke
0 1 0 setrgbcolor
newpath
1 4 scale
100 150 40 0 360 arc
gsave fill grestore stroke
waarbij closepath een figuur sluit door de eindpunten te verbinden met een rechte lijn terwijl fill gebruikt wordt om het vlak, dat omsloten wordt door de figuur, in te kleuren.
PostScript kan ook grijstinten maken door het volgende commando:
x setgray
waarbij x de intensiteit van de grijstint is welke kan liggen tussen 0, wat overeenkomt met zwart, en 1, wat overeenkomt met wit. Het volgende programma wordt opgeslagen als sample7.gs en is zo opgebouwd dat het zelfverklarend is.
0.2 setgray
10 setlinewidth
100 700 moveto
200 0 rlineto
stroke
newpath
0.3 setgray
100 600 moveto
200 0 rlineto
stroke
newpath
0.4 setgray
100 500 moveto
200 0 rlineto
stroke
newpath
0.5 setgray
100 400 moveto
200 0 rlineto
stroke
newpath
0.6 setgray
100 300 moveto
200 0 rlineto
stroke
newpath
0.7 setgray
100 200 moveto
200 0 rlineto
stroke
newpath
0.8 setgray
100 100 moveto
200 0 rlineto
stroke
Voordat deze presentatie eindigd kunnen we de lezer aanraden om ingewikkelder programma's te schrijven in PostScript. In het volgende artikel in deze serie worden meer details van de PostScript taal besproken. Alle vragen en tips zijn van harte welkom. We zullen deze vermelden in de komende artikelen.
De auteur wil graag Oliver Thilmann bedanken voor zijn commentaar op de organisatie en presentatie van dit artikel.