path: root/sys/src/cmd/postscript/postmd/postmd.c

/*
 *
 * postmd - matrix display program for PostScript printers.
 *
 * A simple program that can be used to display a matrix as a gray scale image on
 * a PostScript printer using the image operator. Much of the code was borrowed
 * from postdmd, the bitmap display program DMD screen dumps. May help if you have
 * a large matix (of floating point numbers) and want a simple way to look for
 * patterns.
 *
 * Matrix elements are a series of floating point numbers arranged in the input
 * file in row major order. The actual matrix elements can be preceeded by a simple
 * header that sets things like the matrix dimensions, interval list, and possibly
 * a window into the matrix that we'll use for display. The dimension statement is
 * perhaps the most important. If present it determines the number of rows and
 * columns in the matrix. For example, either of the following defines a 50x50
 * matrix,
 *
 *		dimension	50
 *		dimension	50x50
 *
 * If no dimension statement appears in the input file, the matrix is assumed to
 * be square, and the number of rows (and columns) is set to the square root of
 * the number of elements in the input file.
 *
 * Each matrix element is mapped into an integer in the range 0 to 255 (actually
 * 254) and PostScript's image operator then maps that number into a gray scale
 * appropriate for the particular printer. The mapping from the floating point
 * matrix elements to integers is accomplished using an interval list that can be
 * set using the -i option. The format of the interval string is,
 *
 *		num1,num2,num3,...,numn
 *
 * where each num is a floating point number. The list must be given in increasing
 * numerical order. A list of n numbers partitions the real line into 2n+1 regions
 * given as,
 *
 *		region1		element < num1
 *		region2		element = num1
 *		region3		element < num2
 *		region4		element = num2
 *		   .
 *		   .
 *		   .
 *		region2n	element = numn
 *		region2n+1	element > numn
 *
 * Every number in a region is mapped one integer in the range 0 to 254, and that
 * number, when displayed on a printer using the image operator, prints as a square
 * filled with a gray shade that reflects the integer that was chosen. 0 maps to
 * black and 255 maps to white (which by default will not be used).
 *
 * The default gray scale gets darker as the region number increases, but can be
 * changed by supplying a gray scale list with the -g option or in the optional
 * matrix header. The color map is again a comman or space separated list that
 * looks like,
 *
 *		color1,color2, ... ,color2n+1
 *
 * where color1 applies to region 1 and color2n+1 applies to region2n+1. Each
 * number in the list should be an integer between 0 and 255. If less than 2n+1
 * colors are given default assignments will be used for missing regions.
 *
 * The size of the matrix that we can display reasonably well is a function of the
 * number of elements in the interval list, paper size, and printer resolution.
 * For example a 300dpi printer using 8.5x11 inch paper gives us an image area of
 * about 2400x2400 pixels. An interval list of two numbers generates five separate
 * regions and will therefore need that many different shades of gray. Since we're
 * not using white we'll need to partion our image area into 4x4 pixel squares,
 * and that means a 600x600 matrix is about as big as we can go. In practice that's
 * optimistic, but the argument illustrates some of the limitations.
 *
 * A submatrix can be selected to display by windowing into the matrix. The window
 * list can be given using the -w option or can be set in the optional header that
 * can preceed each matrix.  The list should be a comma or space separated list
 * that looks like,
 *
 *		lower-column, lower-row, upper-column, upper-row
 *
 * where each element in the list must be a positive integer. Rows and columns in
 * the input matrix start at 1. The dimension of the displayed window will be from
 * lower-column to upper-column and from lower-row to upper-row inclusive.
 *
 * The encoding produced by the program is essentially identical to what's done
 * by postdmd. See the comments at the beginning of that program if you need more
 * details. The prologue also shares much of the same code. 
 *
 * The PostScript prologue is copied from *prologue before any of the input files
 * are translated. The program expects that the following PostScript procedures
 * are defined in that file:
 *
 *	setup
 *
 *	  mark ... setup -
 *
 *	    Handles special initialization stuff that depends on how this program
 *	    was called. Expects to find a mark followed by key/value pairs on the
 *	    stack. The def operator is applied to each pair up to the mark, then
 *	    the default state is set up.
 *
 *	pagesetup
 *
 *	  page pagesetup -
 *
 *	    Does whatever is needed to set things up for the next page. Expects
 *	    to find the current page number on the stack.
 *
 *	bitmap
 *
 *	  columns rows bitmap -
 *
 *	    Prints the image that's read as a hex string from standard input. The
 *	    image consists of rows lines, each of which includes columns elements.
 *	    Eight bits per pixel are used to encode the matrix elements.
 *
 *	labelmatrix
 *
 *	  matrixname matrixlimits labelmatrix -
 *
 *	    Prints string matrixname just below the lower left corner of the image
 *	    and prints string martixlimits near the lower right corner. Outlines
 *	    the entire image with a (one pixel wide) box and then draws tick marks
 *	    along the top and left sides of the image. One tick mark is printed
 *	    for every ten elements.
 *
 *	legend
 *
 *	  n1 ... nN N c1 m1 ... cM mM total regions legend -
 *
 *	    Prints the legend as a bar graph below the matrix image. n1 ... nN are
 *	    strings that represent the interval list. c1 m1 ... cm mM are pairs
 *	    that consist of a region's color and the statistics count. Actually
 *	    the c's are trivial procedures that just leave a one character string
 *	    on the stack when they're executed by image - which is the way the
 *	    bar graph is drawn.
 *
 *	done
 *
 *	  done
 *
 *	    Makes sure the last page is printed. Only needed when we're printing
 *	    more than one page on each sheet of paper.
 *
 * Many default values, like the magnification and orientation, are defined in 
 * the prologue, which is where they belong. If they're changed (by options), an
 * appropriate definition is made after the prologue is added to the output file.
 * The -P option passes arbitrary PostScript through to the output file. Among
 * other things it can be used to set (or change) values that can't be accessed by
 * other options.
 *
 */

