src/hd/rhpict.c

#ifndef lint
static const char       RCSid[] = "$Id$";
#endif
/*
 * Radiance holodeck picture generator
 */

#include "rholo.h"
#include "view.h"

char    *progname;              /* our program name */
char    *hdkfile;               /* holodeck file name */
char    gargc;                  /* global argc */
char    **gargv;                /* global argv */

VIEW    myview = STDVIEW;       /* current output view */
int     xres = 512, yres = 512; /* max. horizontal and vertical resolution */
char    *outspec = NULL;        /* output file specification */
double  randfrac = -1.;         /* random resampling fraction */
double  pixaspect = 1.;         /* pixel aspect ratio */
int     seqstart = 0;           /* sequence start frame */
double  expval = 1.;            /* exposure value */

COLOR   *mypixel;               /* pixels being rendered */
float   *myweight;              /* weights (used to compute final pixels) */
float   *mydepth;               /* depth values (visibility culling) */
int     hres, vres;             /* current horizontal and vertical res. */

extern int      nowarn;         /* turn warnings off? */


main(argc, argv)
int     argc;
char    *argv[];
{
        int     i, rval;

        gargc = argc; gargv = argv;
        progname = argv[0];                     /* get arguments */
        for (i = 1; i < argc && argv[i][0] == '-'; i++) {
                rval = getviewopt(&myview, argc-i, argv+i);
                if (rval >= 0) {                /* view option */
                        i += rval;
                        continue;
                }
                switch (argv[i][1]) {
                case 'w':                       /* turn off warnings */
                        nowarn++;
                        break;
                case 'p':                       /* pixel aspect/exposure */
                        if (badarg(argc-i-1,argv+i+1,"f"))
                                goto userr;
                        if (argv[i][2] == 'a')
                                pixaspect = atof(argv[++i]);
                        else if (argv[i][2] == 'e') {
                                expval = atof(argv[++i]);
                                if (argv[i][0] == '-' | argv[i][0] == '+')
                                        expval = pow(2., expval);
                        } else
                                goto userr;
                        break;
                case 'x':                       /* horizontal resolution */
                        if (badarg(argc-i-1,argv+i+1,"i"))
                                goto userr;
                        xres = atoi(argv[++i]);
                        break;
                case 'y':                       /* vertical resolution */
                        if (badarg(argc-i-1,argv+i+1,"i"))
                                goto userr;
                        yres = atoi(argv[++i]);
                        break;
                case 'o':                       /* output file specificaiton */
                        if (badarg(argc-i-1,argv+i+1,"s"))
                                goto userr;
                        outspec = argv[++i];
                        break;
                case 'r':                       /* random sampling */
                        if (badarg(argc-i-1,argv+i+1,"f"))
                                goto userr;
                        randfrac = atof(argv[++i]);
                        break;
                case 's':                       /* smooth sampling */
                        randfrac = -1.;
                        break;
                case 'S':                       /* sequence start */
                        if (badarg(argc-i-1,argv+i+1,"i"))
                                goto userr;
                        seqstart = atoi(argv[++i]);
                        break;
                case 'v':                       /* view file */
                        if (argv[i][2]!='f' || badarg(argc-i-1,argv+i+1,"s"))
                                goto userr;
                        rval = viewfile(argv[++i], &myview, NULL);
                        if (rval < 0) {
                                sprintf(errmsg, "cannot open view file \"%s\"",
                                                argv[i]);
                                error(SYSTEM, errmsg);
                        } else if (rval == 0) {
                                sprintf(errmsg, "bad view file \"%s\"",
                                                argv[i]);
                                error(USER, errmsg);
                        }
                        break;
                default:
                        goto userr;
                }
        }
                                                /* open holodeck file */
        if (i != argc-1)
                goto userr;
        hdkfile = argv[i];
        initialize();
                                                /* render picture(s) */
        if (seqstart <= 0)
                dopicture(0);
        else
                while (nextview(&myview, stdin) != EOF)
                        dopicture(seqstart++);
        quit(0);                                /* all done! */
userr:
        fprintf(stderr,
"Usage: %s [-w][-r rf][-pa pa][-pe ex][-x hr][-y vr][-S stfn][-o outp][view] input.hdk\n",
                        progname);
        quit(1);
}


