The PostScript page description language is useful for representing the printed page in a device independent manner. It is the language that the majority of the laser printers in the Department of Computer Science understand. It is also used by some of the new window managers as their graphical language.

Some features of the PostScript language are:

- PostScript is particularly suited to describe graphical information

- about 1/3 of PostScript is devoted to graphics -- the remainder is a general purpose programming language which closely resembles FORTH and other stack-oriented languages

- it is often called a "page generation language"

- it is interpreted


PostScript files can be viewed by either using some kind of viewing program or by sending them to a PostScript printer. To view a PostScript file on the workstation monitor, use the GhostScript program. To print your file, use the lpr command. USING GHOSTSCRIPT

GhostScript is a PostScript interpreter that runs on many different computers under a variety of different environments. It can be used as a stand alone program or as a front/back end for other programs such as ghostview, for example. To use GhostScript, log into an terminal with X display capabilities, such as one of the DEC Stations and enter the command 'gs'. GhostScript uses a command line window for command entry and displays results in another X-Window. You can enter a PostScript program interactively by directly typing it into GhostScript, line by line, or you can load and execute a program using the following command: '(filename.ps) run'. To get out of GhostScript, type 'quit'. USING LPR

In most applications, a PostScript program (or PostScript file) is created and saved automatically or sent to some output device, such as a printer. To print out a PostScript file, the printer used must support the PostScript language, as is the case for all laser printers in the CS department. To print out your PostScript source code you should use the following command:

lpr -Pc135ps filename.ps

To print out the output from your PostScript source code you should make sure that the first line of your program is "%!" and then issue the same lpr command as before. If the first line of your program is not "%!", then the source code will be printed and not the image generated by the source code.


PostScript reserves a piece of memory called a stack (FILO, LIFO). All PostScript functions (known as macros) which require parameters take them from the stack. When passing values to macros, they are placed on the stack in the proper order required. PostScript uses postfix notation. The operands that it requires are placed on the stack in the order required and the results of the operation are then placed on the stack after the operands have been removed. POSTSCRIPT GRAPHICAL OBJECTS

PostScript supports 3 types of graphical objects:

- Text:

- any typeface in any position, orientation, or scale

- Geometric Figures:

- describe locations of lines of any size, orientation, & width as well as spaces of any size, shape, or colour

- Sampled Images:

- in any scale or orientation POSTSCRIPT IMAGING MODELS

An imaging model is a set of rules which are very similar to those used by graphical artists. A page is built up piece by piece and then displayed on an output device. In PostScript, all "paint" is opaque.

- current page:

- this is the "ideal page" that the image is drawn on and is independent of any output device used

- when a program begins, the current page is blank

- current path:

- a set of connected and disconnected points, lines, and curves that, together, describe shapes and positions

- a path is not actually a mark on a page (yet) but must be stroked, clipped, or filled

- clipping path:

- the boundary of the area that may be drawn upon -- originally the standard paper size but can be any size or shape COORDINATE SYSTEM

PostScript uses a standard X,Y coordinate system with location (0,0) in the bottom left hand corner. This is known as user space. Different output devices have different, idiosyncratic coordinate systems, which is called device space. Coordinates in a PostScript program are automatically transformed from user space to device space before actual printing of the current page. User space may be altered by translating, rotating, or scaling PostScript's default units are 1/72 inch, also known as a point. Therefore, 72 points is equal to one inch.


The following are short examples that demonstrate the use of the PostScript stack.

- to add 2 numbers together:

5 27 add stack: 5 27

stack: 32

- to subtract 2 numbers:

8.3 6.6 sub stack: 8.3 6.6

stack: 1.7

- the sub operator subtracts the top number on the stack from the bottom number

- to divide 2 numbers:

13 8 div stack: 13 8

stack: 1.625

- like sub, div divides the bottom number by the top number

- to perform: 6 + (3 / 8)

3 8 div 6 add stack: 3 8

stack: .375 <div operation>

stack: .375 6

stack: 6.375 <add operation>


6 3 8 div add stack: 6 3 8

stack: 6 .375 <div operation>

stack: 6.375 <add operation>

Some other of the most used PostScript arithmetic operators are:

idiv - divide the bottom number by the top number but only keep the integer

mod - divide the bottom number by the top number but only keep the remainder

mul - multiply the top two numbers of the stack

neg - reverse the sign of the number at the top of the stack

Some other of the most used PostScript stack operators include:

exch - reverse the order of the top two elements of the stack

clear - removes all items from the stack

dup - duplicates the top item of the stack

pop - remove the top element from the stack MORE COMPLEX EXAMPLES

The following are some PostScript example programs selected to show the features of PostScript in action. As with any other language, the only way to learn it is to try it. In the examples below, as new PostScript keywords are encountered, they will be highlighted.