#include <stdio.h>
#include <signal.h>
#include <ctype.h>
#ifdef plan9
#define	isascii(c)	((unsigned char)(c)<=0177)
#endif
#include <sys/types.h>
#include <fcntl.h>
#include <string.h>

#include "comments.h"			/* PostScript file structuring comments */
#include "gen.h"			/* general purpose definitions */
#include "path.h"			/* for the prologue */
#include "ext.h"			/* external variable declarations */
#include "postmd.h"			/* special matrix display definitions */

char	*optnames = "a:b:c:d:g:i:m:n:o:p:w:x:y:A:C:E:J:L:P:R:DI";

char	*prologue = POSTMD;		/* default PostScript prologue */
char	*formfile = FORMFILE;		/* stuff for multiple pages per sheet */
char	*temp_dir = TEMPDIR;		/* temp directory for copying stdin */

int	formsperpage = 1;		/* page images on each piece of paper */
int	copies = 1;			/* and this many copies of each sheet */
int	bytespp = 6;			/* bytes per pattern - on output */

int	dostats = ON;			/* permanent statistics flag */
int	nxtstat = ON;			/* and the one for the next matrix */

char	*interval = DFLTILIST;		/* string representations of the interval */
char	*colormap = NULL;		/* color map */
char	*window = NULL;			/* and window lists */
char	*matrixname = "pipe.end";	/* name for the next plot */

Ilist	ilist[128];			/* active interval list and color map */
int	next = 0;			/* one past the last element in ilist[] */
int	regions;			/* an index assigned to the last region */
int	wlist[4];			/* upper left and lower right corners */

int	page = 0;			/* last page we worked on */
int	printed = 0;			/* and the number of pages printed */

int	dfltrows = 0;			/* default rows */
int	dfltcols = 0;			/* and columns - changed by -d option */
int	rows;				/* real number of rows */
int	columns;			/* and columns in the matrix */
int	patcount = 0;			/* will be set to columns * rows */

double	element;			/* next matrix element */

char	*raster = NULL;			/* next raster line */
char	*rptr;				/* next free byte in raster */
char	*eptr;				/* one past the last byte in raster */

FILE	*fp_in = stdin;			/* read from this file */
FILE	*fp_out = stdout;		/* and write stuff here */
FILE	*fp_acct = NULL;		/* for accounting data */

/*****************************************************************************/

main(agc, agv)

    int		agc;
    char	*agv[];

{

/*
 *
 * Bitmap display program for matrices. Only one matrix is allowed per input file,
 * and each one will be displayed on a page by itself. Input files consist of an
 * optional header followed by floating point numbers that represent the matrix
 * elements - in row major order.
 *
 */

    argc = agc;				/* other routines may want them */
    argv = agv;

    prog_name = argv[0];		/* really just for error messages */

    init_signals();			/* sets up interrupt handling */
    header();				/* PostScript header comments */
    options();				/* handle the command line options */
    setup();				/* for PostScript */
    arguments();			/* followed by each input file */
    done();				/* print the last page etc. */
    account();				/* job accounting data */

    exit(x_stat);			/* not much could be wrong */

}   /* End of main */

