path: root/src/graph/Gdraws/psFiles.pamphlet

\documentclass{article}
\usepackage{axiom}
\begin{document}
\title{\$SPAD/src/graph/Gdraws psFiles}
\author{Timothy Daly}
\maketitle
\begin{abstract}
\end{abstract}
\eject
\tableofcontents
\eject
\section{The postscript command definitions}
\subsection{colorpoly}
\begin{verbatim}
operand stack configuration in order to use psColorPoly:
	psFillPoly
	XPoint[0].y
	XPoint[0].x
	n
	...
	XPoint[n].y
	XPoint[n].x
	graphics-context dictionary
this draws a polygon by connecting all the points and fills the
region with foreground color
\end{verbatim}
<<colorpoly>>=
/psColorPoly
        {	gsave
                newpath
                yVal moveto
                1 sub {
                        yVal lineto
                } repeat
		closepath
		fill	%% fills with foreground color
                grestore }
        def

@
\subsection{colorwol}
\begin{verbatim}
operand stack configuration in order to use psDrawFilled:
	psFillwOL
	XPoint[0].y
	XPoint[0].x
	n
	...
	XPoint[n].y
	XPoint[n].x
	graphics-context dictionary
this draws lines connecting all the points and fills the
region with background color (default: 1, or white).
\end{verbatim}
<<colorwol>>=
/psColorwOutline
        {	gsave
                newpath
                yVal moveto
                1 sub {
                        yVal lineto
                } repeat
		closepath
		begin gsave fill grestore	%% fills with foreground color
		0 setgray stroke grestore end }	%% outline it with black
        def

@
\subsection{drawarc}
\begin{verbatim}
operand stack configuration in order to use psDrawArc:
	psDrawArc
	angle2
	angle1
	width
	height
	y
	x
	graphics-context dictionary
this draws an arc whose origin is at x, y, and whose width
and height specifies the rectangle which encases the arc.
Origin is at upper left corner of rectangle.
This function uses "scale" to make cricles and ellipses.
\end{verbatim}
<<drawarc>>=
/psDrawArc 
        {	gsave
                newpath
                /sfactor 4 index 4 index div def %% scale factor
                1 sfactor scale
                6 5 roll		 	%%      x on top of stack
                3 index 2 div add        	%% define x origin
                6 5 roll			%%      y on top of stack
                6 5 roll		 	%%      h on top of stack
                2 div add yVal sfactor div      %% define y origin
                5 4 roll		 	%%      w on top of stack
                2 div                           %% define radius
                5 3 roll		 	%%      a1 a2 on top of stack
                1 index add
                arcn                            %% draw clockwise arc
		begin installGC stroke end
		grestore }
        def

@
\subsection{drawcolor}
\begin{verbatim}
operand stack configuration in order to use psDrawColor:
	psDraw
	vlist[0].y
	vlist[0].x
	n
	...
	vlist[n].y
	vlist[n].x
	graphics-context dictionary
to draw lines connecting points in vlist[0] to vlist[n]
\end{verbatim}
<<drawcolor>>=
/psDrawColor
        {	gsave
                newpath
                yVal moveto		%% set currentpoint
                1 sub {			%% loop to draw lines.
                        yVal lineto
                } repeat
		stroke %% draw in foreground color
                grestore }
        def

@
\subsection{drawIstr}
\begin{verbatim}
operand stack configuration in order to use psDrawIStr:
	psDrawIStr
	window type: title or window
	string
	y
	x
	graphics-context dictionary
it draws a text string in foreground color on top of bounding box of
string, which is in background color.
\end{verbatim}
<<drawIstr>>=
/psDrawIStr
        {	gsave
		newpath					%% for rectangle
                loadFont

		/window exch def			%% get window type

                %% draw bounding box with background color
                /str exch def				%% get text string
                str stringwidth pop 1 sub               %% width
                FontHeight 1 sub                        %% height
                currentfont begin			%% get font height
                        FontBBox
                end
                /ypos exch def pop			%% define ypos
                neg ypos add /offset exch def pop
                /offset ypos offset div FontHeight mul def %% define offset
                /h exch def /w exch def			%% define h
                /y0 exch def				%% define y0
                /x0 exch def				%% define x0
                w h x0 y0 offset sub
		window (title) eq
		{hVal moveto drawRect}		       %% draws in title window
		{rectangle} ifelse		       %% draws in view window
		begin
                BGcolor setgray fill	%% set background box color

		x0 y0
		window (title) eq 
                {hVal}					%% print title text
                {yVal} ifelse				%% print window text
		moveto str 
                FGcolor setgray show			%% set text color
		end
                grestore }
        def

@
\subsection{drawline}
\begin{verbatim}
operand stack configuration in order to use psDrawLine:
	psDrawLine
	y0
	x0
	y1
	x1
	graphics-context dictionary
this draws a line from (x0, y0) to (x1, y1).
\end{verbatim}
<<drawline>>=
/psDrawLine
        {	gsave
                newpath
                yVal moveto
                yVal lineto
		begin installGC stroke end
		grestore }
        def

