12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157 |
- /*
- *
- * 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 */
- /*****************************************************************************/
|