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

Comparing ray/src/rt/pmapdata.c (file contents):
Revision 2.4 by greg, Wed May 20 12:58:31 2015 UTC vs.
Revision 2.13 by rschregle, Wed Sep 9 16:08:46 2015 UTC

# Line 1 | Line 1
1 + #ifndef lint
2 + static const char RCSid[] = "$Id$";
3 + #endif
4   /*
5     ==================================================================
6     Photon map data structures and kd-tree handling
# Line 8 | Line 11
11     supported by the Swiss National Science Foundation (SNSF, #147053)
12     ==================================================================  
13    
11 –   $Id$
14   */
15  
16  
# Line 19 | Line 21
21   #include "otypes.h"
22   #include "source.h"
23   #include "rcontrib.h"
24 + #include "random.h"
25  
26  
27  
# Line 66 | Line 69 | void initPhotonMap (PhotonMap *pmap, PhotonMapType t)
69   const PhotonPrimary* addPhotonPrimary (PhotonMap *pmap, const RAY *ray)
70   {
71     PhotonPrimary *prim = NULL;
72 +   FVECT dvec;
73    
74     if (!pmap || !ray)
75        return NULL;
# Line 98 | Line 102 | const PhotonPrimary* addPhotonPrimary (PhotonMap *pmap
102     prim -> srcIdx = -1;
103        
104     /* Reverse incident direction to point to light source */
105 <   prim -> dir [0] = -ray -> rdir [0];
106 <   prim -> dir [1] = -ray -> rdir [1];
107 <   prim -> dir [2] = -ray -> rdir [2];
105 >   dvec [0] = -ray -> rdir [0];
106 >   dvec [1] = -ray -> rdir [1];
107 >   dvec [2] = -ray -> rdir [2];
108 >   prim -> dir = encodedir(dvec);
109  
110     VCOPY(prim -> pos, ray -> rop);
111    
# Line 227 | Line 232 | static void nearestNeighbours (PhotonMap* pmap, const
232     }
233  
234     /* Reject photon if normal faces away (ignored for volume photons) */
235 <   if (norm && DOT(norm, p -> norm) <= 0)
235 >   if (norm && DOT(norm, p -> norm) <= 0.5 * frandom())
236        return;
237        
238     if (isContribPmap(pmap) && pmap -> srcContrib) {
# Line 238 | Line 243 | static void nearestNeighbours (PhotonMap* pmap, const
243        if (srcIdx < 0 || srcIdx >= nsources)
244           error(INTERNAL, "invalid light source index in photon map");
245        
246 <      srcMod = objptr(source [srcIdx].so -> omod);
246 >      srcMod = findmaterial(source [srcIdx].so);
247  
248        /* Reject photon if contributions from light source which emitted it
249         * are not sought */
# Line 309 | Line 314 | static void nearestNeighbours (PhotonMap* pmap, const
314   /* Threshold below which we assume increasing max radius won't help */
315   #define PMAP_SHORT_LOOKUP_THRESH 1
316  
317 + /* Coefficient for adaptive maximum search radius */
318 + #define PMAP_MAXDIST_COEFF 100
319 +
320 +
321   void findPhotons (PhotonMap* pmap, const RAY* ray)
322   {
323     float pos [3], norm [3];
# Line 330 | Line 339 | void findPhotons (PhotonMap* pmap, const RAY* ray)
339        pmap -> minError = FHUGE;
340        pmap -> maxError = -FHUGE;
341        pmap -> rmsError = 0;
342 < #ifdef PMAP_MAXDIST_ABS
343 <      /* Treat maxDistCoeff as an *absolute* and *fixed* max search radius.
335 <         Primarily intended for debugging; FOR ZE ECKSPURTZ ONLY! */
336 <      pmap -> maxDist0 = pmap -> maxDistLimit = maxDistCoeff;
337 < #else
338 <      /* Maximum search radius limit based on avg photon distance to
339 <       * centre of gravity */
342 >      /* SQUARED max search radius limit is based on avg photon distance to
343 >       * centre of gravity, unless fixed by user (maxDistFix > 0) */
344        pmap -> maxDist0 = pmap -> maxDistLimit =
345 <         maxDistCoeff * pmap -> squeueSize * pmap -> CoGdist /
346 <         pmap -> heapSize;
347 < #endif      
345 >         maxDistFix > 0 ? maxDistFix * maxDistFix
346 >                        : PMAP_MAXDIST_COEFF * pmap -> squeueSize *
347 >                          pmap -> CoGdist / pmap -> heapSize;
348     }
349  
350     do {
# Line 360 | Line 364 | void findPhotons (PhotonMap* pmap, const RAY* ray)
364           nearestNeighbours(pmap, pos, norm, 1);
365        }
366  
367 < #ifndef PMAP_MAXDIST_ABS      
367 > #ifdef PMAP_ITSYBITSY
368 >      if (pmap -> maxDist < FTINY) {
369 >         sprintf(errmsg, "itsy bitsy teeny weeny photon search radius %e",
370 >                 sqrt(pmap -> maxDist));
371 >         error(WARNING, errmsg);
372 >      }
373 > #endif
374 >
375        if (pmap -> squeueEnd < pmap -> squeueSize * pmap -> gatherTolerance) {
376           /* Short lookup; too few photons found */
377           if (pmap -> squeueEnd > PMAP_SHORT_LOOKUP_THRESH) {
# Line 368 | Line 379 | void findPhotons (PhotonMap* pmap, const RAY* ray)
379               * PMAP_SHORT_LOOKUP_THRESH photons under the assumption there
380               * really are no photons in the vicinity, and increasing the max
381               * search radius therefore won't help */
382 <   #ifdef PMAP_LOOKUP_WARN
382 > #ifdef PMAP_LOOKUP_WARN
383              sprintf(errmsg,
384                      "%d/%d %s photons found at (%.2f,%.2f,%.2f) on %s",
385                      pmap -> squeueEnd, pmap -> squeueSize,
386                      pmapName [pmap -> type], pos [0], pos [1], pos [2],
387                      ray -> ro ? ray -> ro -> oname : "<null>");
388              error(WARNING, errmsg);        
389 <   #endif            
389 > #endif            
390  
391 +            /* Bail out after warning if maxDist is fixed */
392 +            if (maxDistFix > 0)
393 +               return;
394 +            
395              if (pmap -> maxDist0 < pmap -> maxDistLimit) {
396                 /* Increase max search radius if below limit & redo search */
397                 pmap -> maxDist0 *= PMAP_MAXDIST_INC;
398 <   #ifdef PMAP_LOOKUP_REDO
398 > #ifdef PMAP_LOOKUP_REDO
399                 redo = 1;
400 <   #endif              
401 <
387 <   #ifdef PMAP_LOOKUP_WARN
400 > #endif              
401 > #ifdef PMAP_LOOKUP_WARN
402                 sprintf(errmsg,
403                         redo ? "restarting photon lookup with max radius %.1e"
404                              : "max photon lookup radius adjusted to %.1e",
405 <                       pmap -> maxDist0);
405 >                       sqrt(pmap -> maxDist0));
406                 error(WARNING, errmsg);
407 <   #endif
407 > #endif
408              }
409 <   #ifdef PMAP_LOOKUP_REDO
409 > #ifdef PMAP_LOOKUP_REDO
410              else {
411                 sprintf(errmsg, "max photon lookup radius clamped to %.1e",
412 <                       pmap -> maxDist0);
412 >                       sqrt(pmap -> maxDist0));
413                 error(WARNING, errmsg);
414              }
415 <   #endif
415 > #endif
416           }
417          
418           /* Reset successful lookup counter */
419           pmap -> numLookups = 0;
420        }
421        else {
422 +         /* Bail out after warning if maxDist is fixed */
423 +         if (maxDistFix > 0)
424 +            return;
425 +            
426           /* Increment successful lookup counter and reduce max search radius if
427            * wraparound */
428           pmap -> numLookups = (pmap -> numLookups + 1) % PMAP_MAXDIST_CNT;
# Line 413 | Line 431 | void findPhotons (PhotonMap* pmap, const RAY* ray)
431              
432           redo = 0;
433        }
434 < #endif
434 >      
435     } while (redo);
436   }
437  
# Line 453 | Line 471 | static void nearest1Neighbour (PhotonMap *pmap, const
471     dv [2] = pos [2] - p -> pos [2];
472     d2 = DOT(dv, dv);
473    
474 <   if (d2 < pmap -> maxDist && DOT(norm, p -> norm) > 0) {
474 >   if (d2 < pmap -> maxDist && DOT(norm, p -> norm) > 0.5 * frandom()) {
475        /* Closest photon so far with similar normal */
476        pmap -> maxDist = d2;
477        *photon = p;

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines