ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/rt/rcontrib.c
(Generate patch)

Comparing ray/src/rt/rcontrib.c (file contents):
Revision 2.3 by greg, Mon Jun 11 05:07:55 2012 UTC vs.
Revision 2.23 by greg, Mon Aug 25 13:18:30 2014 UTC

# Line 6 | Line 6 | static const char RCSid[] = "$Id$";
6   * Initialization and calculation routines
7   */
8  
9 + #include "copyright.h"
10 +
11 + #include <ctype.h>
12   #include "rcontrib.h"
10 #include "source.h"
13   #include "otypes.h"
14 < #include "platform.h"
14 > #include "source.h"
15  
16   char    *shm_boundary = NULL;           /* boundary of shared memory */
17  
# Line 27 | Line 29 | int    do_irrad = 0;                   /* compute irradiance? */
29  
30   int     rand_samp = 1;                  /* pure Monte Carlo sampling? */
31  
32 < double  dstrsrc = 0.0;                  /* square source distribution */
32 > double  dstrsrc = 0.9;                  /* square source distribution */
33   double  shadthresh = .03;               /* shadow threshold */
34   double  shadcert = .75;                 /* shadow certainty */
35   int     directrelay = 3;                /* number of source relays */
# Line 63 | Line 65 | int    account;                        /* current accumulation count */
65   RNUMBER raysleft;                       /* number of rays left to trace */
66   long    waitflush;                      /* how long until next flush */
67  
68 < int     lastray = 0;                    /* last ray number sent */
69 < int     lastdone = 0;                   /* last ray output */
68 > RNUMBER lastray = 0;                    /* last ray number sent */
69 > RNUMBER lastdone = 0;                   /* last ray output */
70  
71   static void mcfree(void *p) { epfree((*(MODCONT *)p).binv); free(p); }
72  
73   LUTAB   modconttab = LU_SINIT(NULL,mcfree);     /* modifier lookup table */
74  
73 static OBJECT           traset[MAXTSET+1]={0};  /* trace include set */
74
75   /************************** INITIALIZATION ROUTINES ***********************/
76  
77 void
78 tranotify(                      /* record new modifier */
79        OBJECT  obj
80 )
81 {
82        static int      hitlimit = 0;
83        OBJREC          *o = objptr(obj);
84        int             i;
85
86        if (obj == OVOID) {             /* starting over */
87                traset[0] = 0;
88                hitlimit = 0;
89                return;
90        }
91        if (hitlimit || !ismodifier(o->otype))
92                return;
93        for (i = nmods; i-- > 0; )
94                if (!strcmp(o->oname, modname[i])) {
95                        if (traset[0] >= MAXTSET) {
96                                error(WARNING, "too many same-named modifiers");
97                                hitlimit++;
98                                return;         /* should this be fatal? */
99                        }
100                        insertelem(traset, obj);
101                        break;
102                }
103 }
104
105
77   char *
78   formstr(                                /* return format identifier */
79          int  f
# Line 120 | Line 91 | formstr(                               /* return format identifier */
91  
92   /* Add modifier to our list to track */
93   MODCONT *
94 < addmodifier(char *modn, char *outf, char *binv, int bincnt)
94 > addmodifier(char *modn, char *outf, char *prms, char *binv, int bincnt)
95   {
96          LUENT   *lep = lu_find(&modconttab,modn);
97          MODCONT *mp;
# Line 157 | Line 128 | addmodifier(char *modn, char *outf, char *binv, int bi
128                  error(SYSTEM, "out of memory in addmodifier");
129          mp->outspec = outf;             /* XXX assumes static string */
130          mp->modname = modn;             /* XXX assumes static string */
131 +        mp->params = prms;
132          mp->binv = ebinv;
133          mp->nbins = bincnt;
134          memset(mp->cbin, 0, sizeof(DCOLOR)*bincnt);
# Line 168 | Line 140 | addmodifier(char *modn, char *outf, char *binv, int bi
140   }
141  
142  
143 < /* add modifiers from a file list */
143 > /* Add modifiers from a file list */
144   void
145 < addmodfile(char *fname, char *outf, char *binv, int bincnt)
145 > addmodfile(char *fname, char *outf, char *prms, char *binv, int bincnt)
146   {
147          char    *mname[MAXMODLIST];
148          int     i;
# Line 180 | Line 152 | addmodfile(char *fname, char *outf, char *binv, int bi
152                  error(SYSTEM, errmsg);
153          }
154          for (i = 0; mname[i]; i++)      /* add each one */
155 <                addmodifier(mname[i], outf, binv, bincnt);
155 >                addmodifier(mname[i], outf, prms, binv, bincnt);
156   }
157  
158  
# Line 190 | Line 162 | quit(                  /* quit program */
162   )
163   {
164          if (nchild > 0)         /* close children if any */
165 <                end_children();
165 >                end_children(code != 0);
166          exit(code);
167   }
168  
# Line 209 | Line 181 | rcinit()
181                                          /* set shared memory boundary */
182                  shm_boundary = strcpy((char *)malloc(16), "SHM_BOUNDARY");
183          }
184 <        if ((nproc > 1) & (accumulate <= 0))
185 <                put_zero_record(0);     /* prime our queue to accumulate */
214 <
215 <        if (recover) {                  /* recover previous output? */
216 <                if (accumulate <= 0) {
217 <                        reload_output();
218 <                        if (nproc > 1)
219 <                                queue_modifiers();
220 <                } else
221 <                        recover_output();
222 <        }
184 >        for (i = 0; i < nsources; i++)  /* tracing to sources as well */
185 >                source[i].sflags |= SFOLLOW;
186          if (yres > 0) {                 /* set up flushing & ray counts */
187                  if (xres > 0)
188                          raysleft = (RNUMBER)xres*yres;
# Line 230 | Line 193 | rcinit()
193          if ((account = accumulate) > 1)
194                  raysleft *= accumulate;
195          waitflush = (yres > 0) & (xres > 1) ? 0 : xres;
233                                        /* tracing to sources as well */
234        for (i = 0; i < nsources; i++)
235                source[i].sflags |= SFOLLOW;
196  
197 <        if (nproc == 1 || in_rchild())  /* single process or child */
197 >        if (nproc > 1 && in_rchild())   /* forked child? */
198                  return;                 /* return to main processing loop */
199  
200 <        parental_loop();                /* else run controller */
200 >        if (recover) {                  /* recover previous output? */
201 >                if (accumulate <= 0)
202 >                        reload_output();
203 >                else
204 >                        recover_output();
205 >        }
206 >        if (nproc == 1)                 /* single process? */
207 >                return;
208 >                                        /* else run appropriate controller */
209 >        if (accumulate <= 0)
210 >                feeder_loop();
211 >        else
212 >                parental_loop();
213          quit(0);                        /* parent musn't return! */
214   }
215  
216   /************************** MAIN CALCULATION PROCESS ***********************/
217  
218 + /* Set parameters for current bin evaluation */
219 + void
220 + set_eparams(char *prms)
221 + {
222 +        static char     *last_params = NULL;
223 +        char            vname[RMAXWORD];
224 +        double          value;
225 +        char            *cpd;
226 +                                        /* check if already set */
227 +        if ((prms == NULL) | (prms == last_params))
228 +                return;
229 +        if (last_params != NULL && !strcmp(prms, last_params))
230 +                return;
231 +        last_params = prms;             /* assign each variable */
232 +        while (*prms) {
233 +                if (isspace(*prms)) {
234 +                        ++prms; continue;
235 +                }
236 +                if (!isalpha(*prms))
237 +                        goto bad_params;
238 +                cpd = vname;
239 +                while (*prms && (*prms != '=') & !isspace(*prms)) {
240 +                        if (!isid(*prms))
241 +                                goto bad_params;
242 +                        *cpd++ = *prms++;
243 +                }
244 +                if (cpd == vname)
245 +                        goto bad_params;
246 +                *cpd = '\0';
247 +                while (isspace(*prms)) prms++;
248 +                if (*prms++ != '=')
249 +                        goto bad_params;
250 +                value = atof(prms);
251 +                if ((prms = fskip(prms)) == NULL)
252 +                        goto bad_params;
253 +                while (isspace(*prms)) prms++;
254 +                prms += (*prms == ',') | (*prms == ';');
255 +                varset(vname, '=', value);
256 +        }
257 +        return;
258 + bad_params:
259 +        sprintf(errmsg, "bad parameter list '%s'", last_params);
260 +        error(USER, errmsg);
261 + }
262 +
263 +
264   /* Our trace call to sum contributions */
265   static void
266   trace_contrib(RAY *r)
267   {
268          MODCONT *mp;
269 +        double  bval;
270          int     bn;
271          RREAL   contr[3];
272  
273 <        if (r->ro == NULL || !inset(traset, r->ro->omod))
273 >        if (r->ro == NULL || r->ro->omod == OVOID)
274                  return;
275 +                                                /* shadow ray not on source? */
276 +        if (r->rsrc >= 0 && source[r->rsrc].so != r->ro)
277 +                return;
278  
279          mp = (MODCONT *)lu_find(&modconttab,objptr(r->ro->omod)->oname)->data;
280  
281 <        if (mp == NULL)
282 <                error(CONSISTENCY, "unexpected modifier in trace_contrib()");
281 >        if (mp == NULL)                         /* not in our list? */
282 >                return;
283  
284 <        worldfunc(RCCONTEXT, r);                /* get bin number */
285 <        bn = (int)(evalue(mp->binv) + .5);
286 <        if ((bn < 0) | (bn >= mp->nbins)) {
287 <                error(WARNING, "bad bin number (ignored)");
284 >        worldfunc(RCCONTEXT, r);                /* else set context */
285 >        set_eparams((char *)mp->params);
286 >        if ((bval = evalue(mp->binv)) <= -.5)   /* and get bin number */
287 >                return;                         /* silently ignore negatives */
288 >        if ((bn = (int)(bval + .5)) >= mp->nbins) {
289 >                sprintf(errmsg, "bad bin number (%d ignored)", bn);
290 >                error(WARNING, errmsg);
291                  return;
292          }
293 <        raycontrib(contr, r, PRIMARY);
293 >        raycontrib(contr, r, PRIMARY);          /* compute coefficient */
294          if (contrib)
295 <                multcolor(contr, r->rcol);
295 >                multcolor(contr, r->rcol);      /* -> contribution */
296          addcolor(mp->cbin[bn], contr);
297   }
298  
299  
300 + /* Evaluate irradiance contributions */
301   static void
302 < rayirrad(                       /* compute irradiance rather than radiance */
277 <        RAY *r
278 < )
302 > eval_irrad(FVECT org, FVECT dir)
303   {
304 <        r->rot = 1e-5;                  /* pretend we hit surface */
305 <        VSUM(r->rop, r->rorg, r->rdir, r->rot);
306 <        r->ron[0] = -r->rdir[0];
307 <        r->ron[1] = -r->rdir[1];
308 <        r->ron[2] = -r->rdir[2];
309 <        r->rod = 1.0;
310 <                                        /* compute result */
311 <        r->revf = raytrace;
312 <        (*ofun[Lamb.otype].funp)(&Lamb, r);
313 <        r->revf = rayirrad;
304 >        RAY     thisray;
305 >
306 >        VSUM(thisray.rorg, org, dir, 1.1e-4);
307 >        thisray.rdir[0] = -dir[0];
308 >        thisray.rdir[1] = -dir[1];
309 >        thisray.rdir[2] = -dir[2];
310 >        thisray.rmax = 0.0;
311 >        rayorigin(&thisray, PRIMARY, NULL, NULL);
312 >                                        /* pretend we hit surface */
313 >        thisray.rt = thisray.rot = 1e-5;
314 >        thisray.rod = 1.0;
315 >        VCOPY(thisray.ron, dir);
316 >        VSUM(thisray.rop, org, dir, 1e-4);
317 >        samplendx++;                    /* compute result */
318 >        (*ofun[Lamb.otype].funp)(&Lamb, &thisray);
319   }
320  
321  
322 < /* Evaluate ray contributions */
322 > /* Evaluate radiance contributions */
323   static void
324 < eval_ray(FVECT  org, FVECT  dir, double dmax)
324 > eval_rad(FVECT org, FVECT dir, double dmax)
325   {
326          RAY     thisray;
327                                          /* set up ray */
328 +        VCOPY(thisray.rorg, org);
329 +        VCOPY(thisray.rdir, dir);
330 +        thisray.rmax = dmax;
331          rayorigin(&thisray, PRIMARY, NULL, NULL);
300        if (imm_irrad) {
301                VSUM(thisray.rorg, org, dir, 1.1e-4);
302                thisray.rdir[0] = -dir[0];
303                thisray.rdir[1] = -dir[1];
304                thisray.rdir[2] = -dir[2];
305                thisray.rmax = 0.0;
306                thisray.revf = rayirrad;
307        } else {
308                VCOPY(thisray.rorg, org);
309                VCOPY(thisray.rdir, dir);
310                thisray.rmax = dmax;
311        }
332          samplendx++;                    /* call ray evaluation */
333          rayvalue(&thisray);
334   }
# Line 350 | Line 370 | rcontrib()
370   #endif
371          while (getvec(orig) == 0 && getvec(direc) == 0) {
372                  d = normalize(direc);
373 <                if ((d == 0.0) & (accumulate != 1)) {
373 >                if (nchild != -1 && (d == 0.0) & (accumulate == 0)) {
374                          if (!ignore_warning_given++)
375                                  error(WARNING,
376                                  "dummy ray(s) ignored during accumulation\n");
# Line 360 | Line 380 | rcontrib()
380                          lastray = lastdone = 0;
381                  ++lastray;
382                  if (d == 0.0) {                         /* zero ==> flush */
383 <                        if ((yres <= 0) | (xres <= 0))
384 <                                waitflush = 1;          /* flush right after */
385 <                } else {                                /* else compute */
386 <                        eval_ray(orig, direc, lim_dist ? d : 0.0);
383 >                        if ((yres <= 0) | (xres <= 1))
384 >                                waitflush = 1;          /* flush after */
385 >                        if (nchild == -1)
386 >                                account = 1;
387 >                } else if (imm_irrad) {                 /* else compute */
388 >                        eval_irrad(orig, direc);
389 >                } else {
390 >                        eval_rad(orig, direc, lim_dist ? d : 0.0);
391                  }
392                  done_contrib();         /* accumulate/output */
393                  ++lastdone;
394                  if (raysleft && !--raysleft)
395                          break;          /* preemptive EOI */
396          }
397 <        if (accumulate <= 0 || account < accumulate) {
397 >        if (nchild != -1 && (accumulate <= 0) | (account < accumulate)) {
398                  if (account < accumulate) {
399                          error(WARNING, "partial accumulation in final record");
400                          accumulate -= account;
# Line 378 | Line 402 | rcontrib()
402                  account = 1;            /* output accumulated totals */
403                  done_contrib();
404          }
405 +        lu_done(&ofiletab);             /* close output files */
406          if (raysleft)
407                  error(USER, "unexpected EOF on input");
383        lu_done(&ofiletab);             /* close output files */
408   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines