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

Comparing ray/src/gen/mkillum3.c (file contents):
Revision 2.9 by schorsch, Sun Nov 16 10:29:38 2003 UTC vs.
Revision 2.15 by greg, Sat Dec 16 18:35:27 2023 UTC

# Line 1 | Line 1
1   #ifndef lint
2 < static const char RCSid[] = "$Id";
2 > static const char RCSid[] = "$Id$";
3   #endif
4   /*
5   * Routines to print mkillum objects
6   */
7  
8   #include  "mkillum.h"
9 + #include  "paths.h"
10  
10 – #define  brt(col)       (.263*(col)[0]+.655*(col)[1]+.082*(col)[2])
11 –
11   char    DATORD[] = "RGB";               /* data ordering */
12   char    DATSUF[] = ".dat";              /* data file suffix */
13   char    DSTSUF[] = ".dist";             /* distribution suffix */
14   char    FNCFNM[] = "illum.cal";         /* function file name */
15  
16 < void compinv(float *rinv, float *rp, int m);
17 < void colorout(int p, float *da, int n, int m, double mult, FILE *fp);
18 < void fputnum(double d, FILE *fp);
19 < void brightout(float *da, int n, int m, double mult, FILE *fp);
20 < void fputeol(FILE *fp);
21 < void compavg(float col[3], float *da, int n);
22 < char * dfname(struct illum_args *il, int c);
23 < FILE * dfopen(struct illum_args *il, int c);
16 > static void compinv(COLORV *rinv, COLORV *rp, int m);
17 > static void colorout(int p, COLORV *da, int n, int m, double mult, FILE *fp);
18 > static void fputnum(double d, FILE *fp);
19 > static void brightout(COLORV *da, int n, int m, double mult, FILE *fp);
20 > static void fputeol(FILE *fp);
21 > static void compavg(COLOR col, COLORV *da, int n);
22 > static char * dfname(struct illum_args *il, int c);
23 > static FILE * dfopen(struct illum_args *il, int c);
24  
25  
26   void
27   printobj(               /* print out an object */
28          char  *mod,
29 <        register OBJREC  *obj
29 >        OBJREC  *obj
30   )
31   {
32 <        register int  i;
32 >        int  i;
33  
34          if (issurface(obj->otype) && !strcmp(mod, VOIDID))
35                  return;         /* don't print void surfaces */
# Line 62 | Line 61 | dfname(                        /* return data file name */
61   )
62   {
63          char  fname[MAXSTR];
64 <        register char  *s;
64 >        char  *s;
65  
66          s = strcpy(fname, il->datafile);
67          s += strlen(s);
# Line 76 | Line 75 | dfname(                        /* return data file name */
75   }
76  
77  
78 < FILE *
78 > static FILE *
79   dfopen(                 /* open data file */
80 <        register struct illum_args  *il,
80 >        struct illum_args  *il,
81          int  c
82   )
83   {
# Line 98 | Line 97 | dfopen(                        /* open data file */
97   }
98  
99  
100 < extern void
100 > void
101   flatout(                /* write hemispherical distribution */
102          struct illum_args  *il,
103 <        float  *da,
103 >        COLORV  *da,
104          int  n,
105          int  m,
106          FVECT  u,
# Line 109 | Line 108 | flatout(               /* write hemispherical distribution */
108          FVECT  w
109   )
110   {
111 <        float  *Ninv;
111 >        COLORV  *Ninv;
112          FILE  *dfp;
113          int  i;
114  
115 <        if ((Ninv = (float *)malloc(3*m*sizeof(float))) == NULL)
115 >        if ((Ninv = (COLORV *)malloc(3*m*sizeof(COLORV))) == NULL)
116                  error(SYSTEM, "out of memory in flatout");
117          compinv(Ninv, da, m);
118          if (il->flags & IL_COLDST) {
# Line 139 | Line 138 | flatout(               /* write hemispherical distribution */
138                  fprintf(dfp, "2\n%f %f %d\n%f %f %d\n",
139                                  1.+.5/n, .5/n, n+1,
140                                  0., 2.*PI, m+1);
141 <                brightout(Ninv, 1, m, 1./il->nsamps/brt(il->col), dfp);
142 <                brightout(da, n, m, 1./il->nsamps/brt(il->col), dfp);
141 >                brightout(Ninv, 1, m, 1./il->nsamps/bright(il->col), dfp);
142 >                brightout(da, n, m, 1./il->nsamps/bright(il->col), dfp);
143                  fputeol(dfp);
144                  fclose(dfp);
145                  printf(" %s", dfname(il, 0));
# Line 151 | Line 150 | flatout(               /* write hemispherical distribution */
150          printf("\t%f\t%f\t%f\n", v[0], v[1], v[2]);
151          printf("\t%f\t%f\t%f\n", w[0], w[1], w[2]);
152          il->dfnum++;
153 <        free((void *)Ninv);
153 >        free(Ninv);
154   }
155  
156  
157 < extern void
157 > void
158   roundout(                       /* write spherical distribution */
159          struct illum_args  *il,
160 <        float  *da,
160 >        COLORV  *da,
161          int  n,
162          int  m
163   )
164   {
165 <        float  *Ninv, *Sinv;
165 >        COLORV  *Ninv, *Sinv;
166          FILE  *dfp;
167          int  i;
168  
169 <        if ((Ninv = (float *)malloc(3*m*sizeof(float))) == NULL ||
170 <                        (Sinv = (float *)malloc(3*m*sizeof(float))) == NULL)
169 >        if ((Ninv = (COLORV *)malloc(3*m*sizeof(COLORV))) == NULL ||
170 >                        (Sinv = (COLORV *)malloc(3*m*sizeof(COLORV))) == NULL)
171                  error(SYSTEM, "out of memory in roundout");
172          compinv(Ninv, da, m);
173          compinv(Sinv, da+3*m*(n-1), m);
# Line 196 | Line 195 | roundout(                      /* write spherical distribution */
195                  fprintf(dfp, "2\n%f %f %d\n%f %f %d\n",
196                                  1.+1./n, -1.-1./n, n+2,
197                                  0., 2.*PI, m+1);
198 <                brightout(Ninv, 1, m, 1./il->nsamps/brt(il->col), dfp);
199 <                brightout(da, n, m, 1./il->nsamps/brt(il->col), dfp);
200 <                brightout(Sinv, 1, m, 1./il->nsamps/brt(il->col), dfp);
198 >                brightout(Ninv, 1, m, 1./il->nsamps/bright(il->col), dfp);
199 >                brightout(da, n, m, 1./il->nsamps/bright(il->col), dfp);
200 >                brightout(Sinv, 1, m, 1./il->nsamps/bright(il->col), dfp);
201                  fputeol(dfp);
202                  fclose(dfp);
203                  printf(" %s", dfname(il, 0));
# Line 206 | Line 205 | roundout(                      /* write spherical distribution */
205          printf("\n\t%s il_alt il_azi", FNCFNM);
206          printf("\n0\n0\n");
207          il->dfnum++;
208 <        free((void *)Ninv);
209 <        free((void *)Sinv);
208 >        free(Ninv);
209 >        free(Sinv);
210   }
211  
212  
213 < extern void
213 > void
214   illumout(               /* print illum object */
215 <        register struct illum_args  *il,
215 >        struct illum_args  *il,
216          OBJREC  *ob
217   )
218   {
# Line 234 | Line 233 | illumout(              /* print illum object */
233                  cout[1] = il->col[1];
234                  cout[2] = il->col[2];
235          } else {
236 <                cout[0] = cout[1] = cout[2] = brt(il->col);
236 >                cout[0] = cout[1] = cout[2] = bright(il->col);
237          }
238          printf("\n0\n3 %f %f %f\n", cout[0], cout[1], cout[2]);
239  
# Line 242 | Line 241 | illumout(              /* print illum object */
241   }
242  
243  
244 < void
244 > static void
245   compavg(                /* compute average for set of data values */
246 <        float  col[3],
247 <        register float  *da,
246 >        COLOR  col,
247 >        COLORV  *da,
248          int  n
249   )
250   {
251 <        register int  i;
251 >        int  i;
252  
253 <        col[0] = col[1] = col[2] = 0.;
253 >        setcolor(col, 0.0, 0.0, 0.0);
254          i = n;
255          while (i-- > 0) {
256 <                col[0] += *da++;
257 <                col[1] += *da++;
259 <                col[2] += *da++;
256 >                addcolor(col, da);
257 >                da += 3;
258          }
259 <        for (i = 0; i < 3; i++)
262 <                col[i] /= (double)n;
259 >        scalecolor(col, 1./(double)n);
260   }
261  
262  
263 < void
263 > static void
264   compinv(                /* compute other side of row average */
265 <        register float  *rinv,
266 <        register float  *rp,
265 >        COLORV  *rinv,
266 >        COLORV  *rp,
267          int  m
268   )
269   {
270 <        float  avg[3];
270 >        COLOR  avg;
271  
272          compavg(avg, rp, m);            /* row average */
273          while (m-- > 0) {
# Line 281 | Line 278 | compinv(               /* compute other side of row average */
278   }
279  
280  
281 < extern int
281 > int
282   average(                /* evaluate average value for distribution */
283 <        register struct illum_args  *il,
284 <        float  *da,
283 >        struct illum_args  *il,
284 >        COLORV  *da,
285          int  n
286   )
287   {
# Line 295 | Line 292 | average(               /* evaluate average value for distribution *
292                  il->col[2] /= (double)il->nsamps;
293          }
294                                          /* brighter than minimum? */
295 <        return(brt(il->col) > il->minbrt+FTINY);
295 >        return(bright(il->col) > il->minbrt+FTINY);
296   }
297  
298  
299   static int      colmcnt = 0;    /* count of columns written */
300  
301 < void
301 > static void
302   fputnum(                        /* put out a number to fp */
303          double  d,
304          FILE  *fp
# Line 313 | Line 310 | fputnum(                       /* put out a number to fp */
310   }
311  
312  
313 < void
313 > static void
314   fputeol(                        /* write end of line to fp */
315 <        register FILE  *fp
315 >        FILE  *fp
316   )
317   {
318          putc('\n', fp);
# Line 323 | Line 320 | fputeol(                       /* write end of line to fp */
320   }
321  
322  
323 < void
323 > static void
324   colorout(       /* put out color distribution data */
325          int  p,
326 <        register float  *da,
326 >        COLORV  *da,
327          int  n,
328          int  m,
329          double  mult,
330          FILE  *fp
331   )
332   {
333 <        register int  i, j;
333 >        int  i, j;
334  
335          for (i = 0; i < n; i++) {
336                  for (j = 0; j < m; j++) {
# Line 345 | Line 342 | colorout(      /* put out color distribution data */
342   }
343  
344  
345 < void
345 > static void
346   brightout(      /* put out brightness distribution data */
347 <        register float  *da,
347 >        COLORV  *da,
348          int  n,
349          int  m,
350          double  mult,
351          FILE  *fp
352   )
353   {
354 <        register int  i, j;
354 >        int  i, j;
355  
356          for (i = 0; i < n; i++) {
357                  for (j = 0; j < m; j++) {
358 <                        fputnum(mult*brt(da), fp);
358 >                        fputnum(mult*bright(da), fp);
359                          da += 3;
360                  }
361 <                fputnum(mult*brt(da-3*m), fp);  /* wrap phi */
361 >                fputnum(mult*bright(da-3*m), fp);       /* wrap phi */
362          }
363   }

Diff Legend

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