/*****************************************************************************/

init_signals()

{

/*
 *
 * Make sure we handle interrupts.
 *
 */

    if ( signal(SIGINT, interrupt) == SIG_IGN )  {
	signal(SIGINT, SIG_IGN);
	signal(SIGQUIT, SIG_IGN);
	signal(SIGHUP, SIG_IGN);
    } else {
	signal(SIGHUP, interrupt);
	signal(SIGQUIT, interrupt);
    }   /* End else */

    signal(SIGTERM, interrupt);
    signal(SIGFPE, interrupt);

}   /* End of init_signals */

/*****************************************************************************/

header()

{

    int		ch;			/* return value from getopt() */
    int		old_optind = optind;	/* for restoring optind - should be 1 */

/*
 *
 * Scans the option list looking for things, like the prologue file, that we need
 * right away but could be changed from the default. Doing things this way is an
 * attempt to conform to Adobe's latest file structuring conventions. In particular
 * they now say there should be nothing executed in the prologue, and they have
 * added two new comments that delimit global initialization calls. Once we know
 * where things really are we write out the job header, follow it by the prologue,
 * and then add the ENDPROLOG and BEGINSETUP comments.
 *
 */

    while ( (ch = getopt(argc, argv, optnames)) != EOF )
	if ( ch == 'L' )
	    prologue = optarg;
	else if ( ch == '?' )
	    error(FATAL, "");

    optind = old_optind;		/* get ready for option scanning */

    fprintf(stdout, "%s", CONFORMING);
    fprintf(stdout, "%s %s\n", VERSION, PROGRAMVERSION);
    fprintf(stdout, "%s %s\n", DOCUMENTFONTS, ATEND);
    fprintf(stdout, "%s %s\n", PAGES, ATEND);
    fprintf(stdout, "%s", ENDCOMMENTS);

    if ( cat(prologue) == FALSE )
	error(FATAL, "can't read %s", prologue);

    fprintf(stdout, "%s", ENDPROLOG);
    fprintf(stdout, "%s", BEGINSETUP);
    fprintf(stdout, "mark\n");

}   /* End of header */

/*****************************************************************************/

options()

{

    int		ch;			/* return value from getopt() */

/*
 *
 * Reads and processes the command line options. Added the -P option so arbitrary
 * PostScript code can be passed through. Expect it could be useful for changing
 * definitions in the prologue for which options have not been defined.
 *
 */

    while ( (ch = getopt(argc, argv, optnames)) != EOF )  {
	switch ( ch )  {
	    case 'a':			/* aspect ratio */
		    fprintf(stdout, "/aspectratio %s def\n", optarg);
		    break;

	    case 'b':			/* bytes per pattern - on output */
		    bytespp = atoi(optarg);
		    break;

	    case 'c':			/* copies */
		    copies = atoi(optarg);
		    fprintf(stdout, "/#copies %s store\n", optarg);
		    break;

	    case 'd':			/* default matrix dimensions */
		    sscanf(optarg, "%dx%d", &dfltrows, &dfltcols);
		    break;

	    case 'g':			/* set the colormap (ie. grayscale) */
		    colormap = optarg;
		    break;

	    case 'i':			/* matrix element interval list */
		    interval = optarg;
		    break;

	    case 'm':			/* magnification */
		    fprintf(stdout, "/magnification %s def\n", optarg);
		    break;

	    case 'n':			/* forms per page */
		    formsperpage = atoi(optarg);
		    fprintf(stdout, "%s %s\n", FORMSPERPAGE, optarg);
		    fprintf(stdout, "/formsperpage %s def\n", optarg);
		    break;

	    case 'o':			/* output page list */
		    out_list(optarg);
		    break;

	    case 'p':			/* landscape or portrait mode */
		    if ( *optarg == 'l' )
			fprintf(stdout, "/landscape true def\n");
		    else fprintf(stdout, "/landscape false def\n");
		    break;

	    case 'w':			/* set the window */
		    window = optarg;
		    break;

	    case 'x':			/* shift things horizontally */
		    fprintf(stdout, "/xoffset %s def\n", optarg);
		    break;

	    case 'y':			/* and vertically on the page */
		    fprintf(stdout, "/yoffset %s def\n", optarg);
		    break;

	    case 'A':			/* force job accounting */
	    case 'J':
		    if ( (fp_acct = fopen(optarg, "a")) == NULL )
			error(FATAL, "can't open accounting file %s", optarg);
		    break;

	    case 'C':			/* copy file straight to output */
		    if ( cat(optarg) == FALSE )
			error(FATAL, "can't read %s", optarg);
		    break;

	    case 'E':			/* text font encoding */
		    fontencoding = optarg;
		    break;

	    case 'L':			/* PostScript prologue file */
		    prologue = optarg;
		    break;

	    case 'P':			/* PostScript pass through */
		    fprintf(stdout, "%s\n", optarg);
		    break;

	    case 'R':			/* special global or page level request */
		    saverequest(optarg);
		    break;

	    case 'D':			/* debug flag */
		    debug = ON;
		    break;

	    case 'I':			/* ignore FATAL errors */
		    ignore = ON;
		    break;

	    case '?':			/* don't understand the option */
		    error(FATAL, "");
		    break;

	    default:			/* don't know what to do for ch */
		    error(FATAL, "missing case for option %c\n", ch);
		    break;
	}   /* End switch */
    }   /* End while */

    argc -= optind;			/* get ready for non-option args */
    argv += optind;

}   /* End of options */