dopicture(fn)                   /* render view from holodeck */
int     fn;
{
        char    *err;
        int     rval;
        BEAMLIST        blist;

        if ((err = setview(&myview)) != NULL) {
                sprintf(errmsg, "%s -- skipping frame %d", err, fn);
                error(WARNING, errmsg);
                return;
        }
        startpicture(fn);               /* open output picture */
                                        /* determine relevant beams */
        viewbeams(&myview, hres, vres, &blist);
                                        /* render image */
        if (blist.nb > 0) {
                render_frame(blist.bl, blist.nb);
                free((void *)blist.bl);
        } else {
                sprintf(errmsg, "no section visible in frame %d", fn);
                error(WARNING, errmsg);
        }
        rval = endpicture();            /* write pixel values */
        if (rval < 0) {
                sprintf(errmsg, "error writing frame %d", fn);
                error(SYSTEM, errmsg);
        }
#ifdef DEBUG
        if (blist.nb > 0 & rval > 0) {
                sprintf(errmsg, "%d unrendered pixels in frame %d (%.1f%%)",
                                rval, fn, 100.*rval/(hres*vres));
                error(WARNING, errmsg);
        }
#endif
}


render_frame(bl, nb)            /* render frame from beam values */
register PACKHEAD       *bl;
int     nb;
{
        extern int      pixBeam();
        register HDBEAMI        *bil;
        register int    i;

        if (nb <= 0) return;
        if ((bil = (HDBEAMI *)malloc(nb*sizeof(HDBEAMI))) == NULL)
                error(SYSTEM, "out of memory in render_frame");
        for (i = nb; i--; ) {
                bil[i].h = hdlist[bl[i].hd];
                bil[i].b = bl[i].bi;
        }
        hdloadbeams(bil, nb, pixBeam);
        pixFinish(randfrac);
        free((void *)bil);
}


startpicture(fn)                /* initialize picture for rendering & output */
int     fn;
{
        extern char     VersionID[];
        double  pa = pixaspect;
        char    fname[256];
                                /* compute picture resolution */
        hres = xres; vres = yres;
        normaspect(viewaspect(&myview), &pa, &hres, &vres);
                                /* prepare output */
        if (outspec != NULL) {
                sprintf(fname, outspec, fn);
                if (freopen(fname, "w", stdout) == NULL) {
                        sprintf(errmsg, "cannot open output \"%s\"", fname);
                        error(SYSTEM, errmsg);
                }
        }
                                /* write header */
        newheader("RADIANCE", stdout);
        printf("SOFTWARE= %s\n", VersionID);
        printargs(gargc, gargv, stdout);
        if (fn)
                printf("FRAME=%d\n", fn);
        fputs(VIEWSTR, stdout);
        fprintview(&myview, stdout);
        fputc('\n', stdout);
        if (pa < 0.99 | pa > 1.01)
                fputaspect(pa, stdout);
        if (expval < 0.99 | expval > 1.01)
                fputexpos(expval, stdout);
        fputformat(COLRFMT, stdout);
        fputc('\n', stdout);
                                /* write resolution (standard order) */
        fprtresolu(hres, vres, stdout);
                                /* prepare image buffers */
        bzero((char *)mypixel, hres*vres*sizeof(COLOR));
        bzero((char *)myweight, hres*vres*sizeof(float));
        bzero((char *)mydepth, hres*vres*sizeof(float));
}


