src/px/ra_ps.c

#ifndef lint
static const char       RCSid[] = "$Id: ra_ps.c,v 2.26 2003/07/27 22:12:03 schorsch Exp $";
#endif
/*
 *  Radiance picture to PostScript file translator -- one way!
 */

#include  <stdio.h>
#include  <string.h>
#include  <math.h>
#include  <ctype.h>

#include  "platform.h"
#include  "color.h"
#include  "resolu.h"

#define UPPER(c)        ((c)&~0x20)             /* ASCII trick */

#define CODE6GAM        1.47                    /* gamma for 6-bit codes */
#define DEFGGAM         1.0                     /* greyscale device gamma */
#define DEFCGAM         1.8                     /* color device gamma */

#define GRY             -1                      /* artificial index for grey */

#define DEFMARG         0.5                     /* default margin (inches) */
#define DEFWIDTH        8.5                     /* default page width */
#define DEFHEIGHT       11                      /* default page height */
#define HMARGIN         (hmarg*72)              /* horizontal margin */
#define VMARGIN         (vmarg*72)              /* vertical margin */
#define PWIDTH          (width*72-2*HMARGIN)    /* width of device */
#define PHEIGHT         (height*72-2*VMARGIN)   /* height of device */

#define RUNCHR          '*'                     /* character to start rle */
#define MINRUN          4                       /* minimum run-length */
#define RSTRT           '!'                     /* character for MINRUN */
#define MAXRUN          (MINRUN+'~'-RSTRT)      /* maximum run-length */

char  code[] =                  /* 6-bit code lookup table */
        "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ@+";

int  wrongformat = 0;                   /* input in wrong format? */
double  pixaspect = 1.0;                /* pixel aspect ratio */

double  devgam = 0.;                    /* device gamma response */
double  hmarg = DEFMARG,
        vmarg = DEFMARG;                /* horizontal and vertical margins */
double  width = DEFWIDTH,
        height = DEFHEIGHT;             /* default paper width and height */
double  dpi = 0;                        /* print density (0 if unknown) */
int  docolor = 1;                       /* produce color image? */
int  bradj = 0;                         /* brightness adjustment */
int  ncopies = 1;                       /* number of copies */

extern int      Aputprim(), Bputprim(), Cputprim();

int  (*putprim)() = Aputprim;           /* function for writing scanline */

char  *progname;

int  xmax, ymax;                        /* input image dimensions */

extern double   unit2inch();

static gethfunc headline;


static int
headline(               /* check header line */
        char    *s,
        void    *p
)
{
        char  fmt[32];

        if (isformat(s)) {
                formatval(fmt, s);
                wrongformat = strcmp(fmt, COLRFMT);
        } else if (isaspect(s))
                pixaspect *= aspectval(s);
        return(0);
}


main(argc, argv)
int  argc;
char  *argv[];
{
        int  i;
        double  d;
        
        progname = argv[0];

        for (i = 1; i < argc; i++)
                if (argv[i][0] == '-')
                        switch (argv[i][1]) {
                        case 'b':               /* produce b&w PostScript */
                                docolor = 0;
                                break;
                        case 'c':               /* produce color PostScript */
                                docolor = 1;
                                break;
                        case 'A':               /* standard ASCII encoding */
                                putprim = Aputprim;
                                break;
                        case 'B':               /* standard binary encoding */
                                putprim = Bputprim;
                                break;
                        case 'C':               /* compressed ASCII encoding */
                                putprim = Cputprim;
                                break;
                        case 'd':               /* print density */
                                dpi = atof(argv[++i]);
                                break;
                        case 'g':               /* device gamma adjustment */
                                devgam = atof(argv[++i]);
                                break;
                        case 'p':               /* paper size */
                                parsepaper(argv[++i]);
                                break;
                        case 'm':               /* margin */
                                d = atof(argv[i+1]);
                                d *= unit2inch(argv[i+1]);
                                switch (argv[i][2]) {
                                case '\0':
                                        hmarg = vmarg = d;
                                        break;
                                case 'h':
                                        hmarg = d;
                                        break;
                                case 'v':
                                        vmarg = d;
                                        break;
                                default:
                                        goto userr;
                                }
                                i++;
                                break;
                        case 'e':               /* exposure adjustment */
                                if (argv[i+1][0] != '+' && argv[i+1][0] != '-')
                                        goto userr;
                                bradj = atoi(argv[++i]);
                                break;
                        case 'n':               /* number of copies */
                                ncopies = atoi(argv[++i]);
                                break;
                        default:
                                goto userr;
                        }
                else
                        break;

        if (i < argc-2)
                goto userr;
        if (i <= argc-1 && freopen(argv[i], "r", stdin) == NULL) {
                fprintf(stderr, "%s: can't open input \"%s\"\n",
                                progname, argv[i]);
                exit(1);
        }
        if (i == argc-2 && freopen(argv[i+1], "w", stdout) == NULL) {
                fprintf(stderr, "%s: can't open output \"%s\"\n",
                                progname, argv[i+1]);
                exit(1);
        }
        SET_FILE_BINARY(stdin);
                                /* get our header */
        getheader(stdin, headline, NULL);
        if (wrongformat || fgetresolu(&xmax, &ymax, stdin) < 0)
                quiterr("bad picture format");
                                /* gamma compression */
        if (devgam <= 0.05)
                devgam = docolor ? DEFCGAM : DEFGGAM;
        if (putprim == Cputprim)
                setcolrgam(CODE6GAM);
        else if (devgam != 1.)
                setcolrgam(devgam);
                                /* write header */
        PSheader(argc, argv);
                                /* convert file */
        ra2ps();
                                /* write trailer */
        PStrailer();
        exit(0);
userr:
        fprintf(stderr,
"Usage: %s [-b|c][-A|B|C][-e +/-stops][-p paper][-m[h|v] margin][-d dpi][-g gamma] [input [output]]\n",
                        progname);
        exit(1);
}