/*****************************************************************************/

setup()

{

/*
 *
 * Handles things that must be done after the options are read but before the
 * input files are processed.
 *
 */

    writerequest(0, stdout);		/* global requests eg. manual feed */
    setencoding(fontencoding);
    fprintf(stdout, "setup\n");

    if ( formsperpage > 1 )  {
	if ( cat(formfile) == FALSE )
	    error(FATAL, "can't read %s", formfile);
	fprintf(stdout, "%d setupforms\n", formsperpage);
    }	/* End if */

    fprintf(stdout, "%s", ENDSETUP);

}   /* End of setup */

/*****************************************************************************/

arguments()

{

/*
 *
 * Makes sure all the non-option command line arguments are processed. If we get
 * here and there aren't any arguments left, or if '-' is one of the input files
 * we'll process stdin.
 *
 */

    if ( argc < 1 )
	matrix();
    else  {				/* at least one argument is left */
	while ( argc > 0 )  {
	    matrixname = *argv;
	    if ( strcmp(*argv, "-") == 0 )  {
		fp_in = stdin;
		matrixname = "pipe.end";
	    } else if ( (fp_in = fopen(*argv, "r")) == NULL )
		error(FATAL, "can't open %s", *argv);
	    matrix();
	    if ( fp_in != stdin )
		fclose(fp_in);
	    argc--;
	    argv++;
	}   /* End while */
    }   /* End else */

}   /* End of arguments */

/*****************************************************************************/

done()

{

/*
 *
 * Finished with all the input files, so mark the end of the pages, make sure the
 * last page is printed, and restore the initial environment.
 *
 */

    fprintf(stdout, "%s", TRAILER);
    fprintf(stdout, "done\n");
    fprintf(stdout, "%s %d\n", PAGES, printed);

    if ( temp_file != NULL )
	unlink(temp_file);

}   /* End of done */

/*****************************************************************************/

account()

{

/*
 *
 * Writes an accounting record to *fp_acct provided it's not NULL. Accounting
 * is requested using the -A or -J options.
 *
 */

    if ( fp_acct != NULL )
	fprintf(fp_acct, " print %d\n copies %d\n", printed, copies);

}   /* End of account */

/*****************************************************************************/

matrix()

