ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/rt/rtrace.c
Revision: 2.59
Committed: Sun Dec 13 19:13:04 2009 UTC (14 years, 4 months ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.58: +72 -50 lines
Log Message:
Eliminated restriction with -n and -I in rtrace

File Contents

# Content
1 #ifndef lint
2 static const char RCSid[] = "$Id: rtrace.c,v 2.58 2009/12/12 23:08:13 greg Exp $";
3 #endif
4 /*
5 * rtrace.c - program and variables for individual ray tracing.
6 */
7
8 #include "copyright.h"
9
10 /*
11 * Input is in the form:
12 *
13 * xorg yorg zorg xdir ydir zdir
14 *
15 * The direction need not be normalized. Output is flexible.
16 * If the direction vector is (0,0,0), then the output is flushed.
17 * All values default to ascii representation of real
18 * numbers. Binary representations can be selected
19 * with '-ff' for float or '-fd' for double. By default,
20 * radiance is computed. The '-i' or '-I' options indicate that
21 * irradiance values are desired.
22 */
23
24 #include <time.h>
25
26 #include "platform.h"
27 #include "ray.h"
28 #include "ambient.h"
29 #include "source.h"
30 #include "otypes.h"
31 #include "resolu.h"
32 #include "random.h"
33
34 extern int inform; /* input format */
35 extern int outform; /* output format */
36 extern char *outvals; /* output values */
37
38 extern int imm_irrad; /* compute immediate irradiance? */
39 extern int lim_dist; /* limit distance? */
40
41 extern char *tralist[]; /* list of modifers to trace (or no) */
42 extern int traincl; /* include == 1, exclude == 0 */
43
44 extern int hresolu; /* horizontal resolution */
45 extern int vresolu; /* vertical resolution */
46
47 static int castonly = 0;
48
49 #ifndef MAXTSET
50 #define MAXTSET 8191 /* maximum number in trace set */
51 #endif
52 OBJECT traset[MAXTSET+1]={0}; /* trace include/exclude set */
53
54 static RAY thisray; /* for our convenience */
55
56 typedef void putf_t(double v);
57 static putf_t puta, putd, putf;
58
59 typedef void oputf_t(RAY *r);
60 static oputf_t oputo, oputd, oputv, oputV, oputl, oputL, oputc, oputp,
61 oputn, oputN, oputs, oputw, oputW, oputm, oputM, oputtilde;
62
63 static void setoutput(char *vs);
64 extern void tranotify(OBJECT obj);
65 static void bogusray(void);
66 static void raycast(RAY *r);
67 static void rayirrad(RAY *r);
68 static void rtcompute(FVECT org, FVECT dir, double dmax);
69 static int printvals(RAY *r);
70 static int getvec(FVECT vec, int fmt, FILE *fp);
71 static void tabin(RAY *r);
72 static void ourtrace(RAY *r);
73
74 static oputf_t *ray_out[16], *every_out[16];
75 static putf_t *putreal;
76
77
78 void
79 quit( /* quit program */
80 int code
81 )
82 {
83 if (ray_pnprocs > 0) /* close children if any */
84 ray_pclose(0);
85 #ifndef NON_POSIX
86 else if (!ray_pnprocs) {
87 headclean(); /* delete header file */
88 pfclean(); /* clean up persist files */
89 }
90 #endif
91 exit(code);
92 }
93
94
95 char *
96 formstr( /* return format identifier */
97 int f
98 )
99 {
100 switch (f) {
101 case 'a': return("ascii");
102 case 'f': return("float");
103 case 'd': return("double");
104 case 'c': return(COLRFMT);
105 }
106 return("unknown");
107 }
108
109
110 extern void
111 rtrace( /* trace rays from file */
112 char *fname,
113 int nproc
114 )
115 {
116 unsigned long vcount = (hresolu > 1) ? (unsigned long)hresolu*vresolu
117 : vresolu;
118 long nextflush = hresolu;
119 FILE *fp;
120 double d;
121 FVECT orig, direc;
122 /* set up input */
123 if (fname == NULL)
124 fp = stdin;
125 else if ((fp = fopen(fname, "r")) == NULL) {
126 sprintf(errmsg, "cannot open input file \"%s\"", fname);
127 error(SYSTEM, errmsg);
128 }
129 if (inform != 'a')
130 SET_FILE_BINARY(fp);
131 /* set up output */
132 setoutput(outvals);
133 if (imm_irrad)
134 castonly = 0;
135 else if (castonly)
136 nproc = 1; /* don't bother multiprocessing */
137 switch (outform) {
138 case 'a': putreal = puta; break;
139 case 'f': putreal = putf; break;
140 case 'd': putreal = putd; break;
141 case 'c':
142 if (strcmp(outvals, "v"))
143 error(USER, "color format with value output only");
144 break;
145 default:
146 error(CONSISTENCY, "botched output format");
147 }
148 if (nproc > 1) { /* start multiprocessing */
149 ray_popen(nproc);
150 ray_fifo_out = printvals;
151 }
152 if (hresolu > 0) {
153 if (vresolu > 0)
154 fprtresolu(hresolu, vresolu, stdout);
155 fflush(stdout);
156 }
157 /* process file */
158 while (getvec(orig, inform, fp) == 0 &&
159 getvec(direc, inform, fp) == 0) {
160
161 d = normalize(direc);
162 if (d == 0.0) { /* zero ==> flush */
163 if (nproc > 1 && ray_fifo_flush() < 0)
164 error(USER, "lost children");
165 bogusray();
166 if (--nextflush <= 0 || !vcount) {
167 fflush(stdout);
168 nextflush = hresolu;
169 }
170 } else { /* compute and print */
171 rtcompute(orig, direc, lim_dist ? d : 0.0);
172 /* flush if time */
173 if (!--nextflush) {
174 if (nproc > 1 && ray_fifo_flush() < 0)
175 error(USER, "lost children");
176 fflush(stdout);
177 nextflush = hresolu;
178 }
179 }
180 if (ferror(stdout))
181 error(SYSTEM, "write error");
182 if (vcount && !--vcount) /* check for end */
183 break;
184 }
185 if (nproc > 1) { /* clean up children */
186 if (ray_fifo_flush() < 0)
187 error(USER, "unable to complete processing");
188 ray_pclose(0);
189 }
190 if (fflush(stdout) < 0)
191 error(SYSTEM, "write error");
192 if (vcount)
193 error(USER, "unexpected EOF on input");
194 if (fname != NULL)
195 fclose(fp);
196 }
197
198
199 static void
200 trace_sources(void) /* trace rays to light sources, also */
201 {
202 int sn;
203
204 for (sn = 0; sn < nsources; sn++)
205 source[sn].sflags |= SFOLLOW;
206 }
207
208
209 static void
210 setoutput( /* set up output tables */
211 char *vs
212 )
213 {
214 oputf_t **table = ray_out;
215
216 castonly = 1;
217 while (*vs)
218 switch (*vs++) {
219 case 'T': /* trace sources */
220 if (!*vs) break;
221 trace_sources();
222 /* fall through */
223 case 't': /* trace */
224 if (!*vs) break;
225 *table = NULL;
226 table = every_out;
227 trace = ourtrace;
228 castonly = 0;
229 break;
230 case 'o': /* origin */
231 *table++ = oputo;
232 break;
233 case 'd': /* direction */
234 *table++ = oputd;
235 break;
236 case 'v': /* value */
237 *table++ = oputv;
238 castonly = 0;
239 break;
240 case 'V': /* contribution */
241 *table++ = oputV;
242 if (ambounce > 0 && (ambacc > FTINY || ambssamp > 0))
243 error(WARNING,
244 "-otV accuracy depends on -aa 0 -as 0");
245 break;
246 case 'l': /* effective distance */
247 *table++ = oputl;
248 castonly = 0;
249 break;
250 case 'c': /* local coordinates */
251 *table++ = oputc;
252 break;
253 case 'L': /* single ray length */
254 *table++ = oputL;
255 break;
256 case 'p': /* point */
257 *table++ = oputp;
258 break;
259 case 'n': /* perturbed normal */
260 *table++ = oputn;
261 castonly = 0;
262 break;
263 case 'N': /* unperturbed normal */
264 *table++ = oputN;
265 break;
266 case 's': /* surface */
267 *table++ = oputs;
268 break;
269 case 'w': /* weight */
270 *table++ = oputw;
271 break;
272 case 'W': /* coefficient */
273 *table++ = oputW;
274 if (ambounce > 0 && (ambacc > FTINY || ambssamp > 0))
275 error(WARNING,
276 "-otW accuracy depends on -aa 0 -as 0");
277 break;
278 case 'm': /* modifier */
279 *table++ = oputm;
280 break;
281 case 'M': /* material */
282 *table++ = oputM;
283 break;
284 case '~': /* tilde */
285 *table++ = oputtilde;
286 break;
287 }
288 *table = NULL;
289 }
290
291
292 static void
293 bogusray(void) /* print out empty record */
294 {
295 thisray.rorg[0] = thisray.rorg[1] = thisray.rorg[2] =
296 thisray.rdir[0] = thisray.rdir[1] = thisray.rdir[2] = 0.0;
297 thisray.rmax = 0.0;
298 rayorigin(&thisray, PRIMARY, NULL, NULL);
299 printvals(&thisray);
300 }
301
302
303 static void
304 raycast( /* compute first ray intersection only */
305 RAY *r
306 )
307 {
308 if (!localhit(r, &thescene)) {
309 if (r->ro == &Aftplane) { /* clipped */
310 r->ro = NULL;
311 r->rot = FHUGE;
312 } else
313 sourcehit(r);
314 }
315 }
316
317
318 static void
319 rayirrad( /* compute irradiance rather than radiance */
320 RAY *r
321 )
322 {
323 r->rot = 1e-5; /* pretend we hit surface */
324 VSUM(r->rop, r->rorg, r->rdir, r->rot);
325 r->ron[0] = -r->rdir[0];
326 r->ron[1] = -r->rdir[1];
327 r->ron[2] = -r->rdir[2];
328 r->rod = 1.0;
329 /* compute result */
330 (*ofun[Lamb.otype].funp)(&Lamb, r);
331 }
332
333
334 static void
335 rtcompute( /* compute and print ray value(s) */
336 FVECT org,
337 FVECT dir,
338 double dmax
339 )
340 {
341 if (imm_irrad) { /* set up ray */
342 VSUM(thisray.rorg, org, dir, 1.1e-4);
343 thisray.rdir[0] = -dir[0];
344 thisray.rdir[1] = -dir[1];
345 thisray.rdir[2] = -dir[2];
346 thisray.rmax = 0.0;
347 } else {
348 VCOPY(thisray.rorg, org);
349 VCOPY(thisray.rdir, dir);
350 thisray.rmax = dmax;
351 }
352 rayorigin(&thisray, PRIMARY, NULL, NULL);
353 /* special case evaluators */
354 if (castonly)
355 thisray.revf = raycast;
356 else if (imm_irrad)
357 thisray.revf = rayirrad;
358
359 if (ray_pnprocs > 1) { /* multiprocessing FIFO? */
360 if (ray_fifo_in(&thisray) < 0)
361 error(USER, "lost children");
362 return;
363 }
364 samplendx++; /* else do it ourselves */
365 rayvalue(&thisray);
366 printvals(&thisray);
367 }
368
369
370 static int
371 printvals( /* print requested ray values */
372 RAY *r
373 )
374 {
375 oputf_t **tp;
376
377 if (ray_out[0] == NULL)
378 return(0);
379 for (tp = ray_out; *tp != NULL; tp++)
380 (**tp)(r);
381 if (outform == 'a')
382 putchar('\n');
383 return(1);
384 }
385
386
387 static int
388 getvec( /* get a vector from fp */
389 FVECT vec,
390 int fmt,
391 FILE *fp
392 )
393 {
394 static float vf[3];
395 static double vd[3];
396 char buf[32];
397 int i;
398
399 switch (fmt) {
400 case 'a': /* ascii */
401 for (i = 0; i < 3; i++) {
402 if (fgetword(buf, sizeof(buf), fp) == NULL ||
403 !isflt(buf))
404 return(-1);
405 vec[i] = atof(buf);
406 }
407 break;
408 case 'f': /* binary float */
409 if (fread((char *)vf, sizeof(float), 3, fp) != 3)
410 return(-1);
411 VCOPY(vec, vf);
412 break;
413 case 'd': /* binary double */
414 if (fread((char *)vd, sizeof(double), 3, fp) != 3)
415 return(-1);
416 VCOPY(vec, vd);
417 break;
418 default:
419 error(CONSISTENCY, "botched input format");
420 }
421 return(0);
422 }
423
424
425 void
426 tranotify( /* record new modifier */
427 OBJECT obj
428 )
429 {
430 static int hitlimit = 0;
431 OBJREC *o = objptr(obj);
432 char **tralp;
433
434 if (obj == OVOID) { /* starting over */
435 traset[0] = 0;
436 hitlimit = 0;
437 return;
438 }
439 if (hitlimit || !ismodifier(o->otype))
440 return;
441 for (tralp = tralist; *tralp != NULL; tralp++)
442 if (!strcmp(o->oname, *tralp)) {
443 if (traset[0] >= MAXTSET) {
444 error(WARNING, "too many modifiers in trace list");
445 hitlimit++;
446 return; /* should this be fatal? */
447 }
448 insertelem(traset, obj);
449 return;
450 }
451 }
452
453
454 static void
455 ourtrace( /* print ray values */
456 RAY *r
457 )
458 {
459 oputf_t **tp;
460
461 if (every_out[0] == NULL)
462 return;
463 if (r->ro == NULL) {
464 if (traincl == 1)
465 return;
466 } else if (traincl != -1 && traincl != inset(traset, r->ro->omod))
467 return;
468 tabin(r);
469 for (tp = every_out; *tp != NULL; tp++)
470 (**tp)(r);
471 if (outform == 'a')
472 putchar('\n');
473 }
474
475
476 static void
477 tabin( /* tab in appropriate amount */
478 RAY *r
479 )
480 {
481 const RAY *rp;
482
483 for (rp = r->parent; rp != NULL; rp = rp->parent)
484 putchar('\t');
485 }
486
487
488 static void
489 oputo( /* print origin */
490 RAY *r
491 )
492 {
493 (*putreal)(r->rorg[0]);
494 (*putreal)(r->rorg[1]);
495 (*putreal)(r->rorg[2]);
496 }
497
498
499 static void
500 oputd( /* print direction */
501 RAY *r
502 )
503 {
504 (*putreal)(r->rdir[0]);
505 (*putreal)(r->rdir[1]);
506 (*putreal)(r->rdir[2]);
507 }
508
509
510 static void
511 oputv( /* print value */
512 RAY *r
513 )
514 {
515 if (outform == 'c') {
516 COLR cout;
517 setcolr(cout, colval(r->rcol,RED),
518 colval(r->rcol,GRN),
519 colval(r->rcol,BLU));
520 fwrite((char *)cout, sizeof(cout), 1, stdout);
521 return;
522 }
523 (*putreal)(colval(r->rcol,RED));
524 (*putreal)(colval(r->rcol,GRN));
525 (*putreal)(colval(r->rcol,BLU));
526 }
527
528
529 static void
530 oputV( /* print value contribution */
531 RAY *r
532 )
533 {
534 double contr[3];
535
536 raycontrib(contr, r, PRIMARY);
537 multcolor(contr, r->rcol);
538 (*putreal)(contr[RED]);
539 (*putreal)(contr[GRN]);
540 (*putreal)(contr[BLU]);
541 }
542
543
544 static void
545 oputl( /* print effective distance */
546 RAY *r
547 )
548 {
549 (*putreal)(r->rt);
550 }
551
552
553 static void
554 oputL( /* print single ray length */
555 RAY *r
556 )
557 {
558 (*putreal)(r->rot);
559 }
560
561
562 static void
563 oputc( /* print local coordinates */
564 RAY *r
565 )
566 {
567 (*putreal)(r->uv[0]);
568 (*putreal)(r->uv[1]);
569 }
570
571
572 static void
573 oputp( /* print point */
574 RAY *r
575 )
576 {
577 if (r->rot < FHUGE) {
578 (*putreal)(r->rop[0]);
579 (*putreal)(r->rop[1]);
580 (*putreal)(r->rop[2]);
581 } else {
582 (*putreal)(0.0);
583 (*putreal)(0.0);
584 (*putreal)(0.0);
585 }
586 }
587
588
589 static void
590 oputN( /* print unperturbed normal */
591 RAY *r
592 )
593 {
594 if (r->rot < FHUGE) {
595 (*putreal)(r->ron[0]);
596 (*putreal)(r->ron[1]);
597 (*putreal)(r->ron[2]);
598 } else {
599 (*putreal)(0.0);
600 (*putreal)(0.0);
601 (*putreal)(0.0);
602 }
603 }
604
605
606 static void
607 oputn( /* print perturbed normal */
608 RAY *r
609 )
610 {
611 FVECT pnorm;
612
613 if (r->rot >= FHUGE) {
614 (*putreal)(0.0);
615 (*putreal)(0.0);
616 (*putreal)(0.0);
617 return;
618 }
619 raynormal(pnorm, r);
620 (*putreal)(pnorm[0]);
621 (*putreal)(pnorm[1]);
622 (*putreal)(pnorm[2]);
623 }
624
625
626 static void
627 oputs( /* print name */
628 RAY *r
629 )
630 {
631 if (r->ro != NULL)
632 fputs(r->ro->oname, stdout);
633 else
634 putchar('*');
635 putchar('\t');
636 }
637
638
639 static void
640 oputw( /* print weight */
641 RAY *r
642 )
643 {
644 (*putreal)(r->rweight);
645 }
646
647
648 static void
649 oputW( /* print coefficient */
650 RAY *r
651 )
652 {
653 double contr[3];
654
655 raycontrib(contr, r, PRIMARY);
656 (*putreal)(contr[RED]);
657 (*putreal)(contr[GRN]);
658 (*putreal)(contr[BLU]);
659 }
660
661
662 static void
663 oputm( /* print modifier */
664 RAY *r
665 )
666 {
667 if (r->ro != NULL)
668 if (r->ro->omod != OVOID)
669 fputs(objptr(r->ro->omod)->oname, stdout);
670 else
671 fputs(VOIDID, stdout);
672 else
673 putchar('*');
674 putchar('\t');
675 }
676
677
678 static void
679 oputM( /* print material */
680 RAY *r
681 )
682 {
683 OBJREC *mat;
684
685 if (r->ro != NULL) {
686 if ((mat = findmaterial(r->ro)) != NULL)
687 fputs(mat->oname, stdout);
688 else
689 fputs(VOIDID, stdout);
690 } else
691 putchar('*');
692 putchar('\t');
693 }
694
695
696 static void
697 oputtilde( /* output tilde (spacer) */
698 RAY *r
699 )
700 {
701 fputs("~\t", stdout);
702 }
703
704
705 static void
706 puta( /* print ascii value */
707 double v
708 )
709 {
710 printf("%e\t", v);
711 }
712
713
714 static void
715 putd(v) /* print binary double */
716 double v;
717 {
718 fwrite((char *)&v, sizeof(v), 1, stdout);
719 }
720
721
722 static void
723 putf(v) /* print binary float */
724 double v;
725 {
726 float f = v;
727
728 fwrite((char *)&f, sizeof(f), 1, stdout);
729 }