double
unit2inch(s)            /* determine unit */
register char   *s;
{
        static struct unit {char n; float f;} u[] = {
                {'i', 1.},
                {'m', 1./25.4},
                {'c', 1./2.54},
                {'\0',0} };
        register struct unit    *up;

        while (*s && !isalpha(*s))
                s++;
        for (up = u; up->n; up++)
                if (up->n == *s)
                        return(up->f);
        return(1.);
}


int
matchid(name, id)       /* see if name matches id (case insensitive) */
char    *name;
register char   *id;
{
        register char   *s = name;

        while (*s) {
                if (isalpha(*s)) {
                        if (!isalpha(*id) || UPPER(*s) != UPPER(*id))
                                return(0);
                } else if (*s != *id)
                        return(0);
                s++; id++;
        }
        return(!*id || s-name >= 3);    /* substrings >= 3 chars OK */
}


parsepaper(ps)          /* determine paper size from name */
char    *ps;
{
        static struct psize {char n[12]; float w,h;} p[] = {
                {"envelope", 4.12, 9.5},
                {"executive", 7.25, 10.5},
                {"letter", 8.5, 11.},
                {"lettersmall", 7.68, 10.16},
                {"legal", 8.5, 14.},
                {"monarch", 3.87, 7.5},
                {"statement", 5.5, 8.5},
                {"tabloid", 11., 17.},
                {"A3", 11.69, 16.54},
                {"A4", 8.27, 11.69},
                {"A4small", 7.47, 10.85},
                {"A5", 6.00, 8.27},
                {"A6", 4.13, 6.00},
                {"B4", 10.12, 14.33},
                {"B5", 7.17, 10.12},
                {"C5", 6.38, 9.01},
                {"C6", 4.49, 6.38},
                {"DL", 4.33, 8.66},
                {"hagaki", 3.94, 5.83},
                {"",0.0,0.0} };
        register struct psize   *pp;
        register char   *s = ps;
        double  d;

        if (isdigit(*s)) {              /* check for WWxHH specification */
                width = atof(s);
                while (*s && !isalpha(*s))
                        s++;
                d = unit2inch(s);
                height = atof(++s);
                width *= d;
                height *= d;
                if ((width >= 1.) & (height >= 1.))
                        return;
        } else                          /* check for match to standard size */
                for (pp = p; pp->n[0]; pp++)
                        if (matchid(s, pp->n)) {
                                width = pp->w;
                                height = pp->h;
                                return;
                        }
        fprintf(stderr, "%s: unknown paper size \"%s\" -- known sizes:\n",
                        progname, ps);
        fprintf(stderr, "_Name________Width_Height_(inches)\n");
        for (pp = p; pp->n[0]; pp++)
                fprintf(stderr, "%-11s  %5.2f  %5.2f\n", pp->n, pp->w, pp->h);
        fprintf(stderr, "Or use WWxHH size specification\n");
        exit(1);
}


quiterr(err)            /* print message and exit */
char  *err;
{
        if (err != NULL) {
                fprintf(stderr, "%s: %s\n", progname, err);
                exit(1);
        }
        exit(0);
}