{

    int		count;			/* pattern repeats this many times */
    long	total;			/* expect this many patterns */

/*
 *
 * Reads a matrix from *fp_in, translates it into a PostScript gray scale image,
 * and writes the result on stdout. For now only one matrix is allowed per input
 * file. Matrix elements are floating point numbers arranged in row major order
 * in the input file. In addition each input file may contain an optional header
 * that defines special things like the dimension of the matrix, a window into
 * the matrix that will be displayed, and an interval list.
 *
 * If we're reading from stdin we first make a copy in a temporary file so we can
 * can properly position ourselves after we've looked for the header. Originally
 * wasn't always making a copy of stdin, but I've added a few things to what's
 * accepted in the header and this simplifies the job. An alternative would be
 * to always require a header and mark the end of it by some string. Didn't like
 * that approach much - may fix things up later.
 *
 */

    if ( fp_in == stdin )		/* make a copy so we can seek etc. */
	copystdin();

    rows = dfltrows;			/* new dimensions for the next matrix */
    columns = dfltcols;

    buildilist(interval);		/* build the default ilist[] */
    addcolormap(colormap);		/* add the colormap - if not NULL */
    setwindow(window);			/* and setup the initial matrix window */
    nxtstat = dostats;			/* want statistics? */
    getheader();			/* matrix dimensions at the very least */
    dimensions();			/* make sure we have the dimensions etc. */

    patcount = 0;
    total = rows * columns;

    eptr = rptr + (wlist[2] - wlist[0] + 1);

    redirect(++page);

    fprintf(fp_out, "%s %d %d\n", PAGE, page, printed+1);
    fprintf(fp_out, "/saveobj save def\n");
    writerequest(printed+1, fp_out);
    fprintf(fp_out, "%d %d bitmap\n", wlist[2] - wlist[0] + 1, wlist[3] - wlist[1] + 1);

    while ( patcount != total && fscanf(fp_in, "%f", &element) != EOF )  {
	if ( inwindow() ) *rptr++ = mapfloat(element);
	if ( ++patcount % columns == 0 )
	    if ( inrange() )
		putrow();
    }	/* End while */

    if ( total != patcount )
	error(FATAL, "matrix format error");

    labelmatrix();

    if ( fp_out == stdout ) printed++;

    fprintf(fp_out, "showpage\n");
    fprintf(fp_out, "saveobj restore\n");
    fprintf(fp_out, "%s %d %d\n", ENDPAGE, page, printed);

}   /* End of matrix */

/*****************************************************************************/

copystdin()

{

    int		fd_out;			/* for the temporary file */
    int		fd_in;			/* for stdin */
    int		buf[512];		/* buffer for reads and writes */
    int		count;			/* number of bytes put in buf */

/*
 *
 * If we're reading the matrix from stdin and the matrix dimension isn't set by
 * a dimension statement at the beginning of the file we'll copy stdin to a
 * temporary file and reset *fp_in so reads come from the temp file. Simplifies
 * reading the header (if present), but is expensive.
 *
 */

    if ( temp_file != NULL )		/* been here already */
	unlink(temp_file);

    if ( (temp_file = tempnam(temp_dir, "post")) == NULL )
	error(FATAL, "can't generate temp file name");

    if ( (fd_out = creat(temp_file, 0660)) == -1 )
	error(FATAL, "can't create %s", temp_file);

    fd_in = fileno(stdin);

    while ( (count = read(fd_in, buf, sizeof(buf))) > 0 )
	if ( write(fd_out, buf, count) != count )
	    error(FATAL, "error writing to %s", temp_file);

    close(fd_out);

    if ( (fp_in = fopen(temp_file, "r")) == NULL )
	error(FATAL, "can't open %s", temp_file);

}   /* End of copystdin */

/*****************************************************************************/

getheader()

