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