PSheader(ac, av)                /* print PostScript header */
int  ac;
char  **av;
{
        char  *rstr;
        int  landscape, rotate, n;
        double  pwidth, pheight;
        double  iwidth, iheight;
                                        /* EPS comments */
        puts("%!PS-Adobe-2.0 EPSF-2.0");
        printf("%%%%Title: "); printargs(ac, av, stdout);
        printf("%%%%Creator: %s\n", progname);
        printf("%%%%Pages: %d\n", ncopies);
        if ( (landscape = xmax > pixaspect*ymax) )
                puts("%%Orientation: Landscape");
        else
                puts("%%Orientation: Portrait");
        if ( (rotate = (PWIDTH > PHEIGHT) ^ landscape) ) {
                pwidth = PHEIGHT;
                pheight = PWIDTH;
        } else {
                pwidth = PWIDTH;
                pheight = PHEIGHT;
        }
        if (dpi > 100 && (pixaspect >= 0.99) & (pixaspect <= 1.01))
                if (pheight/pwidth > ymax/xmax) {
                        n = pwidth*dpi/xmax;    /* floor */
                        iwidth = n > 0 ? (double)(n*xmax)/dpi : pwidth;
                        iheight = iwidth*ymax/xmax;
                } else {
                        n = pheight*dpi/ymax;   /* floor */
                        iheight = n > 0 ? (double)(n*ymax)/dpi : pheight;
                        iwidth = iheight*xmax/ymax;
                }
        else
                if (pheight/pwidth > pixaspect*ymax/xmax) {
                        iwidth = pwidth;
                        iheight = iwidth*pixaspect*ymax/xmax;
                } else {
                        iheight = pheight;
                        iwidth = iheight*xmax/(pixaspect*ymax);
                }
        if (rotate)
                printf("%%%%BoundingBox: %.0f %.0f %.0f %.0f\n",
                                HMARGIN+(pheight-iheight)*.5,
                                VMARGIN+(pwidth-iwidth)*.5,
                                HMARGIN+(pheight-iheight)*.5+iheight,
                                VMARGIN+(pwidth-iwidth)*.5+iwidth);
        else
                printf("%%%%BoundingBox: %.0f %.0f %.0f %.0f\n",
                                HMARGIN+(pwidth-iwidth)*.5,
                                VMARGIN+(pheight-iheight)*.5,
                                HMARGIN+(pwidth-iwidth)*.5+iwidth,
                                VMARGIN+(pheight-iheight)*.5+iheight);
        puts("%%EndComments");
        puts("gsave save");
        puts("17 dict begin");
                                        /* define image reader */
        if (docolor) {
                printf("/redline %d string def\n", xmax);
                printf("/grnline %d string def\n", xmax);
                printf("/bluline %d string def\n", xmax);
        } else
                printf("/gryline %d string def\n", xmax);
                                        /* use compressed encoding? */
        if (putprim == Cputprim)
                PSprocdef("read6bitRLE");
                                        /* set up transformation matrix */
        printf("%f %f translate\n", HMARGIN, VMARGIN);
        if (rotate) {
                printf("%f 0 translate\n", PWIDTH);
                puts("90 rotate");
        }
        printf("%f %f translate\n", (pwidth-iwidth)*.5, (pheight-iheight)*.5);
        printf("%f %f scale\n", iwidth, iheight);
        puts("%%EndProlog");
                                        /* start image procedure */
        printf("%d %d 8 [%d 0 0 %d 0 %d]\n", xmax, ymax, xmax, -ymax, ymax);
        if (putprim == Cputprim) {
                if (docolor) {
                        puts("{redline read6bitRLE}");
                        puts("{grnline read6bitRLE}");
                        puts("{bluline read6bitRLE}");
                        puts("true 3 colorimage");
                } else
                        puts("{gryline read6bitRLE} image");
        } else {
                rstr = putprim==Aputprim ? "readhexstring" : "readstring";
                if (docolor) {
                        printf("{currentfile redline %s pop}\n", rstr);
                        printf("{currentfile grnline %s pop}\n", rstr);
                        printf("{currentfile bluline %s pop}\n", rstr);
                        puts("true 3 colorimage");
                } else
                        printf("{currentfile gryline %s pop} image\n", rstr);
        }
}


PStrailer()                     /* print PostScript trailer */
{
        puts("%%Trailer");
        if (ncopies > 1)
                printf("/#copies %d def\n", ncopies);
        puts("showpage");
        puts("end");
        puts("restore grestore");
        puts("%%EOF");
}


PSprocdef(nam)                  /* define PS procedure to read image */
char  *nam;
{
        short  itab[128];
        register int  i;
                                /* assign code values */
        for (i = 0; i < 128; i++)       /* clear */
                itab[i] = -1;
        for (i = 1; i < 63; i++)        /* assign greys */
                itab[code[i]] = 256.0*pow((i+.5)/64.0, CODE6GAM/devgam);
        itab[code[0]] = 0;              /* black is black */
        itab[code[63]] = 255;           /* and white is white */
        printf("/codetab [");
        for (i = 0; i < 128; i++) {
                if (!(i & 0xf))
                        putchar('\n');
                printf(" %3d", itab[i]);
        }
        printf("\n] def\n");
        printf("/nrept 0 def\n");
        printf("/readbyte { currentfile read not {stop} if } bind def\n");
        printf("/decode { codetab exch get } bind def\n");
        printf("/%s {\t%% scanbuffer\n", nam);
        printf("\t/scanline exch def\n");
        printf("\t{ 0 1 %d { scanline exch\n", xmax-1);
        printf("\t\tnrept 0 le\n");
        printf("\t\t\t{ { readbyte dup %d eq\n", RUNCHR);
        printf("\t\t\t\t\t{ pop /nrept readbyte %d sub def\n", RSTRT-MINRUN+1);
        printf("\t\t\t\t\t\t/reptv readbyte decode def\n");
        printf("\t\t\t\t\t\treptv exit }\n");
        printf("\t\t\t\t\t{ decode dup 0 lt {pop} {exit} ifelse }\n");
        printf("\t\t\t\tifelse } loop }\n");
        printf("\t\t\t{ /nrept nrept 1 sub def reptv }\n");
        printf("\t\tifelse put\n");
        printf("\t\t} for\n");
        printf("\t} stopped {pop pop 0 string} {scanline} ifelse\n");
        printf("} bind def\n");
}