@
\subsection{drawlines}
\begin{verbatim}
operand stack configuration in order to use psDrawLines:
	psDrawLines
	points[0].y
	points[0].x
	n
	...
	points[n].y
	points[n].x
	graphics-context dictionary
this draws lines connecting all the points.
\end{verbatim}
<<drawlines>>=
/psDrawLines
        {	gsave
                newpath
                yVal moveto
                1 sub {
                        yVal lineto
                } repeat
		begin installGC stroke end
		grestore }
        def

@
\subsection{drawpoint}
\begin{verbatim}
operand stack configuration in order to use psDrawPoint:
	psDrawPoint
	y0
	x0
	graphics-context dictionary
this draws a point at (x0, y0).
\end{verbatim}
<<drawpoint>>=
/psDrawPoint
        {	gsave
                newpath
                yVal moveto
                yVal lineto
		begin installGC stroke end       %%fills with foreground color
		grestore }
        def

@
\subsection{draw}
\begin{verbatim}
operand stack configuration in order to use psDraw:
	psDraw
	vlist[0].y
	vlist[0].x
	n
	...
	vlist[n].y
	vlist[n].x
	graphics-context dictionary
to draw lines connecting points in vlist[0] to vlist[n]
\end{verbatim}
<<draw>>=
/psDraw
        {	gsave
                newpath
                yVal moveto		%% set currentpoint
                1 sub {			%% loop to draw lines.
                        yVal lineto
                } repeat
		begin installGC stroke end  %% draw in foreground color
                grestore }
        def

@
\subsection{drawrect}
\begin{verbatim}
operand stack configuration in order to use psDrawRect:
	psDrawRect
	y
	x
	height
	width
	graphics-context dictionary
this draws an outline of a rectangle whose origin is at (x,y) and is width
+ 1 wide and height + 1 tall.
\end{verbatim}
<<drawrect>>=
/psDrawRect
        {	gsave
                newpath
                rectangle
		begin installGC stroke end
		grestore }
        def

@
\subsection{drawstr}
\begin{verbatim}
operand stack configuration in order to use psDrawStr:
	psDrawStr
	y
	x
	string
	graphics-context dictionary
this function draws a text string at (x,y).
\end{verbatim}
<<drawstr>>=
/psDrawStr
        {	gsave
		newpath
                loadFont
                yVal moveto
		exch begin installGC show end
                grestore }
        def

@
\subsection{drwfilled}
\begin{verbatim}
operand stack configuration in order to use psDrawFilled:
	psDrawFilled
	vlist[0].y
	vlist[0].x
	n
	...
	vlist[n].y
	vlist[n].x
	graphics-context dictionary
this draws lines connecting all the points and fills the
region with background color (default: 1, or white).
\end{verbatim}
<<drwfilled>>=
/psDrawFilled
        {	gsave
                newpath
                yVal moveto
                1 sub {
                        yVal lineto
                } repeat
		begin installGC fill end	%% fills with foreground color
                grestore }
        def

@
\subsection{end}
\begin{verbatim}
\end{verbatim}
<<end>>=

   cleartomark					%% clearing operand stack

end		%% pops mainDict from dictionary stack

showpage

%-------------------------- end --------------------------%
@
\subsection{fillarc}
\begin{verbatim}
operand stack configuration in order to use psFillArc:
	psFillArc
	y center of rectangle
	x center of rectangle
	angle2
	angle1
	width
	height
	y
	x
	graphics-context dictionary
this draws and fills an arc whose origin is at x, y, and whose width
and height specifies the rectangle which encases the arc.
Origin is at upper left corner of rectangle.
This function uses "scale" to make cricles and ellipses.
\end{verbatim}
<<fillarc>>=
/psFillArc
        {	gsave
		yVal moveto
                newpath
                /sfactor 4 index 4 index div def
                1 sfactor scale
                6 5 roll			%%	 x on top of stack
                3 index 2 div add               %% define x origin
                6 5 roll			%%	 y on top of stack
                6 5 roll			%%	 h on top of stack
                2 div add yVal sfactor div      %% define y origin
                5 4 roll			%%	 w on top of stack
                2 div                           %% define radius
                5 3 roll			%%	 a1 a2 now on top
                1 index add
                arc                             %% draw clockwise arc
                begin installGC fill end	%% fills with foreground color
                grestore }
        def

@
\subsection{fillpoly}
\begin{verbatim}
operand stack configuration in order to use psDrawFilled:
	psFillPoly
	XPoint[0].y
	XPoint[0].x
	n
	...
	XPoint[n].y
	XPoint[n].x
	graphics-context dictionary
this draws a polygon by connecting all the points and fills the
region with foreground color
\end{verbatim}
<<fillpoly>>=
/psFillPoly
        {	gsave
                newpath
                yVal moveto
                1 sub {
                        yVal lineto
                } repeat
		closepath
		begin installGC fill end	%% fills with foreground color
                grestore }
        def

@
\subsection{fillwol}
\begin{verbatim}
operand stack configuration in order to use psDrawFilled:
	psFillwOL
	XPoint[0].y
	XPoint[0].x
	n
	...
	XPoint[n].y
	XPoint[n].x
	graphics-context dictionary