int
endpicture()                    /* finish and write out pixels */
{
        int     lastr = -1, nunrend = 0;
        int4    lastp, lastrp;
        register int4   p;
        register double d;
                                /* compute final pixel values */
        for (p = hres*vres; p--; ) {
                if (myweight[p] <= FTINY) {
                        if (lastr >= 0)
                                if (p/hres == lastp/hres)
                                        copycolor(mypixel[p], mypixel[lastp]);
                                else
                                        copycolor(mypixel[p], mypixel[lastrp]);
                        nunrend++;
                        continue;
                }
                d = expval/myweight[p];
                scalecolor(mypixel[p], d);
                if ((lastp=p)/hres != lastr)
                        lastr = (lastrp=p)/hres;
        }
                                /* write each scanline */
        for (p = vres; p--; )
                if (fwritescan(mypixel+p*hres, hres, stdout) < 0)
                        return(-1);
        if (fflush(stdout) == EOF)
                return(-1);
        return(nunrend);
}


initialize()                    /* initialize holodeck and buffers */
{
        extern long     ftell();
        int     fd;
        FILE    *fp;
        int     n;
        int4    nextloc;
                                        /* open holodeck file */
        if ((fp = fopen(hdkfile, "r")) == NULL) {
                sprintf(errmsg, "cannot open \"%s\" for reading", hdkfile);
                error(SYSTEM, errmsg);
        }
                                        /* check header format */
        checkheader(fp, HOLOFMT, NULL);
                                        /* check magic number */
        if (getw(fp) != HOLOMAGIC) {
                sprintf(errmsg, "bad magic number in holodeck file \"%s\"",
                                hdkfile);
                error(USER, errmsg);
        }
        nextloc = ftell(fp);                    /* get stdio position */
        fd = dup(fileno(fp));                   /* dup file descriptor */
        fclose(fp);                             /* done with stdio */
        for (n = 0; nextloc > 0L; n++) {        /* initialize each section */
                lseek(fd, (off_t)nextloc, 0);
                read(fd, (char *)&nextloc, sizeof(nextloc));
                hdinit(fd, NULL);
        }
                                        /* allocate picture buffer */
        mypixel = (COLOR *)bmalloc(xres*yres*sizeof(COLOR));
        myweight = (float *)bmalloc(xres*yres*sizeof(float));
        mydepth = (float *)bmalloc(xres*yres*sizeof(float));
        if (mypixel == NULL | myweight == NULL | mydepth == NULL)
                error(SYSTEM, "out of memory in initialize");
}


