ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/rt/rtrace.c
Revision: 2.42
Committed: Thu May 26 06:55:22 2005 UTC (18 years, 11 months ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.41: +9 -8 lines
Log Message: 
Got rtcontrib working and wrote basic man page

File Contents

# User Rev Content
1 greg 1.1 #ifndef lint
2 greg 2.42 static const char RCSid[] = "$Id: rtrace.c,v 2.41 2005/05/25 04:44:26 greg Exp $";
3 greg 1.1 #endif
4     /*
5     * rtrace.c - program and variables for individual ray tracing.
6 greg 2.27 */
7    
8 greg 2.28 #include "copyright.h"
9 greg 1.1
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 greg 1.7 * If the direction vector is (0,0,0), then the output is flushed.
17 greg 1.1 * 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 greg 1.13 * radiance is computed. The '-i' or '-I' options indicate that
21 greg 1.1 * irradiance values are desired.
22     */
23 greg 2.32
24     #include <time.h>
25 greg 1.1
26 schorsch 2.30 #include "platform.h"
27 greg 1.1 #include "ray.h"
28 schorsch 2.37 #include "ambient.h"
29     #include "source.h"
30 greg 1.1 #include "otypes.h"
31 greg 2.6 #include "resolu.h"
32    
33 greg 2.27 CUBE thescene; /* our scene */
34     OBJECT nsceneobjs; /* number of objects in our scene */
35    
36 greg 1.14 int dimlist[MAXDIM]; /* sampling dimensions */
37     int ndims = 0; /* number of sampling dimensions */
38     int samplendx = 0; /* index for this sample */
39    
40 greg 1.13 int imm_irrad = 0; /* compute immediate irradiance? */
41 gregl 2.25 int lim_dist = 0; /* limit distance? */
42 greg 1.13
43 greg 1.1 int inform = 'a'; /* input format */
44     int outform = 'a'; /* output format */
45     char *outvals = "v"; /* output specification */
46    
47 greg 2.27 int do_irrad = 0; /* compute irradiance? */
48    
49     void (*trace)() = NULL; /* trace call */
50    
51 greg 2.15 char *tralist[128]; /* list of modifers to trace (or no) */
52     int traincl = -1; /* include == 1, exclude == 0 */
53     #define MAXTSET 511 /* maximum number in trace set */
54     OBJECT traset[MAXTSET+1]={0}; /* trace include/exclude set */
55    
56 greg 1.1 int hresolu = 0; /* horizontal (scan) size */
57     int vresolu = 0; /* vertical resolution */
58    
59     double dstrsrc = 0.0; /* square source distribution */
60 greg 2.35 double shadthresh = .03; /* shadow threshold */
61     double shadcert = .75; /* shadow certainty */
62 greg 2.19 int directrelay = 2; /* number of source relays */
63 greg 1.17 int vspretest = 512; /* virtual source pretest density */
64 greg 2.10 int directvis = 1; /* sources visible? */
65 greg 2.19 double srcsizerat = .2; /* maximum ratio source size/dist. */
66 greg 2.20
67     COLOR cextinction = BLKCOLOR; /* global extinction coefficient */
68 greg 2.22 COLOR salbedo = BLKCOLOR; /* global scattering albedo */
69 greg 2.20 double seccg = 0.; /* global scattering eccentricity */
70     double ssampdist = 0.; /* scatter sampling distance */
71 greg 1.1
72 greg 2.4 double specthresh = .15; /* specular sampling threshold */
73 greg 2.3 double specjitter = 1.; /* specular sampling jitter */
74    
75 greg 2.18 int backvis = 1; /* back face visibility */
76    
77 greg 2.34 int maxdepth = 8; /* maximum recursion depth */
78     double minweight = 2e-3; /* minimum ray weight */
79 greg 1.1
80 greg 2.27 char *ambfile = NULL; /* ambient file name */
81 greg 1.1 COLOR ambval = BLKCOLOR; /* ambient value */
82 greg 2.21 int ambvwt = 0; /* initial weight for ambient value */
83 greg 2.36 double ambacc = 0.15; /* ambient accuracy */
84 greg 2.34 int ambres = 256; /* ambient resolution */
85     int ambdiv = 1024; /* ambient divisions */
86     int ambssamp = 512; /* ambient super-samples */
87 greg 1.1 int ambounce = 0; /* ambient bounces */
88 greg 2.38 char *amblist[AMBLLEN]; /* ambient include/exclude list */
89 greg 1.1 int ambincl = -1; /* include == 1, exclude == 0 */
90    
91 schorsch 2.37 static int castonly = 0;
92 gregl 2.25
93 greg 1.1 static RAY thisray; /* for our convenience */
94    
95 schorsch 2.37 typedef void putf_t(double v);
96     static putf_t puta, putd, putf;
97 greg 1.1
98 schorsch 2.37 typedef void oputf_t(RAY *r);
99 greg 2.40 static oputf_t oputo, oputd, oputv, oputl, oputL, oputc, oputp,
100 greg 2.42 oputn, oputN, oputs, oputw, oputW, oputm, oputM, oputtilde;
101 schorsch 2.37
102     static void setoutput(char *vs);
103     static void tranotify(OBJECT obj);
104     static void bogusray(void);
105     static void rad(FVECT org, FVECT dir, double dmax);
106     static void irrad(FVECT org, FVECT dir);
107     static void printvals(RAY *r);
108     static int getvec(FVECT vec, int fmt, FILE *fp);
109     static void tabin(RAY *r);
110     static void ourtrace(RAY *r);
111 greg 1.1
112 schorsch 2.37 static oputf_t *ray_out[16], *every_out[16];
113     static putf_t *putreal;
114 greg 2.27
115 schorsch 2.37 void (*addobjnotify[])() = {ambnotify, tranotify, NULL};
116 greg 1.1
117    
118 greg 2.27 void
119 schorsch 2.37 quit( /* quit program */
120     int code
121     )
122 greg 1.1 {
123 schorsch 2.31 #ifndef NON_POSIX /* XXX we don't clean up elsewhere? */
124 greg 2.11 headclean(); /* delete header file */
125     pfclean(); /* clean up persist files */
126     #endif
127 greg 1.1 exit(code);
128     }
129    
130    
131 schorsch 2.37 extern char *
132     formstr( /* return format identifier */
133     int f
134     )
135 greg 2.6 {
136     switch (f) {
137     case 'a': return("ascii");
138     case 'f': return("float");
139     case 'd': return("double");
140     case 'c': return(COLRFMT);
141     }
142     return("unknown");
143     }
144    
145    
146 schorsch 2.37 extern void
147     rtrace( /* trace rays from file */
148     char *fname
149     )
150 greg 1.1 {
151     long vcount = hresolu>1 ? hresolu*vresolu : vresolu;
152     long nextflush = hresolu;
153     FILE *fp;
154 gregl 2.25 double d;
155 greg 1.2 FVECT orig, direc;
156 greg 1.1 /* set up input */
157     if (fname == NULL)
158     fp = stdin;
159     else if ((fp = fopen(fname, "r")) == NULL) {
160     sprintf(errmsg, "cannot open input file \"%s\"", fname);
161     error(SYSTEM, errmsg);
162     }
163 schorsch 2.30 #ifdef _WIN32
164 greg 2.8 if (inform != 'a')
165 schorsch 2.30 SET_FILE_BINARY(fp);
166 greg 2.8 #endif
167 greg 1.1 /* set up output */
168 greg 2.16 setoutput(outvals);
169 greg 1.1 switch (outform) {
170     case 'a': putreal = puta; break;
171     case 'f': putreal = putf; break;
172     case 'd': putreal = putd; break;
173 greg 2.6 case 'c':
174     if (strcmp(outvals, "v"))
175     error(USER, "color format with value output only");
176     break;
177     default:
178     error(CONSISTENCY, "botched output format");
179 greg 1.1 }
180 greg 2.12 if (hresolu > 0) {
181     if (vresolu > 0)
182     fprtresolu(hresolu, vresolu, stdout);
183     fflush(stdout);
184     }
185 greg 1.1 /* process file */
186     while (getvec(orig, inform, fp) == 0 &&
187     getvec(direc, inform, fp) == 0) {
188    
189 gregl 2.25 d = normalize(direc);
190     if (d == 0.0) { /* zero ==> flush */
191 gregl 2.24 bogusray();
192 gregl 2.26 if (--nextflush <= 0 || vcount <= 0) {
193 gregl 2.24 fflush(stdout);
194     nextflush = hresolu;
195     }
196     } else {
197     samplendx++;
198 greg 1.1 /* compute and print */
199 gregl 2.24 if (imm_irrad)
200     irrad(orig, direc);
201     else
202 gregl 2.25 rad(orig, direc, lim_dist ? d : 0.0);
203 greg 1.7 /* flush if time */
204 gregl 2.24 if (--nextflush == 0) {
205     fflush(stdout);
206     nextflush = hresolu;
207     }
208 greg 1.1 }
209     if (ferror(stdout))
210     error(SYSTEM, "write error");
211     if (--vcount == 0) /* check for end */
212     break;
213     }
214 greg 2.12 fflush(stdout);
215 greg 1.1 if (vcount > 0)
216 greg 2.42 error(USER, "unexpected EOF on input");
217 greg 2.12 if (fname != NULL)
218     fclose(fp);
219 greg 1.1 }
220    
221    
222 schorsch 2.37 static void
223 greg 2.40 trace_sources(void) /* trace rays to light sources, also */
224     {
225     int sn;
226    
227     for (sn = 0; sn < nsources; sn++)
228     source[sn].sflags |= SFOLLOW;
229     }
230    
231    
232     static void
233 schorsch 2.37 setoutput( /* set up output tables */
234     register char *vs
235     )
236 greg 1.1 {
237 schorsch 2.37 register oputf_t **table = ray_out;
238 greg 1.1
239 greg 1.11 castonly = 1;
240 greg 1.1 while (*vs)
241     switch (*vs++) {
242 greg 2.40 case 'T': /* trace sources */
243 greg 2.42 if (!*vs) break;
244 greg 2.40 trace_sources();
245     /* fall through */
246 greg 1.1 case 't': /* trace */
247 greg 2.42 if (!*vs) break;
248 greg 1.1 *table = NULL;
249     table = every_out;
250     trace = ourtrace;
251 greg 1.11 castonly = 0;
252 greg 1.1 break;
253     case 'o': /* origin */
254     *table++ = oputo;
255     break;
256     case 'd': /* direction */
257     *table++ = oputd;
258     break;
259     case 'v': /* value */
260     *table++ = oputv;
261 greg 1.11 castonly = 0;
262 greg 1.1 break;
263 greg 2.5 case 'l': /* effective distance */
264 greg 1.1 *table++ = oputl;
265 greg 1.11 castonly = 0;
266 greg 1.1 break;
267 greg 2.29 case 'c': /* local coordinates */
268     *table++ = oputc;
269     break;
270 greg 2.5 case 'L': /* single ray length */
271     *table++ = oputL;
272     break;
273 greg 1.1 case 'p': /* point */
274     *table++ = oputp;
275     break;
276 greg 2.9 case 'n': /* perturbed normal */
277 greg 1.1 *table++ = oputn;
278 greg 2.9 castonly = 0;
279 greg 1.1 break;
280 greg 2.9 case 'N': /* unperturbed normal */
281     *table++ = oputN;
282     break;
283 greg 1.1 case 's': /* surface */
284     *table++ = oputs;
285     break;
286     case 'w': /* weight */
287     *table++ = oputw;
288     break;
289 greg 2.40 case 'W': /* coefficient */
290     *table++ = oputW;
291     if (ambounce > 0 && (ambacc > FTINY || ambssamp > 0))
292     error(WARNING,
293 greg 2.41 "-otW accuracy depends on -aa 0 -as 0");
294 greg 2.40 break;
295 greg 1.1 case 'm': /* modifier */
296     *table++ = oputm;
297     break;
298 greg 2.39 case 'M': /* material */
299     *table++ = oputM;
300     break;
301 greg 2.42 case '~': /* tilde */
302     *table++ = oputtilde;
303 greg 2.41 break;
304 greg 1.1 }
305     *table = NULL;
306 gregl 2.24 }
307    
308    
309 schorsch 2.37 static void
310     bogusray(void) /* print out empty record */
311 gregl 2.24 {
312     thisray.rorg[0] = thisray.rorg[1] = thisray.rorg[2] =
313     thisray.rdir[0] = thisray.rdir[1] = thisray.rdir[2] = 0.0;
314 greg 2.40 thisray.rmax = 0.0;
315     rayorigin(&thisray, PRIMARY, NULL, NULL);
316 gregl 2.24 printvals(&thisray);
317 greg 1.1 }
318    
319    
320 schorsch 2.37 static void
321     rad( /* compute and print ray value(s) */
322     FVECT org,
323     FVECT dir,
324     double dmax
325     )
326 greg 1.1 {
327     VCOPY(thisray.rorg, org);
328     VCOPY(thisray.rdir, dir);
329 gregl 2.25 thisray.rmax = dmax;
330 greg 2.40 rayorigin(&thisray, PRIMARY, NULL, NULL);
331 gregl 2.25 if (castonly) {
332 schorsch 2.33 if (!localhit(&thisray, &thescene)) {
333 gregl 2.25 if (thisray.ro == &Aftplane) { /* clipped */
334     thisray.ro = NULL;
335     thisray.rot = FHUGE;
336     } else
337     sourcehit(&thisray);
338 schorsch 2.33 }
339 gregl 2.25 } else
340 greg 1.11 rayvalue(&thisray);
341 greg 2.16 printvals(&thisray);
342 greg 1.1 }
343    
344    
345 schorsch 2.37 static void
346     irrad( /* compute immediate irradiance value */
347     FVECT org,
348     FVECT dir
349     )
350 greg 1.1 {
351     register int i;
352    
353     for (i = 0; i < 3; i++) {
354     thisray.rorg[i] = org[i] + dir[i];
355     thisray.rdir[i] = -dir[i];
356     }
357 greg 2.40 thisray.rmax = 0.0;
358     rayorigin(&thisray, PRIMARY, NULL, NULL);
359 greg 1.1 /* pretend we hit surface */
360 greg 2.16 thisray.rot = 1.0-1e-4;
361 greg 1.1 thisray.rod = 1.0;
362     VCOPY(thisray.ron, dir);
363     for (i = 0; i < 3; i++) /* fudge factor */
364     thisray.rop[i] = org[i] + 1e-4*dir[i];
365     /* compute and print */
366     (*ofun[Lamb.otype].funp)(&Lamb, &thisray);
367 greg 2.16 printvals(&thisray);
368     }
369    
370    
371 schorsch 2.37 static void
372     printvals( /* print requested ray values */
373     RAY *r
374     )
375 greg 2.16 {
376 schorsch 2.37 register oputf_t **tp;
377 greg 2.16
378     if (ray_out[0] == NULL)
379     return;
380     for (tp = ray_out; *tp != NULL; tp++)
381     (**tp)(r);
382 greg 1.1 if (outform == 'a')
383     putchar('\n');
384     }
385    
386    
387 schorsch 2.37 static int
388     getvec( /* get a vector from fp */
389     register FVECT vec,
390     int fmt,
391     FILE *fp
392     )
393 greg 1.1 {
394     static float vf[3];
395 greg 2.5 static double vd[3];
396 greg 1.19 char buf[32];
397     register int i;
398 greg 1.1
399     switch (fmt) {
400     case 'a': /* ascii */
401 greg 1.19 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 greg 1.1 break;
408     case 'f': /* binary float */
409 greg 1.8 if (fread((char *)vf, sizeof(float), 3, fp) != 3)
410 greg 1.1 return(-1);
411     vec[0] = vf[0]; vec[1] = vf[1]; vec[2] = vf[2];
412     break;
413     case 'd': /* binary double */
414 greg 2.5 if (fread((char *)vd, sizeof(double), 3, fp) != 3)
415 greg 1.1 return(-1);
416 greg 2.5 vec[0] = vd[0]; vec[1] = vd[1]; vec[2] = vd[2];
417 greg 1.1 break;
418 greg 2.6 default:
419     error(CONSISTENCY, "botched input format");
420 greg 1.1 }
421     return(0);
422     }
423    
424    
425 schorsch 2.37 static void
426     tranotify( /* record new modifier */
427     OBJECT obj
428     )
429 greg 2.15 {
430     static int hitlimit = 0;
431     register OBJREC *o = objptr(obj);
432     register char **tralp;
433    
434 greg 2.27 if (obj == OVOID) { /* starting over */
435     traset[0] = 0;
436     hitlimit = 0;
437     return;
438     }
439 greg 2.15 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 greg 2.27 static void
455 schorsch 2.37 ourtrace( /* print ray values */
456     RAY *r
457     )
458 greg 1.1 {
459 schorsch 2.37 register oputf_t **tp;
460 greg 1.1
461     if (every_out[0] == NULL)
462 greg 2.15 return;
463 greg 2.16 if (r->ro == NULL) {
464     if (traincl == 1)
465     return;
466     } else if (traincl != -1 && traincl != inset(traset, r->ro->omod))
467 greg 1.1 return;
468     tabin(r);
469     for (tp = every_out; *tp != NULL; tp++)
470     (**tp)(r);
471 greg 2.41 if (outform == 'a')
472     putchar('\n');
473 greg 1.1 }
474    
475    
476 greg 2.27 static void
477 schorsch 2.37 tabin( /* tab in appropriate amount */
478     RAY *r
479     )
480 greg 1.1 {
481 greg 2.40 const RAY *rp;
482 greg 1.1
483     for (rp = r->parent; rp != NULL; rp = rp->parent)
484     putchar('\t');
485     }
486    
487    
488 greg 2.27 static void
489 schorsch 2.37 oputo( /* print origin */
490     RAY *r
491     )
492 greg 1.1 {
493     (*putreal)(r->rorg[0]);
494     (*putreal)(r->rorg[1]);
495     (*putreal)(r->rorg[2]);
496     }
497    
498    
499 greg 2.27 static void
500 schorsch 2.37 oputd( /* print direction */
501     RAY *r
502     )
503 greg 1.1 {
504     (*putreal)(r->rdir[0]);
505     (*putreal)(r->rdir[1]);
506     (*putreal)(r->rdir[2]);
507     }
508    
509    
510 greg 2.27 static void
511 schorsch 2.37 oputv( /* print value */
512     RAY *r
513     )
514 greg 1.1 {
515 greg 2.6 if (outform == 'c') {
516 greg 2.41 COLR cout;
517 greg 2.6 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 greg 1.1 (*putreal)(colval(r->rcol,RED));
524     (*putreal)(colval(r->rcol,GRN));
525     (*putreal)(colval(r->rcol,BLU));
526     }
527    
528    
529 greg 2.27 static void
530 schorsch 2.37 oputl( /* print effective distance */
531     RAY *r
532     )
533 greg 1.1 {
534 greg 1.9 (*putreal)(r->rt);
535 greg 2.5 }
536    
537    
538 greg 2.27 static void
539 schorsch 2.37 oputL( /* print single ray length */
540     RAY *r
541     )
542 greg 2.5 {
543     (*putreal)(r->rot);
544 greg 1.1 }
545    
546    
547 greg 2.27 static void
548 schorsch 2.37 oputc( /* print local coordinates */
549     RAY *r
550     )
551 greg 2.29 {
552     (*putreal)(r->uv[0]);
553     (*putreal)(r->uv[1]);
554     }
555    
556    
557     static void
558 schorsch 2.37 oputp( /* print point */
559     RAY *r
560     )
561 greg 1.1 {
562     if (r->rot < FHUGE) {
563     (*putreal)(r->rop[0]);
564     (*putreal)(r->rop[1]);
565     (*putreal)(r->rop[2]);
566     } else {
567     (*putreal)(0.0);
568     (*putreal)(0.0);
569     (*putreal)(0.0);
570     }
571     }
572    
573    
574 greg 2.27 static void
575 schorsch 2.37 oputN( /* print unperturbed normal */
576     RAY *r
577     )
578 greg 1.1 {
579     if (r->rot < FHUGE) {
580     (*putreal)(r->ron[0]);
581     (*putreal)(r->ron[1]);
582     (*putreal)(r->ron[2]);
583     } else {
584     (*putreal)(0.0);
585     (*putreal)(0.0);
586     (*putreal)(0.0);
587     }
588 greg 2.9 }
589    
590    
591 greg 2.27 static void
592 schorsch 2.37 oputn( /* print perturbed normal */
593     RAY *r
594     )
595 greg 2.9 {
596     FVECT pnorm;
597    
598     if (r->rot >= FHUGE) {
599     (*putreal)(0.0);
600     (*putreal)(0.0);
601     (*putreal)(0.0);
602     return;
603     }
604     raynormal(pnorm, r);
605     (*putreal)(pnorm[0]);
606     (*putreal)(pnorm[1]);
607     (*putreal)(pnorm[2]);
608 greg 1.1 }
609    
610    
611 greg 2.27 static void
612 schorsch 2.37 oputs( /* print name */
613     RAY *r
614     )
615 greg 1.1 {
616     if (r->ro != NULL)
617     fputs(r->ro->oname, stdout);
618     else
619     putchar('*');
620     putchar('\t');
621     }
622    
623    
624 greg 2.27 static void
625 schorsch 2.37 oputw( /* print weight */
626     RAY *r
627     )
628 greg 1.1 {
629     (*putreal)(r->rweight);
630     }
631    
632    
633 greg 2.27 static void
634 greg 2.40 oputW( /* print contribution */
635     RAY *r
636     )
637     {
638     COLOR contr;
639    
640     raycontrib(contr, r, PRIMARY);
641     (*putreal)(colval(contr,RED));
642     (*putreal)(colval(contr,GRN));
643     (*putreal)(colval(contr,BLU));
644     }
645    
646    
647     static void
648 schorsch 2.37 oputm( /* print modifier */
649     RAY *r
650     )
651 greg 1.1 {
652     if (r->ro != NULL)
653 greg 2.23 if (r->ro->omod != OVOID)
654     fputs(objptr(r->ro->omod)->oname, stdout);
655     else
656     fputs(VOIDID, stdout);
657 greg 1.1 else
658     putchar('*');
659     putchar('\t');
660     }
661    
662    
663 greg 2.27 static void
664 greg 2.39 oputM( /* print material */
665     RAY *r
666     )
667     {
668     OBJREC *mat;
669    
670     if (r->ro != NULL) {
671     if ((mat = findmaterial(r->ro)) != NULL)
672     fputs(mat->oname, stdout);
673     else
674     fputs(VOIDID, stdout);
675     } else
676     putchar('*');
677     putchar('\t');
678     }
679    
680    
681     static void
682 greg 2.42 oputtilde( /* output tilde (spacer) */
683 greg 2.41 RAY *r
684     )
685     {
686 greg 2.42 fputs("~\t", stdout);
687 greg 2.41 }
688    
689    
690     static void
691 schorsch 2.37 puta( /* print ascii value */
692     double v
693     )
694 greg 1.1 {
695     printf("%e\t", v);
696     }
697    
698    
699 greg 2.27 static void
700 greg 1.1 putd(v) /* print binary double */
701     double v;
702     {
703 greg 1.8 fwrite((char *)&v, sizeof(v), 1, stdout);
704 greg 1.1 }
705    
706    
707 greg 2.27 static void
708 greg 1.1 putf(v) /* print binary float */
709     double v;
710     {
711     float f = v;
712    
713 greg 1.8 fwrite((char *)&f, sizeof(f), 1, stdout);
714 greg 1.1 }