{

    char	buf[512];		/* temporary string space */
    char	*cmap = NULL;		/* remember header colormap list */
    long	pos;			/* for seeking back to first element */

/*
 *
 * Looks for the optional header information at the beginning of the input file,
 * reads it if it's there, and sets *fp_in to be just past the header. That should
 * be the beginning of the matrix element list. The recognized header keywords are
 * dimension, interval, colormap (or grayscale), window, name, and statistics. All
 * are optional, but may be useful in a spooling environment when the user doesn't
 * doesn't actually run the translator.
 *
 * The dimension statement specifies the number of rows and columns. For example
 * either of the following two lines define a 50 by 50 element matrix,
 *
 *	dimension	50
 *	dimension	50x50
 *
 * The first integer is the number of rows and the second, if given, is the number
 * of columns. If columns are missing from the dimension statement we assume the
 * matrix is square.
 *
 * interval can be used to redefine the interval list used for mapping floating
 * point numbers into integers in the range 0 to 254. The string following the
 * interval keyword has the same format as the -i option. For example to set the
 * interval list to -1, 0, and 1 you can add the line,
 *
 *	interval	-1,0,1
 *
 * The numbers are floats given in increasing order, and separated by commas or
 * blanks. The last interval list in a header takes precedence.
 *
 * colormap can be used to redefine the grayscale list.  The string following
 * the colormap keyword has the same format as the -g option.  For example
 *
 *	colormap	0,50,100,150,200,250
 * or	grayscale	0,50,100,150,200,250
 *
 * The window keyword can be used to select a submatrix. The numbers following
 * window are the upper left and lower right matix coordinates. May not be
 * implemented yet but shouldn't be difficult. For example
 *
 *	window		10 10 40 40
 *
 * selects the submatrix with corners at (10, 10) and (40, 40). The edges of the
 * window are included in the display.
 *
 * The name keyword can be used to define the title of the display.  For example,
 *
 *	name		Plot Of Matrix 1
 *
 * prints the string "Plot Of Matrix 1" at the top of the page. Everything up to
 * the next newline is taken as the name string.
 *
 */

    pos = ftell(fp_in);

    while ( fscanf(fp_in, "%s", buf) != EOF )  {
	if ( strncmp(buf, "dimension", strlen("dimension")) == 0 )
	    fscanf(fp_in, "%dx%d", &rows, &columns);
	else if ( strncmp(buf, "window", strlen("window")) == 0 )  {
	    fgets(buf, sizeof(buf), fp_in);
	    setwindow(buf);
	} else if ( strncmp(buf, "name", strlen("name")) == 0 )  {
	    fgets(buf, sizeof(buf), fp_in);
	    matrixname = savestring(buf);
	} else if ( strncmp(buf, "colormap", strlen("colormap")) == 0 )  {
	    fgets(buf, sizeof(buf), fp_in);
	    cmap = savestring(buf);
	} else if ( strncmp(buf, "grayscale", strlen("grayscale")) == 0 )  {
	    fgets(buf, sizeof(buf), fp_in);
	    cmap = savestring(buf);
	} else if ( strncmp(buf, "interval", strlen("interval")) == 0 )  {
	    fgets(buf, sizeof(buf), fp_in);
	    buildilist(buf);
	} else if ( strncmp(buf, "statistics", strlen("statistics")) == 0 )  {
	    fscanf(fp_in, "%s", buf);
	    if ( strcmp(buf, "on") == 0 || strcmp(buf, "ON") == 0 )
		nxtstat = ON;
	    else nxtstat = OFF;
	} else break;
	pos = ftell(fp_in);
    }	/* End while */

    addcolormap(cmap);			/* must happen last */
    fseek(fp_in, pos, 0);		/* back to the start of the matrix */

}   /* End of getheader */

/*****************************************************************************/

dimensions()

{

    char	buf[100];		/* temporary storage for the elements */
    long	count = 0;		/* number of elements in the matrix */
    long	pos;			/* matrix elements start here */

/*
 *
 * Need to know the dimensions of the matrix before we can go any farther. If
 * rows and columns are still 0 we'll read the entire input file, starting from
 * the current position, count the number of elements, take the square root of it,
 * and use it as the number of rows and columns. Then we seek back to the start
 * of the real matrix, make sure columns is set, and allocate enough memory for
 * storing each raster line. After we're certain we've got the number of rows and
 * columns we check the window coordinates, and if they're not legitimate they're
 * reset to cover the entire matrix.
 *
 */

    if ( rows == 0 )  {
	pos = ftell(fp_in);
	while ( fscanf(fp_in, "%s", buf) != EOF )
	    count++;
	rows = sqrt((double) count);
	fseek(fp_in, pos, 0);
    }	/* End if */

    if ( columns <= 0 ) columns = rows;

    if ( raster != NULL ) free(raster);

    if ( (rptr = raster = malloc(columns)) == NULL )
	error(FATAL, "no memory");

    eptr = rptr + columns;

    if ( rows <= 0 || columns <= 0 )
	error(FATAL, "bad matrix dimensions");

    if ( wlist[0] > wlist[2] || wlist[1] > wlist[3] )  {
	wlist[0] = wlist[1] = 1;
	wlist[2] = columns;
	wlist[3] = rows;
    }	/* End if */

}   /* End of dimensions */

/*****************************************************************************/

buildilist(list)

    char	*list;			/* use this as the interval list */

