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 1.5 by greg, Mon Apr 22 10:07:36 1991 UTC vs.
Revision 2.3 by greg, Thu Nov 19 09:59:08 1992 UTC

# Line 5 | Line 5 | static char SCCSid[] = "$SunId$ LBL";
5   #endif
6  
7   /*
8 < * Compute Glare Index given by program name:
8 > * Compute Glare Index given by program name or -t option:
9   *
10   *      guth_dgr -      Guth discomfort glare rating
11   *      guth_vcp -      Guth visual comfort probability
12 + *      cie_cgi -       CIE Glare Index (1983, due to Einhorn)
13 + *      vert_dir -      Direct vertical illuminance
14 + *      vert_ind -      Indirect vertical illuminance (from input)
15 + *      vert_ill -      Total vertical illuminance
16   *
17   *              12 April 1991   Greg Ward       EPFL
18   */
# Line 19 | Line 23 | static char SCCSid[] = "$SunId$ LBL";
23   extern double   erfc();
24  
25   double  posindex();
22 – int     headline();
26  
27 < double  direct(), guth_dgr(), guth_vcp();
27 > double  direct(), guth_dgr(), guth_vcp(), cie_cgi(),
28 >        indirect(), total();
29  
30   struct named_func {
31          char    *name;
32          double  (*func)();
33 +        char    *descrip;
34   } all_funcs[] = {
35 <        {"direct", direct},
36 <        {"guth_dgr", guth_dgr},
37 <        {"guth_vcp", guth_vcp},
35 >        {"guth_vcp", guth_vcp, "Guth Visual Comfort Probability"},
36 >        {"cie_cgi", cie_cgi, "CIE Glare Index (Einhorn)"},
37 >        {"guth_dgr", guth_dgr, "Guth Disability Glare Rating"},
38 >        {"vert_dir", direct, "Direct Vertical Illuminance"},
39 >        {"vert_ill", total, "Total Vertical Illuminance"},
40 >        {"vert_ind", indirect, "Indirect Vertical Illuminance"},
41          {NULL}
42   };
43  
# Line 90 | Line 98 | char   *argv[];
98                          perror(argv[i]);
99                          exit(1);
100                  }
101 <                                        /* read header */
94 <        getheader(stdin, headline, NULL);
95 <        if (wrongformat) {
96 <                fprintf(stderr, "%s: bad input format\n", progname);
97 <                exit(1);
98 <        }
99 <        if (print_header) {             /* add to header */
100 <                printargs(i, argv, stdout);
101 <                putchar('\n');
102 <        }
103 <                                        /* set view */
104 <        if (setview(&midview) != NULL) {
105 <                fprintf(stderr, "%s: bad view information in input\n",
106 <                                progname);
107 <                exit(1);
108 <        }
109 <                                        /* get findglare data */
110 <        read_input();
111 <                                        /* find calculation */
101 >                                        /* find and run calculation */
102          for (funp = all_funcs; funp->name != NULL; funp++)
103                  if (!strcmp(funp->name, progtail)) {
104 +                        init();
105 +                        read_input();
106 +                        if (print_header) {
107 +                                printargs(i, argv, stdout);
108 +                                putchar('\n');
109 +                        }
110                          print_values(funp->func);
111                          exit(0);                /* we're done */
112                  }
113                                          /* invalid function */
118 –        fprintf(stderr, "%s: unknown function!\n", progtail);
119 –        exit(1);
114   userr:
115 <        fprintf(stderr, "Usage: %s [-t type][-h] [input]\n", progname);
115 >        fprintf(stderr, "Usage: %s -t type [-h] [input]\n", progname);
116 >        fprintf(stderr, "\twhere 'type' is one of the following:\n");
117 >        for (funp = all_funcs; funp->name != NULL; funp++)
118 >                fprintf(stderr, "\t%12s\t%s\n", funp->name, funp->descrip);
119          exit(1);
120   }
121  
# Line 130 | Line 127 | char   *s;
127  
128          if (print_header)               /* copy to output */
129                  fputs(s, stdout);
130 <        if (!strncmp(s, VIEWSTR, VIEWSTRL))
131 <                sscanview(&midview, s+VIEWSTRL);
130 >        if (isview(s))
131 >                sscanview(&midview, s);
132          else if (isformat(s)) {
133                  formatval(fmt, s);
134 <                wrongformat = strcmp(fmt, "ASCII");
134 >                wrongformat = strcmp(fmt, "ascii");
135          }
136   }
137  
138  
139 + init()                          /* initialize calculation */
140 + {
141 +                                        /* read header */
142 +        getheader(stdin, headline, NULL);
143 +        if (wrongformat) {
144 +                fprintf(stderr, "%s: bad input format\n", progname);
145 +                exit(1);
146 +        }
147 +                                        /* set view */
148 +        if (setview(&midview) != NULL) {
149 +                fprintf(stderr, "%s: bad view information in input\n",
150 +                                progname);
151 +                exit(1);
152 +        }
153 + }
154 +
155 +
156   read_input()                    /* read glare sources from stdin */
157   {
158   #define S_SEARCH        0
# Line 211 | Line 225 | double (*funp)();
225  
226  
227   double
228 < direct(gd)                      /* compute direct illuminance */
228 > direct(gd)                      /* compute direct vertical illuminance */
229   struct glare_dir        *gd;
230   {
231          FVECT   mydir;
# Line 229 | Line 243 | struct glare_dir       *gd;
243   }
244  
245  
246 + double
247 + indirect(gd)                    /* return indirect vertical illuminance */
248 + struct glare_dir        *gd;
249 + {
250 +        return(gd->indirect);
251 + }
252 +
253 +
254 + double
255 + total(gd)                       /* return total vertical illuminance */
256 + struct glare_dir        *gd;
257 + {
258 +        return(direct(gd)+gd->indirect);
259 + }
260 +
261 +
262   /*
263   * posindex -   compute glare position index from:
264   *
# Line 259 | Line 289 | FVECT  sd, vd, vu;
289          d = DOT(sd,vu)/sqrt(1.0-d*d);
290          if (d >= 1.0)
291                  tau = 0.0;
292 +        else if (d <= -1.0)
293 +                tau = 180.0;
294          else
295                  tau = acos(d) * (180./PI);
296          return( exp( sigma*( (35.2 - tau*.31889 - 1.22*exp(-.22222*tau))*1e-3
# Line 273 | Line 305 | struct glare_dir       *gd;
305   {
306   #define q(w)    (20.4*w+1.52*pow(w,.2)-.075)
307          register struct glare_src       *gs;
308 +        FVECT   mydir;
309          double  p;
310          double  sum;
311          double  wtot, brsum;
312          int     n;
313  
314 +        spinvector(mydir, midview.vdir, midview.vup, gd->ang);
315          sum = wtot = brsum = 0.0; n = 0;
316          for (gs = all_srcs; gs != NULL; gs = gs->next) {
317 <                p = posindex(gs->dir, midview.vdir, midview.vup);
317 >                p = posindex(gs->dir, mydir, midview.vup);
318                  if (p <= FTINY)
319                          continue;
320                  sum += gs->lum * q(gs->dom) / p;
# Line 290 | Line 324 | struct glare_dir       *gd;
324          }
325          if (n == 0)
326                  return(0.0);
327 <        else
328 <                return( pow(
295 <                        .5*sum/pow((brsum+(5.-wtot)*gd->indirect/PI)/5.,.44),
327 >
328 >        return( pow(.5*sum/pow((brsum+(5.-wtot)*gd->indirect/PI)/5.,.44),
329                          pow((double)n, -.0914) ) );
330   #undef q
331   }
# Line 311 | Line 344 | double
344   guth_vcp(gd)            /* compute Guth visual comfort probability */
345   struct glare_dir        *gd;
346   {
347 <        return(100.*norm_integral(6.374-1.3227*log(guth_dgr(gd))));
347 >        double  dgr;
348 >
349 >        dgr = guth_dgr(gd);
350 >        if (dgr <= FTINY)
351 >                return(100.0);
352 >        return(100.*norm_integral(6.374-1.3227*log(dgr)));
353 > }
354 >
355 >
356 > double
357 > cie_cgi(gd)             /* compute CIE Glare Index */
358 > struct glare_dir        *gd;
359 > {
360 >        register struct glare_src       *gs;
361 >        FVECT   mydir;
362 >        double  dillum;
363 >        double  p;
364 >        double  sum;
365 >
366 >        spinvector(mydir, midview.vdir, midview.vup, gd->ang);
367 >        sum = 0.0;
368 >        for (gs = all_srcs; gs != NULL; gs = gs->next) {
369 >                p = posindex(gs->dir, mydir, midview.vup);
370 >                if (p <= FTINY)
371 >                        continue;
372 >                sum += gs->lum*gs->lum * gs->dom / (p*p);
373 >        }
374 >        if (sum <= FTINY)
375 >                return(0.0);
376 >        dillum = direct(gd);
377 >        return(8.*log10(2.*sum*(1.+dillum/500.)/(dillum+gd->indirect)));
378   }

Diff Legend

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