ex 1 - draw a vertical line:

This routine draws a simple vertical line.

newpath % empty the current path and start a new one

144 72 moveto % move to a new location

144 432 lineto % add a segment to the current path

stroke % paint the current path

showpage % print the current page

ex 2 - draw 2 intersecting lines:

This routine intersects a vertical line with a diagonal line.


72 360 moveto

144 72 rlineto % move using relative coordinates

144 432 moveto

0 -216 rlineto



ex 3 - draw a box:

The following routine draws a box with a line thickness value of 4. Since PostScript ignores the thickness of lines when drawing, the box will not be closed correctly.


270 360 moveto

0 72 rlineto

72 0 rlineto

0 -72 rlineto

-72 0 rlineto

4 setlinewidth



ex 4 - draw a better box:

This routine, almost identical to the previous one, draws a better box by using the 'closepath' operator. This causes the box to be closed properly and automatically by PostScript itself. Notice that the last line is derived by PostScript as opposed to having to be specified explicilty by the programmer.


270 360 moveto

0 72 rlineto

72 0 rlineto

0 -72 rlineto


4 setlinewidth


showpage % because of the 'closepath', the square is now closed

ex 5 - draw a filled box:

The following routine is a basic box drawing routine. The 'fill' command is used to demonstrate how PostScript will automatically fill in closed areas. The command 'setgray' is also used to show how PostScript can use different shades of gray. A value of 0 is black and 1 is white.


270 360 moveto

0 72 rlineto

72 0 rlineto

0 -72 rlineto


.85 setgray % set gray value to light gray

fill % this fills the box


ex 6 - variables:

Like most other languages, PostScript allows the program to use variables. In PostScript, however, variables must be defined and placed in a dictionary.

/ppi 72 def

- the / indicates that ppi is a literal and not yet in any dictionary

- the 72 is pushed onto the stack next

- the def takes the 2 objects off the stack and enters them into the current dictionary

The following arithmetic expression makes use of the value stored in ppi.

10 ppi mul stack: 10 72

stack: 720

This small program uses ppi to measure the length of lines. Recall that 72 points is equivalent to one inch.

newpath % draw a 1 inch vertical line

100 100 moveto

0 ppi rlineto



ex 7 - a procedure:

The following program uses a macro, inch, to measure lines. The code between the braces, "72 mul", is placed on the stack when the macro itself is called.

/inch {72 mul} def

newpath % draw a 5 inch vertical line

100 100 moveto

0 5 inch rlineto % causes the command: 5 72 mul



ex 8 - simple text:

PostScript can use any Type 1 font. There are literally thousands of fonts available for use so the best way to determine what fonts are available on a printer or other display device is to try to print them out.

/Times-Roman findfont % findfont looks up font in dictionary

% "FontDirectory" and places the

% appropriate dictionary on the stack

15 scalefont % takes a font dictionary from the stack

% and scales it according to the top number

% on the stack

setfont % take the scaled font dictionary off the

% stack and establish it as the current font

72 200 moveto

(type this) show % show prints a string (...)


ex 9 - arcs:

The 'arc' operator is used to draw any arcs and circles using 5 stack parameters which are:

- the X and Y locations for the centre of the circle

- the radius

- the start and end degrees (counterclockwise) of the circle for the arc

newpath % draw an arc from 45 to 90 degrees

100 150 36 45 90 arc


500 400 50 0 360 arc




PostScript contains numerous operators that allow users to create graphics. PostScript also contains features that allow for the easy manipulation of bitmaps. The image operator is used to perform these functions THE IMAGE OPERATOR

The image operator interprets the bits passed to it as a description of the gray values of a stream of pixels of from one to eight bits each. The results are printed in a one-unit square in which the lower left corner is at the origin. To view the image you must scale it to a viewable size since the default is 1/72 inch -- far to small to be really usable.

The image operator requires 5 arguments:

- scan length

- the number of samples per scan line

- scan lines

- the number of scan lines in the image

- bits per sample

- the number of bits making up the sample (1, 2, 4, or 8)

- an image with 1 bit sampling will print in black or white while an image with 8 bit sampling will print using the values 0 (black) through 255 (white)

- transform matrix

- the image operators impose a coordinate system on the source image:

where w is the width and h is the height

- other conventions (ie. user space) can be mapped into the PostScript convention (image space) by coordinate transformations

- a six element array that determines the mapping of samples into the one unit square imaging region

- for an image with scan length of n and scan lines of m, the following matrix is used: [ n 0 0 m 0 0 ]