{

    static char	*templist = NULL;	/* a working copy of the list */
    char	*ptr;			/* next number in *templist */
    int		i;			/* loop index - for checking the list */

/*
 *
 * Reads string *list and builds up the ilist[] that will be used in the next
 * matrix. Since strtok() modifies the string it's parsing we make a copy first.
 * The format of the interval list is described in detail in the comments at the
 * beginning of this program. Basically consists of a comma or space separated
 * list of floating point numbers that must be given in increasing numerical order.
 * The list determines how floating point numbers are mapped into integers in the
 * range 0 to 254.
 *
 */

    if ( templist != NULL )		/* free the space used by the last list */
	free(templist);

    while ( isascii(*list) && isspace(*list) )
	list++;

    for ( ptr = list, regions = 3; *ptr != '\0'; ptr++ )  {
	if ( *ptr == ',' || *ptr == '/' || isspace(*ptr) )
	    regions += 2;
	while ( isascii(*ptr) && isspace(*ptr) ) ptr++;
    }	/* End for */

    next = 0;
    templist = savestring(list);

    ptr = strtok(templist, ",/ \t\n");
    while ( ptr != NULL )  {
	ilist[next].count = 0;
	ilist[next++].color = 254 * (regions - 1 - next) / (regions - 1);
	ilist[next].val = atof(ptr);
	ilist[next].count = 0;
	ilist[next++].color = 254 * (regions - 1 - next) / (regions - 1);
	ptr = strtok(NULL, ",/ \t\n");
    }	/* End while */

    ilist[next].count = 0;
    ilist[next].color = 254 * (regions - 1 - next) / (regions - 1);

    if ( next == 0 )			/* make sure we have a list */
	error(FATAL, "missing interval list");

    for ( i = 3; i < next; i += 2 )	/* that's in increasing numerical order */
	if ( ilist[i].val <= ilist[i-2].val )
	    error(FATAL, "bad interval list");

}   /* End of buildilist */

/*****************************************************************************/

addcolormap(list)

    char	*list;			/* use this color map */

{

    static char	*templist = NULL;	/* a working copy of the color list */
    char	*ptr;			/* next color in *templist */
    int		i = 0;			/* assigned to this region in ilist[] */

/*
 *
 * Assigns the integers in *list to the color field for the regions defined in
 * ilist[]. Assumes ilist[] has already been setup.
 *
 */

    if ( list != NULL )  {
	if ( templist != NULL )
	    free(templist);
	templist = savestring(list);

	ptr = strtok(templist, ",/ \t\n");
	while ( ptr != NULL )  {
	    ilist[i++].color = atoi(ptr) % 256;
	    ptr = strtok(NULL, ",/ \t\n");
	}   /* End while */
    }	/* End if */

}   /* End of addcolormap */

/*****************************************************************************/

setwindow(list)

    char	*list;			/* corners of window into the matrix */

{

    static char	*templist = NULL;	/* a working copy of the window list */
    char	*ptr;			/* next window coordinate in *templist */
    int		i = 0;			/* assigned to this region in wlist[] */

/*
 *
 * Sets up an optional window into the matrix.
 *
 */

    wlist[0] = wlist[1] = 1;
    wlist[2] = wlist[3] = 0;

    if ( list != NULL )  {
	if ( templist != NULL )
	    free(templist);
	templist = savestring(list);

	ptr = strtok(templist, ",/ \t\n");
	while ( ptr != NULL )  {
	    wlist[i++] = atoi(ptr);
	    ptr = strtok(NULL, ",/ \t\n");
	}   /* End while */
    }	/* End if */

}   /* End of setwindow */

/*****************************************************************************/

inwindow()

{

    int		r;			/* row of the patcount element */
    int		c;			/* column of the patcount element */

/*
 *
 * Checks if the patcount element of the matrix is in the window.
 *
 */

    r = (patcount/columns) + 1;
    c = (patcount%columns) + 1;

    return((c >= wlist[0]) && (r >= wlist[1]) && (c <= wlist[2]) && (r <= wlist[3]));

}   /* End of inwindow */

/*****************************************************************************/

inrange()

{

/*
 *
 * Checks if the current row lies in the window. Used right before we output the
 * raster lines.
 *
 */

    return(((patcount/columns) >= wlist[1]) && ((patcount/columns) <= wlist[3]));

}   /* End of inrange */

/*****************************************************************************/

mapfloat(element)

    double	element;		/* floating point matrix element */

{

    int		i;			/* loop index */

/*
 *
 * Maps element into an integer in the range 0 to 255, and returns the result to
 * the caller. Mapping is done using the color map that was saved in ilist[]. Also
 * updates the count field for the region that contains element - not good!
 *
 */

    for ( i = 1; i < next && ilist[i].val < element; i += 2 ) ;

    if ( i > next || element < ilist[i].val )
	i--;

    ilist[i].count++;
    return(ilist[i].color);

}   /* End of mapfloat */