this draws lines connecting all the points and fills the
region with background color (default: 1, or white).
\end{verbatim}
<<fillwol>>=
/psFillwOutline
        {	gsave
                newpath
                yVal moveto
                1 sub {
                        yVal lineto
                } repeat
		closepath
		begin installGC
			gsave fill grestore	%% fills with foreground color
		0 setgray stroke grestore end }	%% outline it with black
        def

@
\subsection{header}
\begin{verbatim}
\end{verbatim}
<<header>>=
%!PS-Adobe-2.0
%%DocumentFonts: Times-Roman
%%Creator: AXIOM
%%CreationDate: today
%%Pages: 1
%%processing (hard) limit: 250 pts or 500 values for the operand stack.
%%EndComments

%------------------------------- prologue -------------------------------%
%-------------------------- support procedures --------------------------%

%--------- first create user dictionary with 100 entries max ------------%
%          (number can be changed to accomodate definitions)             %

100	dict	begin		%% using 100 entries in top level dictionary

/FontHeight     12 def

/inch
        {       72 mul }
        def

% yVal and hVal are necessary because the Xwindow display origin
% is at the upper left corner, while the postscript display
% origin is at the lower left hand corner.

/yVal		%% get Y value -- make upper left corner origin
        {       maxY exch sub  }	%% maxY is viewWindow height
        def

/hVal		%% get H value -- used for displaying title text
        {       maxH sub abs }	%% maxH is viewWindow height+titleWindow height
        def

% loads in the font

/loadFont
        {       /Times-Roman findfont FontHeight scalefont setfont }
        def

% draws a rectangle with input operand: 
%		height
%		width
% notice that this function does not "draw" or ink the rectangle.
/drawRect
	{	1 index 1 add 0 rlineto		%% draw first side
                0 exch 1 add neg rlineto	%% draw second side
                1 add neg 0 rlineto		%% draw third side
                closepath }			%% draw fourth side
        def

% create a rectangle with input operand in the view window: 
%		y
%		x
%		height
%		width
% notice that this function does not "draw" or ink the rectangle.
/rectangle
        {       yVal moveto			%% set currentpoint for line
		drawRect }			%% draws the rectangle
        def

% These are global variables that every draw procedure uses
% THe operand should be as follows:
%		viewWindow width
%		viewWindow height
%		title height
/setDim
        {       /maxX exch def			%% width of display
                /maxY exch def			%% height of display
		/titleH exch def		%% height of title
		/maxH maxY titleH add def	%% height of display + title
        } def

%-------------------------- major procedures --------------------------%

/title		%% draws a rectangle around the title of picture
	{	gsave
		newpath
		moveto				%% lower left of title
                titleH 1 add 0 exch rlineto	%% draw first side
                1 add 0 rlineto			%% draw second side
                1 add neg 0 exch rlineto
		begin installGC stroke end	%% draw third side
		grestore }
	def

/drawFrame      %% draw display frame
        {	gsave
                newpath
                maxX maxY 0 0 rectangle
		begin installGC stroke end
                grestore }
        def

% updates the foreground color of existing graphics-context dictionary:
%		foreground color
%		dictionary name
/setForeground
	{	/FGcolor exch put }
	def

% updates the background color of existing graphics-context dictionary:
%		background color
%		dictionary name
/setBackground
	{	/BGcolor exch put }
	def

% updates the line width, line style, cap style, join style of
% existing graphics-context dictionary:
%		dictionary name
%		join style
%		cap style
%		line width
/setLineAttributes
	{	begin
		/JoinStyle exch def
		/CapStyle  exch def
		/LineWidth exch def
		end }
	def

% creates a graphics context dictionary with the following information:
%		/dictionary name
%		foreground color
%		background color
%		line width
%		cap style
%		join style
% this creates different graphical contexts for different drawing functions.
/makeDict
	{	5 dict 2 copy def begin	pop %% with dict name on top of stack
		/FGcolor   exch def	%% define drawing attributes
		/BGcolor   exch def	%% not heavily used
		/LineWidth exch def
		/CapStyle  exch def
		/JoinStyle exch def
		end }
	def

% makes the current dictionary attributes effective
% this function takes the values in the current dictionary to set the context
% these are the values currently being used: foreground, cap, join, and width
/installGC
	{
		FGcolor currentgray ne
		{FGcolor setgray} if		%% foreground color
		CapStyle currentlinecap ne
		{CapStyle setlinecap} if	%% cap style
		JoinStyle currentlinejoin ne
		{JoinStyle setlinejoin} if	%% join style
		LineWidth currentlinewidth ne
		{LineWidth setlinewidth} if }	%% line width
	def

@
\subsection{setup}
\begin{verbatim}
\end{verbatim}
<<setup>>=
%-------------------------- script --------------------------%

% 1 inch 1 inch translate

   mark					%% mark bottom of our stack

@
<<*>>=
@
\eject
\begin{thebibliography}{99}
\bibitem{1} nothing
\end{thebibliography}
\end{document}