ra2ps()                         /* convert Radiance scanlines to 6-bit */
{
        register COLR   *scanin;
        int     y;
                                                /* allocate scanline */
        scanin = (COLR *)malloc(xmax*sizeof(COLR));
        if (scanin == NULL)
                quiterr("out of memory in ra2ps");
                                                /* convert image */
        for (y = ymax-1; y >= 0; y--) {
                if (freadcolrs(scanin, xmax, stdin) < 0)
                        quiterr("error reading Radiance picture");
                if (putprim == Cputprim || devgam != 1.) {
                        if (bradj)                      /* adjust exposure */
                                shiftcolrs(scanin, xmax, bradj);
                        colrs_gambs(scanin, xmax);      /* gamma compression */
                } else
                        normcolrs(scanin, xmax, bradj);
                if (docolor) {
                        (*putprim)(scanin, RED);
                        (*putprim)(scanin, GRN);
                        (*putprim)(scanin, BLU);
                } else
                        (*putprim)(scanin, GRY);
                if (ferror(stdout))
                        quiterr("error writing PostScript file");
        }
        putchar('\n');
                                                /* free scanline */
        free((void *)scanin);
}


int
Aputprim(scn, pri)              /* put out hex ASCII primary from scanline */
COLR    *scn;
int     pri;
{
        static char     hexdigit[] = "0123456789ABCDEF";
        static int      col = 0;
        register int    x, c;

        for (x = 0; x < xmax; x++) {
                if (pri == GRY)
                        c = normbright(scn[x]);
                else
                        c = scn[x][pri];
                if (c > 255) c = 255;
                putchar(hexdigit[c>>4]);
                putchar(hexdigit[c&0xf]);
                if ((col += 2) >= 72) {
                        putchar('\n');
                        col = 0;
                }
        }
}


int
Bputprim(scn, pri)              /* put out binary primary from scanline */
COLR    *scn;
int     pri;
{
        register int    x, c;

        for (x = 0; x < xmax; x++) {
                if (pri == GRY)
                        c = normbright(scn[x]);
                else
                        c = scn[x][pri];
                if (c > 255) c = 255;
                putchar(c);
        }
}


int
Cputprim(scn, pri)              /* put out compressed primary from scanline */
COLR    *scn;
int     pri;
{
        register int    c;
        register int    x;
        int     lastc, cnt;

        lastc = -1; cnt = 0;
        for (x = 0; x < xmax; x++) {
                if (pri == GRY)
                        c = normbright(scn[x]) + 2;
                else
                        c = scn[x][pri] + 2;
                if (c > 255) c = 255;
                c = code[c>>2];
                if (c == lastc && cnt < MAXRUN)
                        cnt++;
                else {
                        putrle(cnt, lastc);
                        lastc = c;
                        cnt = 1;
                }
        }
        putrle(cnt, lastc);
}