/*****************************************************************************/

putrow()

{

    char	*p1, *p2;		/* starting and ending columns */
    int		n;			/* set to bytes per pattern */
    int		i;			/* loop index */

/*
 *
 * Takes the scanline that's been saved in *raster, encodes it according to the
 * value that's been assigned to bytespp, and writes the result to *fp_out. Each
 * line in the output bitmap is terminated by a 0 on a line by itself.
 *
 */

    n = (bytespp <= 0) ? columns : bytespp;

    for ( p1 = raster, p2 = raster + n; p1 < eptr; p1 = p2 )
	if ( patncmp(p1, n) == TRUE )  {
	    while ( patncmp(p2, n) == TRUE ) p2 += n;
	    p2 += n;
	    fprintf(fp_out, "%d ", n);
	    for ( i = 0; i < n; i++, p1++ )
		fprintf(fp_out, "%.2X", ((int) *p1) & 0377);
	    fprintf(fp_out, " %d\n", (p2 - p1) / n);
	} else {
	    while ( p2 < eptr && patncmp(p2, n) == FALSE ) p2 += n;
	    if ( p2 > eptr ) p2 = eptr;
	    fprintf(fp_out, "%d ", p2 - p1);
	    while ( p1 < p2 )
		fprintf(fp_out, "%.2X", ((int) *p1++) & 0377);
	    fprintf(fp_out, " 0\n");
	}   /* End else */

    fprintf(fp_out, "0\n");

    rptr = raster;

}   /* End of putrow */

/*****************************************************************************/

labelmatrix()

{

    int		total;			/* number of elements in the window */
    int		i;			/* loop index */

/*
 *
 * Responsible for generating the PostScript calls that label the matrix, generate
 * the legend, and print the matrix name.
 *
 */

    fprintf(fp_out, "(%s) ((%d, %d) to (%d, %d)) labelmatrix\n", matrixname,
			wlist[0], wlist[1], wlist[2], wlist[3]);

    total = (wlist[2] - wlist[0] + 1) * (wlist[3] - wlist[1] + 1);

    if ( nxtstat == OFF )
	for ( i = 0; i < regions; i++ )
	    ilist[i].count = 0;

    for ( i = 1; i < next; i += 2 )
	fprintf(fp_out, "(%g) ", ilist[i].val);
    fprintf(fp_out, "%d ", (regions - 1) / 2);

    for ( i = regions - 1; i >= 0; i-- )
	fprintf(fp_out, "{(\\%.3o)} %d ", ilist[i].color, ilist[i].count);
    fprintf(fp_out, "%d %d legend\n", total, regions);

}   /* End of labelmatrix */

/*****************************************************************************/

patncmp(p1, n)

    char	*p1;			/* first patterns starts here */
    int		n;			/* and extends this many bytes */

{

    char	*p2;			/* address of the second pattern */

/*
 *
 * Compares the two n byte patterns *p1 and *(p1+n). FALSE if returned is they're
 * different or extend past the end of the current raster line.
 *
 */

    p2 = p1 + n;

    for ( ; n > 0; n--, p1++, p2++ )
	if ( p2 >= eptr || *p1 != *p2 )
	    return(FALSE);

    return(TRUE);

}   /* End of patncmp */

/*****************************************************************************/

char *savestring(str)

    char	*str;			/* save this string */

{

    char	*ptr = NULL;		/* at this address */

/*
 *
 * Copies string *str to a permanent place and returns the address to the caller.
 *
 */

    if ( str != NULL && *str != '\0' )  {
	if ( (ptr = malloc(strlen(str) + 1)) == NULL )
	    error(FATAL, "no memory available for string %s", str);
	strcpy(ptr, str);
    }	/* End if */

    return(ptr);

}   /* End of savestring */

/*****************************************************************************/

redirect(pg)

    int		pg;			/* next page we're printing */

{

    static FILE	*fp_null = NULL;	/* if output is turned off */

/*
 *
 * If we're not supposed to print page pg, fp_out will be directed to /dev/null,
 * otherwise output goes to stdout.
 *
 */

    if ( pg >= 0 && in_olist(pg) == ON )
	fp_out = stdout;
    else if ( (fp_out = fp_null) == NULL )
	fp_out = fp_null = fopen("/dev/null", "w");

}   /* End of redirect */

/*****************************************************************************/