1 /*
2 *
3 * postmd - matrix display program for PostScript printers.
4 *
5 * A simple program that can be used to display a matrix as a gray scale image on
6 * a PostScript printer using the image operator. Much of the code was borrowed
7 * from postdmd, the bitmap display program DMD screen dumps. May help if you have
8 * a large matix (of floating point numbers) and want a simple way to look for
9 * patterns.
10 *
11 * Matrix elements are a series of floating point numbers arranged in the input
12 * file in row major order. The actual matrix elements can be preceeded by a simple
13 * header that sets things like the matrix dimensions, interval list, and possibly
14 * a window into the matrix that we'll use for display. The dimension statement is
15 * perhaps the most important. If present it determines the number of rows and
16 * columns in the matrix. For example, either of the following defines a 50x50
17 * matrix,
18 *
19 * dimension 50
20 * dimension 50x50
21 *
22 * If no dimension statement appears in the input file, the matrix is assumed to
23 * be square, and the number of rows (and columns) is set to the square root of
24 * the number of elements in the input file.
25 *
26 * Each matrix element is mapped into an integer in the range 0 to 255 (actually
27 * 254) and PostScript's image operator then maps that number into a gray scale
28 * appropriate for the particular printer. The mapping from the floating point
29 * matrix elements to integers is accomplished using an interval list that can be
30 * set using the -i option. The format of the interval string is,
31 *
32 * num1,num2,num3,...,numn
33 *
34 * where each num is a floating point number. The list must be given in increasing
35 * numerical order. A list of n numbers partitions the real line into 2n+1 regions
36 * given as,
37 *
38 * region1 element < num1
39 * region2 element = num1
40 * region3 element < num2
41 * region4 element = num2
42 * .
43 * .
44 * .
45 * region2n element = numn
46 * region2n+1 element > numn
47 *
48 * Every number in a region is mapped one integer in the range 0 to 254, and that
49 * number, when displayed on a printer using the image operator, prints as a square
50 * filled with a gray shade that reflects the integer that was chosen. 0 maps to
51 * black and 255 maps to white (which by default will not be used).
52 *
53 * The default gray scale gets darker as the region number increases, but can be
54 * changed by supplying a gray scale list with the -g option or in the optional
55 * matrix header. The color map is again a comman or space separated list that
56 * looks like,
57 *
58 * color1,color2, ... ,color2n+1
59 *
60 * where color1 applies to region 1 and color2n+1 applies to region2n+1. Each
61 * number in the list should be an integer between 0 and 255. If less than 2n+1
62 * colors are given default assignments will be used for missing regions.
63 *
64 * The size of the matrix that we can display reasonably well is a function of the
65 * number of elements in the interval list, paper size, and printer resolution.
66 * For example a 300dpi printer using 8.5x11 inch paper gives us an image area of
67 * about 2400x2400 pixels. An interval list of two numbers generates five separate
68 * regions and will therefore need that many different shades of gray. Since we're
69 * not using white we'll need to partion our image area into 4x4 pixel squares,
70 * and that means a 600x600 matrix is about as big as we can go. In practice that's
71 * optimistic, but the argument illustrates some of the limitations.
72 *
73 * A submatrix can be selected to display by windowing into the matrix. The window
74 * list can be given using the -w option or can be set in the optional header that
75 * can preceed each matrix. The list should be a comma or space separated list
76 * that looks like,
77 *
78 * lower-column, lower-row, upper-column, upper-row
79 *
80 * where each element in the list must be a positive integer. Rows and columns in
81 * the input matrix start at 1. The dimension of the displayed window will be from
82 * lower-column to upper-column and from lower-row to upper-row inclusive.
83 *
84 * The encoding produced by the program is essentially identical to what's done
85 * by postdmd. See the comments at the beginning of that program if you need more
86 * details. The prologue also shares much of the same code.
87 *
88 * The PostScript prologue is copied from *prologue before any of the input files
89 * are translated. The program expects that the following PostScript procedures
90 * are defined in that file:
91 *
92 * setup
93 *
94 * mark ... setup -
95 *
96 * Handles special initialization stuff that depends on how this program
97 * was called. Expects to find a mark followed by key/value pairs on the
98 * stack. The def operator is applied to each pair up to the mark, then
99 * the default state is set up.
100 *
101 * pagesetup
102 *
103 * page pagesetup -
104 *
105 * Does whatever is needed to set things up for the next page. Expects
106 * to find the current page number on the stack.
107 *
108 * bitmap
109 *
110 * columns rows bitmap -
111 *
112 * Prints the image that's read as a hex string from standard input. The
113 * image consists of rows lines, each of which includes columns elements.
114 * Eight bits per pixel are used to encode the matrix elements.
115 *
116 * labelmatrix
117 *
118 * matrixname matrixlimits labelmatrix -
119 *
120 * Prints string matrixname just below the lower left corner of the image
121 * and prints string martixlimits near the lower right corner. Outlines
122 * the entire image with a (one pixel wide) box and then draws tick marks
123 * along the top and left sides of the image. One tick mark is printed
124 * for every ten elements.
125 *
126 * legend
127 *
128 * n1 ... nN N c1 m1 ... cM mM total regions legend -
129 *
130 * Prints the legend as a bar graph below the matrix image. n1 ... nN are
131 * strings that represent the interval list. c1 m1 ... cm mM are pairs
132 * that consist of a region's color and the statistics count. Actually
133 * the c's are trivial procedures that just leave a one character string
134 * on the stack when they're executed by image - which is the way the
135 * bar graph is drawn.
136 *
137 * done
138 *
139 * done
140 *
141 * Makes sure the last page is printed. Only needed when we're printing
142 * more than one page on each sheet of paper.
143 *
144 * Many default values, like the magnification and orientation, are defined in
145 * the prologue, which is where they belong. If they're changed (by options), an
146 * appropriate definition is made after the prologue is added to the output file.
147 * The -P option passes arbitrary PostScript through to the output file. Among
148 * other things it can be used to set (or change) values that can't be accessed by
149 * other options.
150 *
151 */
152
153 #include <stdio.h>
154 #include <signal.h>
155 #include <ctype.h>
156 #ifdef plan9
157 #define isascii(c) ((unsigned char)(c)<=0177)
158 #endif
159 #include <sys/types.h>
160 #include <fcntl.h>
161 #include <string.h>
162
163 #include "comments.h" /* PostScript file structuring comments */
164 #include "gen.h" /* general purpose definitions */
165 #include "path.h" /* for the prologue */
166 #include "ext.h" /* external variable declarations */
167 #include "postmd.h" /* special matrix display definitions */
168
169 char *optnames = "a:b:c:d:g:i:m:n:o:p:w:x:y:A:C:E:J:L:P:R:DI";
170
171 char *prologue = POSTMD; /* default PostScript prologue */
172 char *formfile = FORMFILE; /* stuff for multiple pages per sheet */
173 char *temp_dir = TEMPDIR; /* temp directory for copying stdin */
174
175 int formsperpage = 1; /* page images on each piece of paper */
176 int copies = 1; /* and this many copies of each sheet */
177 int bytespp = 6; /* bytes per pattern - on output */
178
179 int dostats = ON; /* permanent statistics flag */
180 int nxtstat = ON; /* and the one for the next matrix */
181
182 char *interval = DFLTILIST; /* string representations of the interval */
183 char *colormap = NULL; /* color map */
184 char *window = NULL; /* and window lists */
185 char *matrixname = "pipe.end"; /* name for the next plot */
186
187 Ilist ilist[128]; /* active interval list and color map */
188 int next = 0; /* one past the last element in ilist[] */
189 int regions; /* an index assigned to the last region */
190 int wlist[4]; /* upper left and lower right corners */
191
192 int page = 0; /* last page we worked on */
193 int printed = 0; /* and the number of pages printed */
194
195 int dfltrows = 0; /* default rows */
196 int dfltcols = 0; /* and columns - changed by -d option */
197 int rows; /* real number of rows */
198 int columns; /* and columns in the matrix */
199 int patcount = 0; /* will be set to columns * rows */
200
201 double element; /* next matrix element */
202
203 char *raster = NULL; /* next raster line */
204 char *rptr; /* next free byte in raster */
205 char *eptr; /* one past the last byte in raster */
206
207 FILE *fp_in = stdin; /* read from this file */
208 FILE *fp_out = stdout; /* and write stuff here */
209 FILE *fp_acct = NULL; /* for accounting data */
210
211 /*****************************************************************************/
212
main(agc,agv)213 main(agc, agv)
214
215 int agc;
216 char *agv[];
217
218 {
219
220 /*
221 *
222 * Bitmap display program for matrices. Only one matrix is allowed per input file,
223 * and each one will be displayed on a page by itself. Input files consist of an
224 * optional header followed by floating point numbers that represent the matrix
225 * elements - in row major order.
226 *
227 */
228
229 argc = agc; /* other routines may want them */
230 argv = agv;
231
232 prog_name = argv[0]; /* really just for error messages */
233
234 init_signals(); /* sets up interrupt handling */
235 header(); /* PostScript header comments */
236 options(); /* handle the command line options */
237 setup(); /* for PostScript */
238 arguments(); /* followed by each input file */
239 done(); /* print the last page etc. */
240 account(); /* job accounting data */
241
242 exit(x_stat); /* not much could be wrong */
243
244 } /* End of main */
245
246 /*****************************************************************************/
247
init_signals()248 init_signals()
249
250 {
251
252 /*
253 *
254 * Make sure we handle interrupts.
255 *
256 */
257
258 if ( signal(SIGINT, interrupt) == SIG_IGN ) {
259 signal(SIGINT, SIG_IGN);
260 signal(SIGQUIT, SIG_IGN);
261 signal(SIGHUP, SIG_IGN);
262 } else {
263 signal(SIGHUP, interrupt);
264 signal(SIGQUIT, interrupt);
265 } /* End else */
266
267 signal(SIGTERM, interrupt);
268 signal(SIGFPE, interrupt);
269
270 } /* End of init_signals */
271
272 /*****************************************************************************/
273
header()274 header()
275
276 {
277
278 int ch; /* return value from getopt() */
279 int old_optind = optind; /* for restoring optind - should be 1 */
280
281 /*
282 *
283 * Scans the option list looking for things, like the prologue file, that we need
284 * right away but could be changed from the default. Doing things this way is an
285 * attempt to conform to Adobe's latest file structuring conventions. In particular
286 * they now say there should be nothing executed in the prologue, and they have
287 * added two new comments that delimit global initialization calls. Once we know
288 * where things really are we write out the job header, follow it by the prologue,
289 * and then add the ENDPROLOG and BEGINSETUP comments.
290 *
291 */
292
293 while ( (ch = getopt(argc, argv, optnames)) != EOF )
294 if ( ch == 'L' )
295 prologue = optarg;
296 else if ( ch == '?' )
297 error(FATAL, "");
298
299 optind = old_optind; /* get ready for option scanning */
300
301 fprintf(stdout, "%s", CONFORMING);
302 fprintf(stdout, "%s %s\n", VERSION, PROGRAMVERSION);
303 fprintf(stdout, "%s %s\n", DOCUMENTFONTS, ATEND);
304 fprintf(stdout, "%s %s\n", PAGES, ATEND);
305 fprintf(stdout, "%s", ENDCOMMENTS);
306
307 if ( cat(prologue) == FALSE )
308 error(FATAL, "can't read %s", prologue);
309
310 fprintf(stdout, "%s", ENDPROLOG);
311 fprintf(stdout, "%s", BEGINSETUP);
312 fprintf(stdout, "mark\n");
313
314 } /* End of header */
315
316 /*****************************************************************************/
317
options()318 options()
319
320 {
321
322 int ch; /* return value from getopt() */
323
324 /*
325 *
326 * Reads and processes the command line options. Added the -P option so arbitrary
327 * PostScript code can be passed through. Expect it could be useful for changing
328 * definitions in the prologue for which options have not been defined.
329 *
330 */
331
332 while ( (ch = getopt(argc, argv, optnames)) != EOF ) {
333 switch ( ch ) {
334 case 'a': /* aspect ratio */
335 fprintf(stdout, "/aspectratio %s def\n", optarg);
336 break;
337
338 case 'b': /* bytes per pattern - on output */
339 bytespp = atoi(optarg);
340 break;
341
342 case 'c': /* copies */
343 copies = atoi(optarg);
344 fprintf(stdout, "/#copies %s store\n", optarg);
345 break;
346
347 case 'd': /* default matrix dimensions */
348 sscanf(optarg, "%dx%d", &dfltrows, &dfltcols);
349 break;
350
351 case 'g': /* set the colormap (ie. grayscale) */
352 colormap = optarg;
353 break;
354
355 case 'i': /* matrix element interval list */
356 interval = optarg;
357 break;
358
359 case 'm': /* magnification */
360 fprintf(stdout, "/magnification %s def\n", optarg);
361 break;
362
363 case 'n': /* forms per page */
364 formsperpage = atoi(optarg);
365 fprintf(stdout, "%s %s\n", FORMSPERPAGE, optarg);
366 fprintf(stdout, "/formsperpage %s def\n", optarg);
367 break;
368
369 case 'o': /* output page list */
370 out_list(optarg);
371 break;
372
373 case 'p': /* landscape or portrait mode */
374 if ( *optarg == 'l' )
375 fprintf(stdout, "/landscape true def\n");
376 else fprintf(stdout, "/landscape false def\n");
377 break;
378
379 case 'w': /* set the window */
380 window = optarg;
381 break;
382
383 case 'x': /* shift things horizontally */
384 fprintf(stdout, "/xoffset %s def\n", optarg);
385 break;
386
387 case 'y': /* and vertically on the page */
388 fprintf(stdout, "/yoffset %s def\n", optarg);
389 break;
390
391 case 'A': /* force job accounting */
392 case 'J':
393 if ( (fp_acct = fopen(optarg, "a")) == NULL )
394 error(FATAL, "can't open accounting file %s", optarg);
395 break;
396
397 case 'C': /* copy file straight to output */
398 if ( cat(optarg) == FALSE )
399 error(FATAL, "can't read %s", optarg);
400 break;
401
402 case 'E': /* text font encoding */
403 fontencoding = optarg;
404 break;
405
406 case 'L': /* PostScript prologue file */
407 prologue = optarg;
408 break;
409
410 case 'P': /* PostScript pass through */
411 fprintf(stdout, "%s\n", optarg);
412 break;
413
414 case 'R': /* special global or page level request */
415 saverequest(optarg);
416 break;
417
418 case 'D': /* debug flag */
419 debug = ON;
420 break;
421
422 case 'I': /* ignore FATAL errors */
423 ignore = ON;
424 break;
425
426 case '?': /* don't understand the option */
427 error(FATAL, "");
428 break;
429
430 default: /* don't know what to do for ch */
431 error(FATAL, "missing case for option %c\n", ch);
432 break;
433 } /* End switch */
434 } /* End while */
435
436 argc -= optind; /* get ready for non-option args */
437 argv += optind;
438
439 } /* End of options */
440
441 /*****************************************************************************/
442
setup()443 setup()
444
445 {
446
447 /*
448 *
449 * Handles things that must be done after the options are read but before the
450 * input files are processed.
451 *
452 */
453
454 writerequest(0, stdout); /* global requests eg. manual feed */
455 setencoding(fontencoding);
456 fprintf(stdout, "setup\n");
457
458 if ( formsperpage > 1 ) {
459 if ( cat(formfile) == FALSE )
460 error(FATAL, "can't read %s", formfile);
461 fprintf(stdout, "%d setupforms\n", formsperpage);
462 } /* End if */
463
464 fprintf(stdout, "%s", ENDSETUP);
465
466 } /* End of setup */
467
468 /*****************************************************************************/
469
arguments()470 arguments()
471
472 {
473
474 /*
475 *
476 * Makes sure all the non-option command line arguments are processed. If we get
477 * here and there aren't any arguments left, or if '-' is one of the input files
478 * we'll process stdin.
479 *
480 */
481
482 if ( argc < 1 )
483 matrix();
484 else { /* at least one argument is left */
485 while ( argc > 0 ) {
486 matrixname = *argv;
487 if ( strcmp(*argv, "-") == 0 ) {
488 fp_in = stdin;
489 matrixname = "pipe.end";
490 } else if ( (fp_in = fopen(*argv, "r")) == NULL )
491 error(FATAL, "can't open %s", *argv);
492 matrix();
493 if ( fp_in != stdin )
494 fclose(fp_in);
495 argc--;
496 argv++;
497 } /* End while */
498 } /* End else */
499
500 } /* End of arguments */
501
502 /*****************************************************************************/
503
done()504 done()
505
506 {
507
508 /*
509 *
510 * Finished with all the input files, so mark the end of the pages, make sure the
511 * last page is printed, and restore the initial environment.
512 *
513 */
514
515 fprintf(stdout, "%s", TRAILER);
516 fprintf(stdout, "done\n");
517 fprintf(stdout, "%s %d\n", PAGES, printed);
518
519 if ( temp_file != NULL )
520 unlink(temp_file);
521
522 } /* End of done */
523
524 /*****************************************************************************/
525
account()526 account()
527
528 {
529
530 /*
531 *
532 * Writes an accounting record to *fp_acct provided it's not NULL. Accounting
533 * is requested using the -A or -J options.
534 *
535 */
536
537 if ( fp_acct != NULL )
538 fprintf(fp_acct, " print %d\n copies %d\n", printed, copies);
539
540 } /* End of account */
541
542 /*****************************************************************************/
543
matrix()544 matrix()
545
546 {
547
548 int count; /* pattern repeats this many times */
549 long total; /* expect this many patterns */
550
551 /*
552 *
553 * Reads a matrix from *fp_in, translates it into a PostScript gray scale image,
554 * and writes the result on stdout. For now only one matrix is allowed per input
555 * file. Matrix elements are floating point numbers arranged in row major order
556 * in the input file. In addition each input file may contain an optional header
557 * that defines special things like the dimension of the matrix, a window into
558 * the matrix that will be displayed, and an interval list.
559 *
560 * If we're reading from stdin we first make a copy in a temporary file so we can
561 * can properly position ourselves after we've looked for the header. Originally
562 * wasn't always making a copy of stdin, but I've added a few things to what's
563 * accepted in the header and this simplifies the job. An alternative would be
564 * to always require a header and mark the end of it by some string. Didn't like
565 * that approach much - may fix things up later.
566 *
567 */
568
569 if ( fp_in == stdin ) /* make a copy so we can seek etc. */
570 copystdin();
571
572 rows = dfltrows; /* new dimensions for the next matrix */
573 columns = dfltcols;
574
575 buildilist(interval); /* build the default ilist[] */
576 addcolormap(colormap); /* add the colormap - if not NULL */
577 setwindow(window); /* and setup the initial matrix window */
578 nxtstat = dostats; /* want statistics? */
579 getheader(); /* matrix dimensions at the very least */
580 dimensions(); /* make sure we have the dimensions etc. */
581
582 patcount = 0;
583 total = rows * columns;
584
585 eptr = rptr + (wlist[2] - wlist[0] + 1);
586
587 redirect(++page);
588
589 fprintf(fp_out, "%s %d %d\n", PAGE, page, printed+1);
590 fprintf(fp_out, "/saveobj save def\n");
591 writerequest(printed+1, fp_out);
592 fprintf(fp_out, "%d %d bitmap\n", wlist[2] - wlist[0] + 1, wlist[3] - wlist[1] + 1);
593
594 while ( patcount != total && fscanf(fp_in, "%f", &element) != EOF ) {
595 if ( inwindow() ) *rptr++ = mapfloat(element);
596 if ( ++patcount % columns == 0 )
597 if ( inrange() )
598 putrow();
599 } /* End while */
600
601 if ( total != patcount )
602 error(FATAL, "matrix format error");
603
604 labelmatrix();
605
606 if ( fp_out == stdout ) printed++;
607
608 fprintf(fp_out, "showpage\n");
609 fprintf(fp_out, "saveobj restore\n");
610 fprintf(fp_out, "%s %d %d\n", ENDPAGE, page, printed);
611
612 } /* End of matrix */
613
614 /*****************************************************************************/
615
copystdin()616 copystdin()
617
618 {
619
620 int fd_out; /* for the temporary file */
621 int fd_in; /* for stdin */
622 int buf[512]; /* buffer for reads and writes */
623 int count; /* number of bytes put in buf */
624
625 /*
626 *
627 * If we're reading the matrix from stdin and the matrix dimension isn't set by
628 * a dimension statement at the beginning of the file we'll copy stdin to a
629 * temporary file and reset *fp_in so reads come from the temp file. Simplifies
630 * reading the header (if present), but is expensive.
631 *
632 */
633
634 if ( temp_file != NULL ) /* been here already */
635 unlink(temp_file);
636
637 if ( (temp_file = tempnam(temp_dir, "post")) == NULL )
638 error(FATAL, "can't generate temp file name");
639
640 if ( (fd_out = creat(temp_file, 0660)) == -1 )
641 error(FATAL, "can't create %s", temp_file);
642
643 fd_in = fileno(stdin);
644
645 while ( (count = read(fd_in, buf, sizeof(buf))) > 0 )
646 if ( write(fd_out, buf, count) != count )
647 error(FATAL, "error writing to %s", temp_file);
648
649 close(fd_out);
650
651 if ( (fp_in = fopen(temp_file, "r")) == NULL )
652 error(FATAL, "can't open %s", temp_file);
653
654 } /* End of copystdin */
655
656 /*****************************************************************************/
657
getheader()658 getheader()
659
660 {
661
662 char buf[512]; /* temporary string space */
663 char *cmap = NULL; /* remember header colormap list */
664 long pos; /* for seeking back to first element */
665
666 /*
667 *
668 * Looks for the optional header information at the beginning of the input file,
669 * reads it if it's there, and sets *fp_in to be just past the header. That should
670 * be the beginning of the matrix element list. The recognized header keywords are
671 * dimension, interval, colormap (or grayscale), window, name, and statistics. All
672 * are optional, but may be useful in a spooling environment when the user doesn't
673 * doesn't actually run the translator.
674 *
675 * The dimension statement specifies the number of rows and columns. For example
676 * either of the following two lines define a 50 by 50 element matrix,
677 *
678 * dimension 50
679 * dimension 50x50
680 *
681 * The first integer is the number of rows and the second, if given, is the number
682 * of columns. If columns are missing from the dimension statement we assume the
683 * matrix is square.
684 *
685 * interval can be used to redefine the interval list used for mapping floating
686 * point numbers into integers in the range 0 to 254. The string following the
687 * interval keyword has the same format as the -i option. For example to set the
688 * interval list to -1, 0, and 1 you can add the line,
689 *
690 * interval -1,0,1
691 *
692 * The numbers are floats given in increasing order, and separated by commas or
693 * blanks. The last interval list in a header takes precedence.
694 *
695 * colormap can be used to redefine the grayscale list. The string following
696 * the colormap keyword has the same format as the -g option. For example
697 *
698 * colormap 0,50,100,150,200,250
699 * or grayscale 0,50,100,150,200,250
700 *
701 * The window keyword can be used to select a submatrix. The numbers following
702 * window are the upper left and lower right matix coordinates. May not be
703 * implemented yet but shouldn't be difficult. For example
704 *
705 * window 10 10 40 40
706 *
707 * selects the submatrix with corners at (10, 10) and (40, 40). The edges of the
708 * window are included in the display.
709 *
710 * The name keyword can be used to define the title of the display. For example,
711 *
712 * name Plot Of Matrix 1
713 *
714 * prints the string "Plot Of Matrix 1" at the top of the page. Everything up to
715 * the next newline is taken as the name string.
716 *
717 */
718
719 pos = ftell(fp_in);
720
721 while ( fscanf(fp_in, "%s", buf) != EOF ) {
722 if ( strncmp(buf, "dimension", strlen("dimension")) == 0 )
723 fscanf(fp_in, "%dx%d", &rows, &columns);
724 else if ( strncmp(buf, "window", strlen("window")) == 0 ) {
725 fgets(buf, sizeof(buf), fp_in);
726 setwindow(buf);
727 } else if ( strncmp(buf, "name", strlen("name")) == 0 ) {
728 fgets(buf, sizeof(buf), fp_in);
729 matrixname = savestring(buf);
730 } else if ( strncmp(buf, "colormap", strlen("colormap")) == 0 ) {
731 fgets(buf, sizeof(buf), fp_in);
732 cmap = savestring(buf);
733 } else if ( strncmp(buf, "grayscale", strlen("grayscale")) == 0 ) {
734 fgets(buf, sizeof(buf), fp_in);
735 cmap = savestring(buf);
736 } else if ( strncmp(buf, "interval", strlen("interval")) == 0 ) {
737 fgets(buf, sizeof(buf), fp_in);
738 buildilist(buf);
739 } else if ( strncmp(buf, "statistics", strlen("statistics")) == 0 ) {
740 fscanf(fp_in, "%s", buf);
741 if ( strcmp(buf, "on") == 0 || strcmp(buf, "ON") == 0 )
742 nxtstat = ON;
743 else nxtstat = OFF;
744 } else break;
745 pos = ftell(fp_in);
746 } /* End while */
747
748 addcolormap(cmap); /* must happen last */
749 fseek(fp_in, pos, 0); /* back to the start of the matrix */
750
751 } /* End of getheader */
752
753 /*****************************************************************************/
754
dimensions()755 dimensions()
756
757 {
758
759 char buf[100]; /* temporary storage for the elements */
760 long count = 0; /* number of elements in the matrix */
761 long pos; /* matrix elements start here */
762
763 /*
764 *
765 * Need to know the dimensions of the matrix before we can go any farther. If
766 * rows and columns are still 0 we'll read the entire input file, starting from
767 * the current position, count the number of elements, take the square root of it,
768 * and use it as the number of rows and columns. Then we seek back to the start
769 * of the real matrix, make sure columns is set, and allocate enough memory for
770 * storing each raster line. After we're certain we've got the number of rows and
771 * columns we check the window coordinates, and if they're not legitimate they're
772 * reset to cover the entire matrix.
773 *
774 */
775
776 if ( rows == 0 ) {
777 pos = ftell(fp_in);
778 while ( fscanf(fp_in, "%s", buf) != EOF )
779 count++;
780 rows = sqrt((double) count);
781 fseek(fp_in, pos, 0);
782 } /* End if */
783
784 if ( columns <= 0 ) columns = rows;
785
786 if ( raster != NULL ) free(raster);
787
788 if ( (rptr = raster = malloc(columns)) == NULL )
789 error(FATAL, "no memory");
790
791 eptr = rptr + columns;
792
793 if ( rows <= 0 || columns <= 0 )
794 error(FATAL, "bad matrix dimensions");
795
796 if ( wlist[0] > wlist[2] || wlist[1] > wlist[3] ) {
797 wlist[0] = wlist[1] = 1;
798 wlist[2] = columns;
799 wlist[3] = rows;
800 } /* End if */
801
802 } /* End of dimensions */
803
804 /*****************************************************************************/
805
buildilist(list)806 buildilist(list)
807
808 char *list; /* use this as the interval list */
809
810 {
811
812 static char *templist = NULL; /* a working copy of the list */
813 char *ptr; /* next number in *templist */
814 int i; /* loop index - for checking the list */
815
816 /*
817 *
818 * Reads string *list and builds up the ilist[] that will be used in the next
819 * matrix. Since strtok() modifies the string it's parsing we make a copy first.
820 * The format of the interval list is described in detail in the comments at the
821 * beginning of this program. Basically consists of a comma or space separated
822 * list of floating point numbers that must be given in increasing numerical order.
823 * The list determines how floating point numbers are mapped into integers in the
824 * range 0 to 254.
825 *
826 */
827
828 if ( templist != NULL ) /* free the space used by the last list */
829 free(templist);
830
831 while ( isascii(*list) && isspace(*list) )
832 list++;
833
834 for ( ptr = list, regions = 3; *ptr != '\0'; ptr++ ) {
835 if ( *ptr == ',' || *ptr == '/' || isspace(*ptr) )
836 regions += 2;
837 while ( isascii(*ptr) && isspace(*ptr) ) ptr++;
838 } /* End for */
839
840 next = 0;
841 templist = savestring(list);
842
843 ptr = strtok(templist, ",/ \t\n");
844 while ( ptr != NULL ) {
845 ilist[next].count = 0;
846 ilist[next++].color = 254 * (regions - 1 - next) / (regions - 1);
847 ilist[next].val = atof(ptr);
848 ilist[next].count = 0;
849 ilist[next++].color = 254 * (regions - 1 - next) / (regions - 1);
850 ptr = strtok(NULL, ",/ \t\n");
851 } /* End while */
852
853 ilist[next].count = 0;
854 ilist[next].color = 254 * (regions - 1 - next) / (regions - 1);
855
856 if ( next == 0 ) /* make sure we have a list */
857 error(FATAL, "missing interval list");
858
859 for ( i = 3; i < next; i += 2 ) /* that's in increasing numerical order */
860 if ( ilist[i].val <= ilist[i-2].val )
861 error(FATAL, "bad interval list");
862
863 } /* End of buildilist */
864
865 /*****************************************************************************/
866
addcolormap(list)867 addcolormap(list)
868
869 char *list; /* use this color map */
870
871 {
872
873 static char *templist = NULL; /* a working copy of the color list */
874 char *ptr; /* next color in *templist */
875 int i = 0; /* assigned to this region in ilist[] */
876
877 /*
878 *
879 * Assigns the integers in *list to the color field for the regions defined in
880 * ilist[]. Assumes ilist[] has already been setup.
881 *
882 */
883
884 if ( list != NULL ) {
885 if ( templist != NULL )
886 free(templist);
887 templist = savestring(list);
888
889 ptr = strtok(templist, ",/ \t\n");
890 while ( ptr != NULL ) {
891 ilist[i++].color = atoi(ptr) % 256;
892 ptr = strtok(NULL, ",/ \t\n");
893 } /* End while */
894 } /* End if */
895
896 } /* End of addcolormap */
897
898 /*****************************************************************************/
899
setwindow(list)900 setwindow(list)
901
902 char *list; /* corners of window into the matrix */
903
904 {
905
906 static char *templist = NULL; /* a working copy of the window list */
907 char *ptr; /* next window coordinate in *templist */
908 int i = 0; /* assigned to this region in wlist[] */
909
910 /*
911 *
912 * Sets up an optional window into the matrix.
913 *
914 */
915
916 wlist[0] = wlist[1] = 1;
917 wlist[2] = wlist[3] = 0;
918
919 if ( list != NULL ) {
920 if ( templist != NULL )
921 free(templist);
922 templist = savestring(list);
923
924 ptr = strtok(templist, ",/ \t\n");
925 while ( ptr != NULL ) {
926 wlist[i++] = atoi(ptr);
927 ptr = strtok(NULL, ",/ \t\n");
928 } /* End while */
929 } /* End if */
930
931 } /* End of setwindow */
932
933 /*****************************************************************************/
934
inwindow()935 inwindow()
936
937 {
938
939 int r; /* row of the patcount element */
940 int c; /* column of the patcount element */
941
942 /*
943 *
944 * Checks if the patcount element of the matrix is in the window.
945 *
946 */
947
948 r = (patcount/columns) + 1;
949 c = (patcount%columns) + 1;
950
951 return((c >= wlist[0]) && (r >= wlist[1]) && (c <= wlist[2]) && (r <= wlist[3]));
952
953 } /* End of inwindow */
954
955 /*****************************************************************************/
956
inrange()957 inrange()
958
959 {
960
961 /*
962 *
963 * Checks if the current row lies in the window. Used right before we output the
964 * raster lines.
965 *
966 */
967
968 return(((patcount/columns) >= wlist[1]) && ((patcount/columns) <= wlist[3]));
969
970 } /* End of inrange */
971
972 /*****************************************************************************/
973
mapfloat(element)974 mapfloat(element)
975
976 double element; /* floating point matrix element */
977
978 {
979
980 int i; /* loop index */
981
982 /*
983 *
984 * Maps element into an integer in the range 0 to 255, and returns the result to
985 * the caller. Mapping is done using the color map that was saved in ilist[]. Also
986 * updates the count field for the region that contains element - not good!
987 *
988 */
989
990 for ( i = 1; i < next && ilist[i].val < element; i += 2 ) ;
991
992 if ( i > next || element < ilist[i].val )
993 i--;
994
995 ilist[i].count++;
996 return(ilist[i].color);
997
998 } /* End of mapfloat */
999
1000 /*****************************************************************************/
1001
putrow()1002 putrow()
1003
1004 {
1005
1006 char *p1, *p2; /* starting and ending columns */
1007 int n; /* set to bytes per pattern */
1008 int i; /* loop index */
1009
1010 /*
1011 *
1012 * Takes the scanline that's been saved in *raster, encodes it according to the
1013 * value that's been assigned to bytespp, and writes the result to *fp_out. Each
1014 * line in the output bitmap is terminated by a 0 on a line by itself.
1015 *
1016 */
1017
1018 n = (bytespp <= 0) ? columns : bytespp;
1019
1020 for ( p1 = raster, p2 = raster + n; p1 < eptr; p1 = p2 )
1021 if ( patncmp(p1, n) == TRUE ) {
1022 while ( patncmp(p2, n) == TRUE ) p2 += n;
1023 p2 += n;
1024 fprintf(fp_out, "%d ", n);
1025 for ( i = 0; i < n; i++, p1++ )
1026 fprintf(fp_out, "%.2X", ((int) *p1) & 0377);
1027 fprintf(fp_out, " %d\n", (p2 - p1) / n);
1028 } else {
1029 while ( p2 < eptr && patncmp(p2, n) == FALSE ) p2 += n;
1030 if ( p2 > eptr ) p2 = eptr;
1031 fprintf(fp_out, "%d ", p2 - p1);
1032 while ( p1 < p2 )
1033 fprintf(fp_out, "%.2X", ((int) *p1++) & 0377);
1034 fprintf(fp_out, " 0\n");
1035 } /* End else */
1036
1037 fprintf(fp_out, "0\n");
1038
1039 rptr = raster;
1040
1041 } /* End of putrow */
1042
1043 /*****************************************************************************/
1044
labelmatrix()1045 labelmatrix()
1046
1047 {
1048
1049 int total; /* number of elements in the window */
1050 int i; /* loop index */
1051
1052 /*
1053 *
1054 * Responsible for generating the PostScript calls that label the matrix, generate
1055 * the legend, and print the matrix name.
1056 *
1057 */
1058
1059 fprintf(fp_out, "(%s) ((%d, %d) to (%d, %d)) labelmatrix\n", matrixname,
1060 wlist[0], wlist[1], wlist[2], wlist[3]);
1061
1062 total = (wlist[2] - wlist[0] + 1) * (wlist[3] - wlist[1] + 1);
1063
1064 if ( nxtstat == OFF )
1065 for ( i = 0; i < regions; i++ )
1066 ilist[i].count = 0;
1067
1068 for ( i = 1; i < next; i += 2 )
1069 fprintf(fp_out, "(%g) ", ilist[i].val);
1070 fprintf(fp_out, "%d ", (regions - 1) / 2);
1071
1072 for ( i = regions - 1; i >= 0; i-- )
1073 fprintf(fp_out, "{(\\%.3o)} %d ", ilist[i].color, ilist[i].count);
1074 fprintf(fp_out, "%d %d legend\n", total, regions);
1075
1076 } /* End of labelmatrix */
1077
1078 /*****************************************************************************/
1079
patncmp(p1,n)1080 patncmp(p1, n)
1081
1082 char *p1; /* first patterns starts here */
1083 int n; /* and extends this many bytes */
1084
1085 {
1086
1087 char *p2; /* address of the second pattern */
1088
1089 /*
1090 *
1091 * Compares the two n byte patterns *p1 and *(p1+n). FALSE if returned is they're
1092 * different or extend past the end of the current raster line.
1093 *
1094 */
1095
1096 p2 = p1 + n;
1097
1098 for ( ; n > 0; n--, p1++, p2++ )
1099 if ( p2 >= eptr || *p1 != *p2 )
1100 return(FALSE);
1101
1102 return(TRUE);
1103
1104 } /* End of patncmp */
1105
1106 /*****************************************************************************/
1107
savestring(str)1108 char *savestring(str)
1109
1110 char *str; /* save this string */
1111
1112 {
1113
1114 char *ptr = NULL; /* at this address */
1115
1116 /*
1117 *
1118 * Copies string *str to a permanent place and returns the address to the caller.
1119 *
1120 */
1121
1122 if ( str != NULL && *str != '\0' ) {
1123 if ( (ptr = malloc(strlen(str) + 1)) == NULL )
1124 error(FATAL, "no memory available for string %s", str);
1125 strcpy(ptr, str);
1126 } /* End if */
1127
1128 return(ptr);
1129
1130 } /* End of savestring */
1131
1132 /*****************************************************************************/
1133
redirect(pg)1134 redirect(pg)
1135
1136 int pg; /* next page we're printing */
1137
1138 {
1139
1140 static FILE *fp_null = NULL; /* if output is turned off */
1141
1142 /*
1143 *
1144 * If we're not supposed to print page pg, fp_out will be directed to /dev/null,
1145 * otherwise output goes to stdout.
1146 *
1147 */
1148
1149 if ( pg >= 0 && in_olist(pg) == ON )
1150 fp_out = stdout;
1151 else if ( (fp_out = fp_null) == NULL )
1152 fp_out = fp_null = fopen("/dev/null", "w");
1153
1154 } /* End of redirect */
1155
1156 /*****************************************************************************/
1157
1158