putrle(cnt, cod)                /* put out cnt of cod */
register int    cnt, cod;
{
        static int      col = 0;

        if (cnt >= MINRUN) {
                col += 3;
                putchar(RUNCHR);
                putchar(RSTRT-MINRUN+cnt);
                putchar(cod);
        } else {
                col += cnt;
                while (cnt-- > 0)
                        putchar(cod);
        }
        if (col >= 72) {
                putchar('\n');
                col = 0;
        }
}
Revision:	2.27
Committed:	Fri Jan 2 12:47:01 2004 UTC (20 years, 4 months ago) by schorsch
Content type:	text/plain
Branch:	MAIN
Changes since 2.26:	+34 -28 lines
Log Message:	Fixed typing/prototype of getheader() and its callback.
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	schorsch	2.27	static const char RCSid[] = "$Id: ra_ps.c,v 2.26 2003/07/27 22:12:03 schorsch Exp $";
3	greg	2.1	#endif
4			/*
5			* Radiance picture to PostScript file translator -- one way!
6			*/
7
8			#include <stdio.h>
9	schorsch	2.27	#include <string.h>
10	greg	2.13	#include <math.h>
11	gregl	2.18	#include <ctype.h>
12	schorsch	2.25
13			#include "platform.h"
14	greg	2.1	#include "color.h"
15	schorsch	2.27	#include "resolu.h"
16	greg	2.1
17	gregl	2.18	#define UPPER(c) ((c)&~0x20) /* ASCII trick */
18
19	gregl	2.17	#define CODE6GAM 1.47 /* gamma for 6-bit codes */
20	gwlarson	2.21	#define DEFGGAM 1.0 /* greyscale device gamma */
21			#define DEFCGAM 1.8 /* color device gamma */
22	greg	2.13
23	greg	2.11	#define GRY -1 /* artificial index for grey */
24
25	gregl	2.18	#define DEFMARG 0.5 /* default margin (inches) */
26			#define DEFWIDTH 8.5 /* default page width */
27			#define DEFHEIGHT 11 /* default page height */
28			#define HMARGIN (hmarg72) / horizontal margin */
29			#define VMARGIN (vmarg72) / vertical margin */
30			#define PWIDTH (width72-2HMARGIN) /* width of device */
31			#define PHEIGHT (height72-2VMARGIN) /* height of device */
32	greg	2.1
33	greg	2.9	#define RUNCHR '' / character to start rle */
34			#define MINRUN 4 /* minimum run-length */
35			#define RSTRT '!' /* character for MINRUN */
36			#define MAXRUN (MINRUN+'~'-RSTRT) /* maximum run-length */
37
38	greg	2.1	char code[] = /* 6-bit code lookup table */
39			"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ@+";
40
41			int wrongformat = 0; /* input in wrong format? */
42	greg	2.6	double pixaspect = 1.0; /* pixel aspect ratio */
43	greg	2.1
44	gwlarson	2.21	double devgam = 0.; /* device gamma response */
45	gregl	2.18	double hmarg = DEFMARG,
46			vmarg = DEFMARG; /* horizontal and vertical margins */
47			double width = DEFWIDTH,
48			height = DEFHEIGHT; /* default paper width and height */
49	gregl	2.20	double dpi = 0; /* print density (0 if unknown) */
50	gwlarson	2.21	int docolor = 1; /* produce color image? */
51	greg	2.1	int bradj = 0; /* brightness adjustment */
52	greg	2.4	int ncopies = 1; /* number of copies */
53	greg	2.1
54	greg	2.15	extern int Aputprim(), Bputprim(), Cputprim();
55
56			int (putprim)() = Aputprim; / function for writing scanline */
57
58	greg	2.1	char *progname;
59
60	gregl	2.20	int xmax, ymax; /* input image dimensions */
61	greg	2.1
62	gregl	2.18	extern double unit2inch();
63	greg	2.1
64	schorsch	2.27	static gethfunc headline;
65	greg	2.6
66	schorsch	2.27
67			static int
68			headline( /* check header line */
69			char *s,
70			void *p
71			)
72	greg	2.1	{
73			char fmt[32];
74
75			if (isformat(s)) {
76			formatval(fmt, s);
77			wrongformat = strcmp(fmt, COLRFMT);
78			} else if (isaspect(s))
79			pixaspect *= aspectval(s);
80	gwlarson	2.22	return(0);
81	greg	2.1	}
82
83
84			main(argc, argv)
85			int argc;
86			char *argv[];
87			{
88			int i;
89	gregl	2.18	double d;
90	greg	2.1
91			progname = argv[0];
92
93			for (i = 1; i < argc; i++)
94			if (argv[i][0] == '-')
95			switch (argv[i][1]) {
96	greg	2.15	case 'b': /* produce b&w PostScript */
97			docolor = 0;
98			break;
99	greg	2.11	case 'c': /* produce color PostScript */
100	greg	2.15	docolor = 1;
101	greg	2.11	break;
102	greg	2.15	case 'A': /* standard ASCII encoding */
103			putprim = Aputprim;
104			break;
105			case 'B': /* standard binary encoding */
106			putprim = Bputprim;
107			break;
108			case 'C': /* compressed ASCII encoding */
109			putprim = Cputprim;
110			break;
111	gregl	2.20	case 'd': /* print density */
112			dpi = atof(argv[++i]);
113			break;
114	gregl	2.18	case 'g': /* device gamma adjustment */
115	gregl	2.17	devgam = atof(argv[++i]);
116			break;
117	gregl	2.18	case 'p': /* paper size */
118			parsepaper(argv[++i]);
119			break;
120			case 'm': /* margin */
121			d = atof(argv[i+1]);
122			d *= unit2inch(argv[i+1]);
123			switch (argv[i][2]) {
124			case '\0':
125			hmarg = vmarg = d;
126			break;
127			case 'h':
128			hmarg = d;
129			break;
130			case 'v':
131			vmarg = d;
132			break;
133			default:
134			goto userr;
135			}
136			i++;
137			break;
138	greg	2.1	case 'e': /* exposure adjustment */
139			if (argv[i+1][0] != '+' && argv[i+1][0] != '-')
140			goto userr;
141			bradj = atoi(argv[++i]);
142			break;
143	greg	2.4	case 'n': /* number of copies */
144			ncopies = atoi(argv[++i]);
145			break;
146	greg	2.1	default:
147			goto userr;
148			}
149			else
150			break;
151
152			if (i < argc-2)
153			goto userr;
154			if (i <= argc-1 && freopen(argv[i], "r", stdin) == NULL) {
155			fprintf(stderr, "%s: can't open input \"%s\"\n",
156			progname, argv[i]);
157			exit(1);
158			}
159			if (i == argc-2 && freopen(argv[i+1], "w", stdout) == NULL) {
160	greg	2.7	fprintf(stderr, "%s: can't open output \"%s\"\n",
161	greg	2.1	progname, argv[i+1]);
162			exit(1);
163			}
164	schorsch	2.25	SET_FILE_BINARY(stdin);
165	greg	2.1	/* get our header */
166			getheader(stdin, headline, NULL);
167			if (wrongformat \|\| fgetresolu(&xmax, &ymax, stdin) < 0)
168			quiterr("bad picture format");
169	greg	2.13	/* gamma compression */
170	gwlarson	2.21	if (devgam <= 0.05)
171			devgam = docolor ? DEFCGAM : DEFGGAM;
172	greg	2.15	if (putprim == Cputprim)
173	gregl	2.19	setcolrgam(CODE6GAM);
174	gregl	2.17	else if (devgam != 1.)
175	gregl	2.19	setcolrgam(devgam);
176	greg	2.1	/* write header */
177	gwlarson	2.21	PSheader(argc, argv);
178	greg	2.1	/* convert file */
179			ra2ps();
180			/* write trailer */
181			PStrailer();
182			exit(0);
183			userr:
184	gregl	2.18	fprintf(stderr,
185	gregl	2.20	"Usage: %s [-b\|c][-A\|B\|C][-e +/-stops][-p paper][-m[h\|v] margin][-d dpi][-g gamma] [input [output]]\n",
186	greg	2.11	progname);
187	gregl	2.18	exit(1);
188			}
189
190
191			double
192			unit2inch(s) /* determine unit */
193			register char *s;
194			{
195	gwlarson	2.23	static struct unit {char n; float f;} u[] = {
196	schorsch	2.27	{'i', 1.},
197			{'m', 1./25.4},
198			{'c', 1./2.54},
199			{'\0',0} };
200	gregl	2.18	register struct unit *up;
201
202			while (s && !isalpha(s))
203			s++;
204			for (up = u; up->n; up++)
205			if (up->n == *s)
206			return(up->f);
207			return(1.);
208			}
209
210
211			int
212			matchid(name, id) /* see if name matches id (case insensitive) */
213			char *name;
214			register char *id;
215			{
216			register char *s = name;
217
218			while (*s) {
219			if (isalpha(*s)) {
220			if (!isalpha(id) \|\| UPPER(s) != UPPER(*id))
221			return(0);
222			} else if (s != id)
223			return(0);
224			s++; id++;
225			}
226			return(!id \|\| s-name >= 3); / substrings >= 3 chars OK */
227			}
228
229
230			parsepaper(ps) /* determine paper size from name */
231			char *ps;
232			{
233			static struct psize {char n[12]; float w,h;} p[] = {
234	schorsch	2.27	{"envelope", 4.12, 9.5},
235			{"executive", 7.25, 10.5},
236			{"letter", 8.5, 11.},
237			{"lettersmall", 7.68, 10.16},
238			{"legal", 8.5, 14.},
239			{"monarch", 3.87, 7.5},
240			{"statement", 5.5, 8.5},
241			{"tabloid", 11., 17.},
242			{"A3", 11.69, 16.54},
243			{"A4", 8.27, 11.69},
244			{"A4small", 7.47, 10.85},
245			{"A5", 6.00, 8.27},
246			{"A6", 4.13, 6.00},
247			{"B4", 10.12, 14.33},
248			{"B5", 7.17, 10.12},
249			{"C5", 6.38, 9.01},
250			{"C6", 4.49, 6.38},
251			{"DL", 4.33, 8.66},
252			{"hagaki", 3.94, 5.83},
253			{"",0.0,0.0} };
254	gregl	2.18	register struct psize *pp;
255			register char *s = ps;
256			double d;
257
258			if (isdigit(s)) { / check for WWxHH specification */
259			width = atof(s);
260			while (s && !isalpha(s))
261			s++;
262			d = unit2inch(s);
263			height = atof(++s);
264			width *= d;
265			height *= d;
266	schorsch	2.26	if ((width >= 1.) & (height >= 1.))
267	gregl	2.18	return;
268			} else /* check for match to standard size */
269			for (pp = p; pp->n[0]; pp++)
270			if (matchid(s, pp->n)) {
271			width = pp->w;
272			height = pp->h;
273			return;
274			}
275			fprintf(stderr, "%s: unknown paper size \"%s\" -- known sizes:\n",
276			progname, ps);
277			fprintf(stderr, "_Name________Width_Height_(inches)\n");
278			for (pp = p; pp->n[0]; pp++)
279			fprintf(stderr, "%-11s %5.2f %5.2f\n", pp->n, pp->w, pp->h);
280	gregl	2.19	fprintf(stderr, "Or use WWxHH size specification\n");
281	greg	2.1	exit(1);
282			}
283
284
285			quiterr(err) /* print message and exit */
286			char *err;
287			{
288			if (err != NULL) {
289			fprintf(stderr, "%s: %s\n", progname, err);
290			exit(1);
291			}
292			exit(0);
293			}
294
295
296	gwlarson	2.21	PSheader(ac, av) /* print PostScript header */
297			int ac;
298			char **av;
299	greg	2.1	{
300	greg	2.15	char *rstr;
301	gregl	2.20	int landscape, rotate, n;
302	greg	2.6	double pwidth, pheight;
303			double iwidth, iheight;
304	greg	2.10	/* EPS comments */
305	greg	2.11	puts("%!PS-Adobe-2.0 EPSF-2.0");
306	gwlarson	2.21	printf("%%%%Title: "); printargs(ac, av, stdout);
307	greg	2.24	printf("%%%%Creator: %s\n", progname);
308	greg	2.4	printf("%%%%Pages: %d\n", ncopies);
309	schorsch	2.26	if ( (landscape = xmax > pixaspect*ymax) )
310	greg	2.10	puts("%%Orientation: Landscape");
311	greg	2.1	else
312	greg	2.10	puts("%%Orientation: Portrait");
313	schorsch	2.26	if ( (rotate = (PWIDTH > PHEIGHT) ^ landscape) ) {
314	greg	2.1	pwidth = PHEIGHT;
315			pheight = PWIDTH;
316			} else {
317			pwidth = PWIDTH;
318			pheight = PHEIGHT;
319			}
320	schorsch	2.26	if (dpi > 100 && (pixaspect >= 0.99) & (pixaspect <= 1.01))
321	gregl	2.20	if (pheight/pwidth > ymax/xmax) {
322			n = pwidthdpi/xmax; / floor */
323			iwidth = n > 0 ? (double)(n*xmax)/dpi : pwidth;
324			iheight = iwidth*ymax/xmax;
325			} else {
326			n = pheightdpi/ymax; / floor */
327			iheight = n > 0 ? (double)(n*ymax)/dpi : pheight;
328			iwidth = iheight*xmax/ymax;
329			}
330			else
331			if (pheight/pwidth > pixaspect*ymax/xmax) {
332			iwidth = pwidth;
333			iheight = iwidthpixaspectymax/xmax;
334			} else {
335			iheight = pheight;
336			iwidth = iheightxmax/(pixaspectymax);
337			}
338			if (rotate)
339	greg	2.10	printf("%%%%BoundingBox: %.0f %.0f %.0f %.0f\n",
340			HMARGIN+(pheight-iheight)*.5,
341			VMARGIN+(pwidth-iwidth)*.5,
342			HMARGIN+(pheight-iheight)*.5+iheight,
343			VMARGIN+(pwidth-iwidth)*.5+iwidth);
344			else
345			printf("%%%%BoundingBox: %.0f %.0f %.0f %.0f\n",
346			HMARGIN+(pwidth-iwidth)*.5,
347			VMARGIN+(pheight-iheight)*.5,
348			HMARGIN+(pwidth-iwidth)*.5+iwidth,
349			VMARGIN+(pheight-iheight)*.5+iheight);
350			puts("%%EndComments");
351	greg	2.13	puts("gsave save");
352	greg	2.15	puts("17 dict begin");
353	greg	2.10	/* define image reader */
354	greg	2.11	if (docolor) {
355			printf("/redline %d string def\n", xmax);
356			printf("/grnline %d string def\n", xmax);
357			printf("/bluline %d string def\n", xmax);
358	greg	2.15	} else
359			printf("/gryline %d string def\n", xmax);
360			/* use compressed encoding? */
361			if (putprim == Cputprim)
362			PSprocdef("read6bitRLE");
363	greg	2.10	/* set up transformation matrix */
364			printf("%f %f translate\n", HMARGIN, VMARGIN);
365	gregl	2.20	if (rotate) {
366	greg	2.14	printf("%f 0 translate\n", PWIDTH);
367			puts("90 rotate");
368	greg	2.10	}
369	greg	2.2	printf("%f %f translate\n", (pwidth-iwidth).5, (pheight-iheight).5);
370			printf("%f %f scale\n", iwidth, iheight);
371	greg	2.12	puts("%%EndProlog");
372	greg	2.3	/* start image procedure */
373	greg	2.15	printf("%d %d 8 [%d 0 0 %d 0 %d]\n", xmax, ymax, xmax, -ymax, ymax);
374			if (putprim == Cputprim) {
375			if (docolor) {
376	greg	2.16	puts("{redline read6bitRLE}");
377			puts("{grnline read6bitRLE}");
378			puts("{bluline read6bitRLE}");
379			puts("true 3 colorimage");
380	greg	2.15	} else
381			puts("{gryline read6bitRLE} image");
382			} else {
383			rstr = putprim==Aputprim ? "readhexstring" : "readstring";
384			if (docolor) {
385			printf("{currentfile redline %s pop}\n", rstr);
386			printf("{currentfile grnline %s pop}\n", rstr);
387			printf("{currentfile bluline %s pop}\n", rstr);
388			puts("true 3 colorimage");
389			} else
390			printf("{currentfile gryline %s pop} image\n", rstr);
391			}
392	greg	2.1	}
393
394
395			PStrailer() /* print PostScript trailer */
396			{
397			puts("%%Trailer");
398	greg	2.4	if (ncopies > 1)
399			printf("/#copies %d def\n", ncopies);
400			puts("showpage");
401	greg	2.1	puts("end");
402	greg	2.13	puts("restore grestore");
403	greg	2.1	puts("%%EOF");
404			}
405
406
407	greg	2.15	PSprocdef(nam) /* define PS procedure to read image */
408			char *nam;
409	greg	2.1	{
410			short itab[128];
411			register int i;
412	greg	2.5	/* assign code values */
413			for (i = 0; i < 128; i++) /* clear */
414	greg	2.1	itab[i] = -1;
415	greg	2.5	for (i = 1; i < 63; i++) /* assign greys */
416	gregl	2.19	itab[code[i]] = 256.0*pow((i+.5)/64.0, CODE6GAM/devgam);
417	greg	2.5	itab[code[0]] = 0; /* black is black */
418			itab[code[63]] = 255; /* and white is white */
419	greg	2.9	printf("/codetab [");
420	greg	2.1	for (i = 0; i < 128; i++) {
421			if (!(i & 0xf))
422			putchar('\n');
423			printf(" %3d", itab[i]);
424			}
425			printf("\n] def\n");
426	greg	2.9	printf("/nrept 0 def\n");
427	greg	2.11	printf("/readbyte { currentfile read not {stop} if } bind def\n");
428			printf("/decode { codetab exch get } bind def\n");
429			printf("/%s {\t%% scanbuffer\n", nam);
430			printf("\t/scanline exch def\n");
431	greg	2.1	printf("\t{ 0 1 %d { scanline exch\n", xmax-1);
432	greg	2.9	printf("\t\tnrept 0 le\n");
433			printf("\t\t\t{ { readbyte dup %d eq\n", RUNCHR);
434			printf("\t\t\t\t\t{ pop /nrept readbyte %d sub def\n", RSTRT-MINRUN+1);
435			printf("\t\t\t\t\t\t/reptv readbyte decode def\n");
436			printf("\t\t\t\t\t\treptv exit }\n");
437			printf("\t\t\t\t\t{ decode dup 0 lt {pop} {exit} ifelse }\n");
438			printf("\t\t\t\tifelse } loop }\n");
439			printf("\t\t\t{ /nrept nrept 1 sub def reptv }\n");
440			printf("\t\tifelse put\n");
441			printf("\t\t} for\n");
442			printf("\t} stopped {pop pop 0 string} {scanline} ifelse\n");
443	greg	2.8	printf("} bind def\n");
444	greg	2.1	}
445
446
447			ra2ps() /* convert Radiance scanlines to 6-bit */
448			{
449	greg	2.9	register COLR *scanin;
450	greg	2.1	int y;
451			/* allocate scanline */
452			scanin = (COLR )malloc(xmaxsizeof(COLR));
453			if (scanin == NULL)
454			quiterr("out of memory in ra2ps");
455			/* convert image */
456			for (y = ymax-1; y >= 0; y--) {
457			if (freadcolrs(scanin, xmax, stdin) < 0)
458			quiterr("error reading Radiance picture");
459	gregl	2.17	if (putprim == Cputprim \|\| devgam != 1.) {
460	greg	2.15	if (bradj) /* adjust exposure */
461			shiftcolrs(scanin, xmax, bradj);
462			colrs_gambs(scanin, xmax); /* gamma compression */
463			} else
464			normcolrs(scanin, xmax, bradj);
465	greg	2.11	if (docolor) {
466	greg	2.15	(*putprim)(scanin, RED);
467			(*putprim)(scanin, GRN);
468			(*putprim)(scanin, BLU);
469	greg	2.11	} else
470	greg	2.15	(*putprim)(scanin, GRY);
471	greg	2.1	if (ferror(stdout))
472			quiterr("error writing PostScript file");
473			}
474			putchar('\n');
475			/* free scanline */
476	greg	2.24	free((void *)scanin);
477	greg	2.11	}
478
479
480	greg	2.15	int
481			Aputprim(scn, pri) /* put out hex ASCII primary from scanline */
482			COLR *scn;
483			int pri;
484			{
485			static char hexdigit[] = "0123456789ABCDEF";
486			static int col = 0;
487			register int x, c;
488
489			for (x = 0; x < xmax; x++) {
490			if (pri == GRY)
491			c = normbright(scn[x]);
492			else
493			c = scn[x][pri];
494			if (c > 255) c = 255;
495			putchar(hexdigit[c>>4]);
496			putchar(hexdigit[c&0xf]);
497			if ((col += 2) >= 72) {
498			putchar('\n');
499			col = 0;
500			}
501			}
502			}
503
504
505			int
506			Bputprim(scn, pri) /* put out binary primary from scanline */
507			COLR *scn;
508			int pri;
509			{
510			register int x, c;
511
512			for (x = 0; x < xmax; x++) {
513			if (pri == GRY)
514			c = normbright(scn[x]);
515			else
516			c = scn[x][pri];
517			if (c > 255) c = 255;
518			putchar(c);
519			}
520			}
521
522
523			int
524			Cputprim(scn, pri) /* put out compressed primary from scanline */
525	greg	2.11	COLR *scn;
526			int pri;
527			{
528			register int c;
529			register int x;
530			int lastc, cnt;
531
532			lastc = -1; cnt = 0;
533			for (x = 0; x < xmax; x++) {
534			if (pri == GRY)
535			c = normbright(scn[x]) + 2;
536			else
537			c = scn[x][pri] + 2;
538			if (c > 255) c = 255;
539			c = code[c>>2];
540			if (c == lastc && cnt < MAXRUN)
541			cnt++;
542			else {
543			putrle(cnt, lastc);
544			lastc = c;
545			cnt = 1;
546			}
547			}
548			putrle(cnt, lastc);
549	greg	2.9	}
550
551
552			putrle(cnt, cod) /* put out cnt of cod */
553			register int cnt, cod;
554			{
555			static int col = 0;
556
557			if (cnt >= MINRUN) {
558			col += 3;
559			putchar(RUNCHR);
560			putchar(RSTRT-MINRUN+cnt);
561			putchar(cod);
562			} else {
563			col += cnt;
564			while (cnt-- > 0)
565			putchar(cod);
566			}
567			if (col >= 72) {
568			putchar('\n');
569			col = 0;
570			}
571	greg	2.1	}