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

Comparing ray/src/util/glarendx.c (file contents):
Revision 2.9 by greg, Wed Nov 19 16:21:28 2003 UTC vs.
Revision 2.10 by schorsch, Fri Jan 2 12:48:36 2004 UTC

# Line 18 | Line 18 | static const char      RCSid[] = "$Id$";
18   *              12 April 1991   Greg Ward       EPFL
19   *              19 April 1993   R. Compagnon    EPFL (added dgi, brs_gi, ugr)
20   */
21 <
21 >
22   #include <string.h>
23  
24   #include "standard.h"
25   #include "view.h"
26 <
27 <
28 < double  posindex();
29 <
30 < double  direct(), guth_dgr(), guth_vcp(), cie_cgi(),
31 <        indirect(), total(), dgi(), brs_gi(), ugr();
32 <
26 >
27 >
28 > struct glare_src {
29 >        FVECT   dir;            /* source direction */
30 >        double  dom;            /* solid angle */
31 >        double  lum;            /* average luminance */
32 >        struct glare_src        *next;
33 > } *all_srcs = NULL;
34 >
35 > struct glare_dir {
36 >        double  ang;            /* angle (in radians) */
37 >        double  indirect;       /* indirect illuminance */
38 >        struct glare_dir        *next;
39 > } *all_dirs = NULL;
40 >
41 > typedef double gdfun(struct glare_dir *gd);
42 >
43 > static gdfun dgi;
44 > static gdfun brs_gi;
45 > static gdfun ugr;
46 > static gdfun guth_dgr;
47 > static gdfun guth_vcp;
48 > static gdfun cie_cgi;
49 > static gdfun direct;
50 > static gdfun indirect;
51 > static gdfun total;
52 >
53 > static gethfunc headline;
54 > static void init(void);
55 > static void read_input(void);
56 > static void print_values(gdfun *func);
57 > static double posindex(FVECT sd, FVECT vd, FVECT vu);
58 >
59 >
60   struct named_func {
61          char    *name;
62 <        double  (*func)();
62 >        gdfun   *func;
63          char    *descrip;
64   } all_funcs[] = {
65          {"dgi", dgi, "Daylight Glare Index"},
# Line 46 | Line 73 | struct named_func {
73          {"vert_ind", indirect, "Indirect Vertical Illuminance"},
74          {NULL}
75   };
76 <
50 < struct glare_src {
51 <        FVECT   dir;            /* source direction */
52 <        double  dom;            /* solid angle */
53 <        double  lum;            /* average luminance */
54 <        struct glare_src        *next;
55 < } *all_srcs = NULL;
56 <
57 < struct glare_dir {
58 <        double  ang;            /* angle (in radians) */
59 <        double  indirect;       /* indirect illuminance */
60 <        struct glare_dir        *next;
61 < } *all_dirs = NULL;
62 <
76 >
77   #define newp(type)      (type *)malloc(sizeof(type))
78 <
78 >
79   char    *progname;
80   int     print_header = 1;
81 <
81 >
82   VIEW    midview = STDVIEW;
83 <
83 >
84   int     wrongformat = 0;
85 <
86 <
87 < main(argc, argv)
88 < int     argc;
89 < char    *argv[];
85 >
86 >
87 > int
88 > main(
89 >        int     argc,
90 >        char    *argv[]
91 > )
92   {
93          struct named_func       *funp;
94          char    *progtail;
# Line 123 | Line 139 | userr:
139                  fprintf(stderr, "\t%12s\t%s\n", funp->name, funp->descrip);
140          exit(1);
141   }
142 <
143 <
144 < int
145 < headline(s)                     /* get line from header */
146 < char    *s;
142 >
143 >
144 > static int
145 > headline(                       /* get line from header */
146 >        char    *s,
147 >        void    *p
148 > )
149   {
150          char    fmt[32];
151 <
151 >
152          if (print_header)               /* copy to output */
153                  fputs(s, stdout);
154          if (isview(s))
# Line 141 | Line 159 | char   *s;
159          }
160          return(0);
161   }
162 <
163 <
164 < init()                          /* initialize calculation */
162 >
163 >
164 > static void
165 > init(void)                              /* initialize calculation */
166   {
167                                          /* read header */
168          getheader(stdin, headline, NULL);
# Line 158 | Line 177 | init()                         /* initialize calculation */
177                  exit(1);
178          }
179   }
180 <
181 <
182 < read_input()                    /* read glare sources from stdin */
180 >
181 >
182 > static void
183 > read_input(void)                        /* read glare sources from stdin */
184   {
185   #define S_SEARCH        0
186   #define S_SOURCE        1
# Line 169 | Line 189 | read_input()                   /* read glare sources from stdin */
189          char    buf[128];
190          register struct glare_src       *gs;
191          register struct glare_dir       *gd;
192 <
192 >
193          while (fgets(buf, sizeof(buf), stdin) != NULL)
194                  switch (state) {
195                  case S_SEARCH:
# Line 219 | Line 239 | readerr:
239   #undef S_SOURCE
240   #undef S_DIREC
241   }
242 <
243 <
244 < print_values(funp)              /* print out calculations */
245 < double  (*funp)();
242 >
243 >
244 > static void
245 > print_values(           /* print out calculations */
246 >        gdfun *func
247 > )
248   {
249          register struct glare_dir       *gd;
250 <
250 >
251          for (gd = all_dirs; gd != NULL; gd = gd->next)
252 <                printf("%f\t%f\n", gd->ang*(180.0/PI), (*funp)(gd));
252 >                printf("%f\t%f\n", gd->ang*(180.0/PI), (*func)(gd));
253   }
254 <
255 <
256 < double
257 < direct(gd)                      /* compute direct vertical illuminance */
258 < struct glare_dir        *gd;
254 >
255 >
256 > static double
257 > direct(                 /* compute direct vertical illuminance */
258 >        struct glare_dir        *gd
259 > )
260   {
261          FVECT   mydir;
262          double  d, dval;
263          register struct glare_src       *gs;
264 <
264 >
265          spinvector(mydir, midview.vdir, midview.vup, gd->ang);
266          dval = 0.0;
267          for (gs = all_srcs; gs != NULL; gs = gs->next) {
# Line 248 | Line 271 | struct glare_dir       *gd;
271          }
272          return(dval);
273   }
274 <
275 <
276 < double
277 < indirect(gd)                    /* return indirect vertical illuminance */
278 < struct glare_dir        *gd;
274 >
275 >
276 > static double
277 > indirect(                       /* return indirect vertical illuminance */
278 >        struct glare_dir        *gd
279 > )
280   {
281          return(gd->indirect);
282   }
283 <
284 <
285 < double
286 < total(gd)                       /* return total vertical illuminance */
287 < struct glare_dir        *gd;
283 >
284 >
285 > static double
286 > total(                  /* return total vertical illuminance */
287 >        struct glare_dir        *gd
288 > )
289   {
290          return(direct(gd)+gd->indirect);
291   }
292 <
293 <
292 >
293 >
294   /*
295   * posindex -   compute glare position index from:
296   *
# Line 279 | Line 304 | struct glare_dir       *gd;
304   * This calculation presumes the view direction and up vectors perpendicular.
305   * We return a value less than zero for improper positions.
306   */
307 <
308 < double
309 < posindex(sd, vd, vu)                    /* compute position index */
310 < FVECT   sd, vd, vu;
307 >
308 > static double
309 > posindex(                       /* compute position index */
310 >        FVECT   sd,
311 >        FVECT   vd,
312 >        FVECT   vu
313 > )
314   {
315          double  sigma, tau;
316          double  d;
317 <
317 >
318          d = DOT(sd,vd);
319          if (d <= 0.0)
320                  return(-1.0);
# Line 302 | Line 330 | FVECT  sd, vd, vu;
330                          + sigma*(21. + tau*(.26667 + tau*-.002963))*1e-5 )
331                  ) );
332   }
333 <
334 <
335 < double
336 < dgi(gd)         /* compute Daylight Glare Index */
337 < struct glare_dir        *gd;
333 >
334 >
335 > static double
336 > dgi(            /* compute Daylight Glare Index */
337 >        struct glare_dir        *gd
338 > )
339   {
340          register struct glare_src       *gs;
341          FVECT   mydir,testdir[7],vhor;
342          double  r,posn,omega,p[7],sum;
343          int     i,n;
344 <
344 >
345          spinvector(mydir, midview.vdir, midview.vup, gd->ang);
346          sum = 0.0; n = 0;
347          for (gs = all_srcs; gs != NULL; gs = gs->next) {
# Line 344 | Line 373 | struct glare_dir       *gd;
373                  omega += (2*PI-r*PI*(1+1/r/r))*(-p[0]-0.1667*(p[1]+p[3])
374                            +0.3334*(p[2]+p[4]+p[5]+p[6]));
375  
376 <                sum += pow(gs->lum,1.6) * pow(omega,0.8) /
376 >                sum += pow(gs->lum,1.6) * pow(omega,0.8) /
377                         (gd->indirect/PI + 0.07*sqrt(gs->dom)*gs->lum);
378                  n++;
379          }
# Line 352 | Line 381 | struct glare_dir       *gd;
381                  return(0.0);
382          return( 10*log10(0.478*sum) );
383   }
355 –
384  
385 < double
386 < brs_gi(gd)              /* compute BRS Glare Index */
387 < struct glare_dir        *gd;
385 >
386 > static double
387 > brs_gi(         /* compute BRS Glare Index */
388 >        struct glare_dir        *gd
389 > )
390   {
391          register struct glare_src       *gs;
392          FVECT   mydir;
393          double  p;
394          double  sum;
395 <
395 >
396          spinvector(mydir, midview.vdir, midview.vup, gd->ang);
397          sum = 0.0;
398          for (gs = all_srcs; gs != NULL; gs = gs->next) {
# Line 378 | Line 408 | struct glare_dir       *gd;
408   }
409  
410  
411 < double
412 < guth_dgr(gd)            /* compute Guth discomfort glare rating */
413 < struct glare_dir        *gd;
411 > static double
412 > guth_dgr(               /* compute Guth discomfort glare rating */
413 >        struct glare_dir        *gd
414 > )
415   {
416   #define q(w)    (20.4*w+1.52*pow(w,.2)-.075)
417          register struct glare_src       *gs;
# Line 389 | Line 420 | struct glare_dir       *gd;
420          double  sum;
421          double  wtot, brsum;
422          int     n;
423 <
423 >
424          spinvector(mydir, midview.vdir, midview.vup, gd->ang);
425          sum = wtot = brsum = 0.0; n = 0;
426          for (gs = all_srcs; gs != NULL; gs = gs->next) {
# Line 407 | Line 438 | struct glare_dir       *gd;
438                          pow((double)n, -.0914) ) );
439   #undef q
440   }
441 <
442 <
441 >
442 >
443   #ifndef M_SQRT2
444   #define M_SQRT2 1.41421356237309504880
445   #endif
446 <
446 >
447   #define norm_integral(z)        (1.-.5*erfc((z)/M_SQRT2))
448 <
449 <
450 < double
451 < guth_vcp(gd)            /* compute Guth visual comfort probability */
452 < struct glare_dir        *gd;
448 >
449 >
450 > static double
451 > guth_vcp(               /* compute Guth visual comfort probability */
452 >        struct glare_dir        *gd
453 > )
454   {
455          extern double   erfc();
456          double  dgr;
457 <
457 >
458          dgr = guth_dgr(gd);
459          if (dgr <= FTINY)
460                  return(100.0);
461          return(100.*norm_integral(6.374-1.3227*log(dgr)));
462   }
463 <
464 <
465 < double
466 < cie_cgi(gd)             /* compute CIE Glare Index */
467 < struct glare_dir        *gd;
463 >
464 >
465 > static double
466 > cie_cgi(                /* compute CIE Glare Index */
467 >        struct glare_dir        *gd
468 > )
469   {
470          register struct glare_src       *gs;
471          FVECT   mydir;
472          double  dillum;
473          double  p;
474          double  sum;
475 <
475 >
476          spinvector(mydir, midview.vdir, midview.vup, gd->ang);
477          sum = 0.0;
478          for (gs = all_srcs; gs != NULL; gs = gs->next) {
# Line 455 | Line 488 | struct glare_dir       *gd;
488   }
489  
490  
491 < double
492 < ugr(gd)         /* compute Unified Glare Rating */
493 < struct glare_dir        *gd;
491 > static double
492 > ugr(            /* compute Unified Glare Rating */
493 >        struct glare_dir        *gd
494 > )
495   {
496          register struct glare_src       *gs;
497          FVECT   mydir;
498          double  p;
499          double  sum;
500 <
500 >
501          spinvector(mydir, midview.vdir, midview.vup, gd->ang);
502          sum = 0.0;
503          for (gs = all_srcs; gs != NULL; gs = gs->next) {

Diff Legend

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