- for an image whose data begins in the upper left corner as opposed to the lower left (PostScript's default), the following matrix may be used: [ n 0 0 -m 0 m ]

- for a more general definition of the transform matrix, please refer to Section 4.4 of the PostScript Language Reference Manual

- procedure

- this is the procedure that produces the data strings needed by image

- if the string does not describe the complete image, the image operator will call this procedure again and again until the number of samples implied by the first 3 arguments have been processed

- any unused data left in the string at the end of the image is ignored as are any bits left in the current character of data at the end of the scan line POSITION, ORIENTATION, AND SIZING

An image that has been mapped into the unit square may then be placed on the output page in the desired position, orientation, and size by invoking operations such as translate, rotate, and scale

ex: To place an image into a rectangle where the lower left corner is at (100,200), is rotated 45 degrees counterclockwise, and is 150 units wide and 80 high, one would execute the following prior to invoking the image operator:

100 200 translate 45 rotate 150 80 scale A BINARY IMAGE:

Consider the following 16 bit string: 1100100100110110

We can use the preceeding string in a PostScript program, such as in the following segment:

400 400 translate % position of lower left corner

72 72 scale % make the image 1 inch by 1 inch square

8 8 1 [8 0 0 8 0 0] {<c936>} image


- The third line prints an 8 pixel by 8 line image, each pixel being 1 bit deep.

- The transform matrix will fill the unit square with the image.

- The procedure argument encloses a hexadecimal string, denoted by the angle brackets:

- each pair of characters represents an 8 bit code, therefore c936 is interpreted as the 16 bit string listed above

- it is important to note that, by default, PostScript defines images with the origin in the lower left corner and where the higher numbers are lighter colours and the lower numbers are darker colours -- in this case, 1 is white and 0 is black

The above program produces a simple bitmap where, since each line of the image is eight one-bit samples wide, each call of the procedure will supply data for two lines producing an image something like:









By changing the bits per sample a different pattern is created -- recall that 1 bit per sample results in a black and white image, 2 bits produces shades of gray from 0 to 3, 4 bits produces shades from 0 to 15, and 8 produces from 0 to 255 CREATING AN IMAGE

PostScript images can be created in a number of different ways:

- generated by another program

- many programs generate output files in PostScript format -- PMDraw, Corel Draw, and Super Paint are some examples

- scanned in

- a user may decide to use a scanner to digitize an existing picture and store it as a PostScript bitmap

- created entirely by hand

- a user may also decide to generate a bitmap entirely by hand, for example, by using a pencil and some graph paper

ex: Suppose a raster image of 256 by 256, 8 bits per pixel is available -- one way to display it is:

/picstr 256 string def % string to hold image data

45 140 translate % lower left corner of image

132 132 scale % map image to 132 point scale

256 256 8 % dimensions of source image

[ 256 0 0 -256 0 256] % map the unit square to the

% source image

{ currentfile % read image data from the

% program file

picstr readhexstring pop

} image

4c 47 49 4b 4d 4c 52 4c 4d 50 53 ............

% 256 x 256 x2 hex digits of image data

% note: one 8-bit pixel is converted to two hex digits



In addition to the image manipulation described above, there are some others that may be of use:

- gsave

- save the current graphics state on a graphics state stack, which can hold up to 32 states including the current one

- grestore

- restores the most recently saved graphics state -- all the characteristics of the state including current path, gray level, line width, and user coordinate system are returned to what they were when gsave was executed

- X Y scale

- set the appropriate scaling factor for all subsequent operations

- currentpoint

- put the coordinates of the current location on the stack

- n { ... } repeat

- the repeat loop causes a procedure to be executed n times

- l m n { ... } for

- the for loop iterates a procedure from l to n by an increment (or decrement) value of m

- ( ... ) stringwidth

- stringwidth returns the length of the string ( ... ) and (usually) the value 0.0

ex: the following code will determine the width of a string and center it on some background that is 200 units wide

(PostScript) stringwidth pop

200 exch sub 2 div

0 rmoveto

(PostScript) show


A few sample images are stored on the U of R ftp site in the directory pub/405/PS. These images are contained in actual PostScript programs -- to incorporate them into your own programs, you will need to edit the images out. Some of the sample PostScript programs use the commands described above as well as other commands not described in this manual, so it would be beneficial to give them a view.

Other sample files are available in /net/share/lib/ghostscript/examples. To determine which fonts are available for use in GhostScript, you may want to look in the file /net/share/lib/ghostscript/Fontmap for a list of the correct font names. The directory /net/share/lib/ghostscript/doc also contains a number of very useful documentation files for GhostScript as well as for PostScript in general.

The two books "PostScript Language Tutorial and Cookbook" and "PostScript Language Reference Manual" are very good PostScript references published by Adobe Systems Incorporated.