void
eputs(s)                        /* put error message to stderr */
register char  *s;
{
        static int  midline = 0;

        if (!*s)
                return;
        if (!midline++) {       /* prepend line with program name */
                fputs(progname, stderr);
                fputs(": ", stderr);
        }
        fputs(s, stderr);
        if (s[strlen(s)-1] == '\n') {
                fflush(stderr);
                midline = 0;
        }
}
Revision:	3.8
Committed:	Sat Feb 22 02:07:25 2003 UTC (21 years, 2 months ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad3R5
Changes since 3.7:	+5 -8 lines
Log Message:	Changes and check-in for 3.5 release Includes new source files and modifications not recorded for many years See ray/doc/notes/ReleaseNotes for notes between 3.1 and 3.5 release
#	User	Rev	Content
1	gwlarson	3.1	#ifndef lint
2	greg	3.8	static const char RCSid[] = "$Id$";
3	gwlarson	3.1	#endif
4			/*
5			* Radiance holodeck picture generator
6			*/
7
8			#include "rholo.h"
9			#include "view.h"
10
11			char progname; / our program name */
12			char hdkfile; / holodeck file name */
13	gwlarson	3.7	char gargc; /* global argc */
14			char *gargv; / global argv */
15	gwlarson	3.1
16			VIEW myview = STDVIEW; /* current output view */
17			int xres = 512, yres = 512; /* max. horizontal and vertical resolution */
18			char outspec = NULL; / output file specification */
19	gwlarson	3.6	double randfrac = -1.; /* random resampling fraction */
20	gwlarson	3.1	double pixaspect = 1.; /* pixel aspect ratio */
21			int seqstart = 0; /* sequence start frame */
22			double expval = 1.; /* exposure value */
23
24			COLOR mypixel; / pixels being rendered */
25			float myweight; / weights (used to compute final pixels) */
26	gwlarson	3.2	float mydepth; / depth values (visibility culling) */
27	gwlarson	3.1	int hres, vres; /* current horizontal and vertical res. */
28
29			extern int nowarn; /* turn warnings off? */
30
31
32			main(argc, argv)
33			int argc;
34			char *argv[];
35			{
36			int i, rval;
37
38	gwlarson	3.7	gargc = argc; gargv = argv;
39	gwlarson	3.1	progname = argv[0]; /* get arguments */
40			for (i = 1; i < argc && argv[i][0] == '-'; i++) {
41			rval = getviewopt(&myview, argc-i, argv+i);
42			if (rval >= 0) { /* view option */
43			i += rval;
44			continue;
45			}
46			switch (argv[i][1]) {
47			case 'w': /* turn off warnings */
48			nowarn++;
49			break;
50			case 'p': /* pixel aspect/exposure */
51			if (badarg(argc-i-1,argv+i+1,"f"))
52			goto userr;
53	gwlarson	3.3	if (argv[i][2] == 'a')
54	gwlarson	3.1	pixaspect = atof(argv[++i]);
55	gwlarson	3.3	else if (argv[i][2] == 'e') {
56	gwlarson	3.1	expval = atof(argv[++i]);
57			if (argv[i][0] == '-' \| argv[i][0] == '+')
58			expval = pow(2., expval);
59			} else
60			goto userr;
61			break;
62			case 'x': /* horizontal resolution */
63			if (badarg(argc-i-1,argv+i+1,"i"))
64			goto userr;
65			xres = atoi(argv[++i]);
66			break;
67			case 'y': /* vertical resolution */
68			if (badarg(argc-i-1,argv+i+1,"i"))
69			goto userr;
70			yres = atoi(argv[++i]);
71			break;
72			case 'o': /* output file specificaiton */
73			if (badarg(argc-i-1,argv+i+1,"s"))
74			goto userr;
75			outspec = argv[++i];
76			break;
77	gwlarson	3.5	case 'r': /* random sampling */
78	gwlarson	3.6	if (badarg(argc-i-1,argv+i+1,"f"))
79			goto userr;
80			randfrac = atof(argv[++i]);
81	gwlarson	3.5	break;
82			case 's': /* smooth sampling */
83	gwlarson	3.6	randfrac = -1.;
84	gwlarson	3.5	break;
85	gwlarson	3.1	case 'S': /* sequence start */
86			if (badarg(argc-i-1,argv+i+1,"i"))
87			goto userr;
88			seqstart = atoi(argv[++i]);
89			break;
90			case 'v': /* view file */
91	gwlarson	3.4	if (argv[i][2]!='f' \|\| badarg(argc-i-1,argv+i+1,"s"))
92	gwlarson	3.1	goto userr;
93			rval = viewfile(argv[++i], &myview, NULL);
94			if (rval < 0) {
95			sprintf(errmsg, "cannot open view file \"%s\"",
96			argv[i]);
97			error(SYSTEM, errmsg);
98			} else if (rval == 0) {
99			sprintf(errmsg, "bad view file \"%s\"",
100			argv[i]);
101			error(USER, errmsg);
102			}
103			break;
104			default:
105			goto userr;
106			}
107			}
108			/* open holodeck file */
109	gwlarson	3.3	if (i != argc-1)
110	gwlarson	3.1	goto userr;
111	gwlarson	3.3	hdkfile = argv[i];
112	gwlarson	3.1	initialize();
113			/* render picture(s) */
114			if (seqstart <= 0)
115			dopicture(0);
116			else
117			while (nextview(&myview, stdin) != EOF)
118			dopicture(seqstart++);
119			quit(0); /* all done! */
120			userr:
121			fprintf(stderr,
122	gwlarson	3.6	"Usage: %s [-w][-r rf][-pa pa][-pe ex][-x hr][-y vr][-S stfn][-o outp][view] input.hdk\n",
123	gwlarson	3.1	progname);
124			quit(1);
125			}
126
127
128			dopicture(fn) /* render view from holodeck */
129			int fn;
130			{
131			char *err;
132			int rval;
133			BEAMLIST blist;
134
135			if ((err = setview(&myview)) != NULL) {
136			sprintf(errmsg, "%s -- skipping frame %d", err, fn);
137			error(WARNING, errmsg);
138			return;
139			}
140			startpicture(fn); /* open output picture */
141			/* determine relevant beams */
142			viewbeams(&myview, hres, vres, &blist);
143			/* render image */
144			if (blist.nb > 0) {
145			render_frame(blist.bl, blist.nb);
146	greg	3.8	free((void *)blist.bl);
147	gwlarson	3.1	} else {
148			sprintf(errmsg, "no section visible in frame %d", fn);
149			error(WARNING, errmsg);
150			}
151			rval = endpicture(); /* write pixel values */
152			if (rval < 0) {
153			sprintf(errmsg, "error writing frame %d", fn);
154			error(SYSTEM, errmsg);
155			}
156	gwlarson	3.3	#ifdef DEBUG
157	gwlarson	3.1	if (blist.nb > 0 & rval > 0) {
158	gwlarson	3.3	sprintf(errmsg, "%d unrendered pixels in frame %d (%.1f%%)",
159			rval, fn, 100.rval/(hresvres));
160	gwlarson	3.1	error(WARNING, errmsg);
161			}
162	gwlarson	3.3	#endif
163	gwlarson	3.1	}
164
165
166			render_frame(bl, nb) /* render frame from beam values */
167			register PACKHEAD *bl;
168			int nb;
169			{
170	gwlarson	3.2	extern int pixBeam();
171	gwlarson	3.1	register HDBEAMI *bil;
172			register int i;
173
174			if (nb <= 0) return;
175			if ((bil = (HDBEAMI )malloc(nbsizeof(HDBEAMI))) == NULL)
176			error(SYSTEM, "out of memory in render_frame");
177			for (i = nb; i--; ) {
178			bil[i].h = hdlist[bl[i].hd];
179			bil[i].b = bl[i].bi;
180			}
181	gwlarson	3.2	hdloadbeams(bil, nb, pixBeam);
182	gwlarson	3.6	pixFinish(randfrac);
183	greg	3.8	free((void *)bil);
184	gwlarson	3.1	}
185
186
187			startpicture(fn) /* initialize picture for rendering & output */
188			int fn;
189			{
190			extern char VersionID[];
191			double pa = pixaspect;
192			char fname[256];
193			/* compute picture resolution */
194			hres = xres; vres = yres;
195			normaspect(viewaspect(&myview), &pa, &hres, &vres);
196			/* prepare output */
197			if (outspec != NULL) {
198			sprintf(fname, outspec, fn);
199			if (freopen(fname, "w", stdout) == NULL) {
200			sprintf(errmsg, "cannot open output \"%s\"", fname);
201			error(SYSTEM, errmsg);
202			}
203			}
204			/* write header */
205			newheader("RADIANCE", stdout);
206			printf("SOFTWARE= %s\n", VersionID);
207	gwlarson	3.7	printargs(gargc, gargv, stdout);
208	gwlarson	3.1	if (fn)
209			printf("FRAME=%d\n", fn);
210			fputs(VIEWSTR, stdout);
211			fprintview(&myview, stdout);
212			fputc('\n', stdout);
213			if (pa < 0.99 \| pa > 1.01)
214			fputaspect(pa, stdout);
215			if (expval < 0.99 \| expval > 1.01)
216			fputexpos(expval, stdout);
217			fputformat(COLRFMT, stdout);
218			fputc('\n', stdout);
219			/* write resolution (standard order) */
220			fprtresolu(hres, vres, stdout);
221			/* prepare image buffers */
222			bzero((char )mypixel, hresvres*sizeof(COLOR));
223			bzero((char )myweight, hresvres*sizeof(float));
224	gwlarson	3.2	bzero((char )mydepth, hresvres*sizeof(float));
225	gwlarson	3.1	}
226
227
228			int
229			endpicture() /* finish and write out pixels */
230			{
231	gwlarson	3.4	int lastr = -1, nunrend = 0;
232			int4 lastp, lastrp;
233			register int4 p;
234	gwlarson	3.1	register double d;
235			/* compute final pixel values */
236			for (p = hres*vres; p--; ) {
237			if (myweight[p] <= FTINY) {
238	gwlarson	3.4	if (lastr >= 0)
239			if (p/hres == lastp/hres)
240			copycolor(mypixel[p], mypixel[lastp]);
241			else
242			copycolor(mypixel[p], mypixel[lastrp]);
243	gwlarson	3.1	nunrend++;
244			continue;
245			}
246			d = expval/myweight[p];
247			scalecolor(mypixel[p], d);
248	gwlarson	3.4	if ((lastp=p)/hres != lastr)
249			lastr = (lastrp=p)/hres;
250	gwlarson	3.1	}
251			/* write each scanline */
252	gwlarson	3.4	for (p = vres; p--; )
253			if (fwritescan(mypixel+p*hres, hres, stdout) < 0)
254	gwlarson	3.1	return(-1);
255			if (fflush(stdout) == EOF)
256			return(-1);
257			return(nunrend);
258			}
259
260
261			initialize() /* initialize holodeck and buffers */
262			{
263			extern long ftell();
264			int fd;
265			FILE *fp;
266			int n;
267			int4 nextloc;
268			/* open holodeck file */
269			if ((fp = fopen(hdkfile, "r")) == NULL) {
270			sprintf(errmsg, "cannot open \"%s\" for reading", hdkfile);
271			error(SYSTEM, errmsg);
272			}
273			/* check header format */
274			checkheader(fp, HOLOFMT, NULL);
275			/* check magic number */
276			if (getw(fp) != HOLOMAGIC) {
277			sprintf(errmsg, "bad magic number in holodeck file \"%s\"",
278			hdkfile);
279			error(USER, errmsg);
280			}
281			nextloc = ftell(fp); /* get stdio position */
282			fd = dup(fileno(fp)); /* dup file descriptor */
283			fclose(fp); /* done with stdio */
284			for (n = 0; nextloc > 0L; n++) { /* initialize each section */
285	greg	3.8	lseek(fd, (off_t)nextloc, 0);
286	gwlarson	3.1	read(fd, (char *)&nextloc, sizeof(nextloc));
287			hdinit(fd, NULL);
288			}
289			/* allocate picture buffer */
290			mypixel = (COLOR )bmalloc(xresyres*sizeof(COLOR));
291			myweight = (float )bmalloc(xresyres*sizeof(float));
292	gwlarson	3.2	mydepth = (float )bmalloc(xresyres*sizeof(float));
293			if (mypixel == NULL \| myweight == NULL \| mydepth == NULL)
294	gwlarson	3.1	error(SYSTEM, "out of memory in initialize");
295			}
296
297
298	greg	3.8	void
299	gwlarson	3.1	eputs(s) /* put error message to stderr */
300			register char *s;
301			{
302			static int midline = 0;
303
304			if (!*s)
305			return;
306			if (!midline++) { /* prepend line with program name */
307			fputs(progname, stderr);
308			fputs(": ", stderr);
309			}
310			fputs(s, stderr);
311			if (s[strlen(s)-1] == '\n') {
312			fflush(stderr);
313			midline = 0;
314			}
315			}