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

Comparing ray/src/px/pcond4.c (file contents):
Revision 3.8 by greg, Tue Oct 8 12:48:00 1996 UTC vs.
Revision 3.15 by gregl, Wed Aug 13 11:24:48 1997 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1996 Regents of the University of California */
1 > /* Copyright (c) 1997 Regents of the University of California */
2  
3   #ifndef lint
4   static char SCCSid[] = "$SunId$ LBL";
# Line 14 | Line 14 | static char SCCSid[] = "$SunId$ LBL";
14  
15   #define VADAPT          0.08            /* fraction of adaptation from veil */
16  
17 < extern COLOR    *fovimg;                /* foveal (1 degree) averaged image */
18 < extern short    fvxr, fvyr;             /* foveal image resolution */
17 > static COLOR    *veilimg = NULL;        /* veiling image */
18  
20 – #define fovscan(y)      (fovimg+(y)*fvxr)
21 –
22 – static COLOR    *veilimg;               /* veiling image */
23 –
19   #define veilscan(y)     (veilimg+(y)*fvxr)
20  
21   static float    (*raydir)[3] = NULL;    /* ray direction for each pixel */
# Line 83 | Line 78 | compveil()                             /* compute veiling image */
78          COLOR   ctmp, vsum;
79          int     px, py;
80          register int    x, y;
81 +
82 +        if (veilimg != NULL)            /* already done? */
83 +                return;
84                                          /* compute ray directions */
85          compraydir();
86                                          /* compute veil image */
# Line 100 | Line 98 | compveil()                             /* compute veiling image */
98                                                          rdirscan(y)[x]);
99                                          if (t2 <= FTINY) continue;
100                                          /*      use approximation instead
101 <                                        t2 = acos(t2);
102 <                                        t2 = 1./(t2*t2);
101 >                                        t3 = acos(t2);
102 >                                        t2 = t2/(t3*t3);
103                                          */
104 <                                        t2 = .5 / (1. - t2);
104 >                                        t2 *= .5 / (1. - t2);
105                                          copycolor(ctmp, fovscan(y)[x]);
106                                          scalecolor(ctmp, t2);
107                                          addcolor(vsum, ctmp);
108                                          t2sum += t2;
109                                  }
110                          /* VADAPT of original is subtracted in addveil() */
111 <                        scalecolor(vsum, VADAPT/t2sum);
111 >                        if (t2sum > FTINY)
112 >                                scalecolor(vsum, VADAPT/t2sum);
113                          copycolor(veilscan(py)[px], vsum);
114                  }
115 +                                        /* modify FOV sample image */
116 +        for (y = 0; y < fvyr; y++)
117 +                for (x = 0; x < fvxr; x++) {
118 +                        scalecolor(fovscan(y)[x], 1.-VADAPT);
119 +                        addcolor(fovscan(y)[x], veilscan(y)[x]);
120 +                }
121 +        comphist();                     /* recompute histogram */
122   }
123  
124  
# Line 166 | Line 172 | float  *inpacuD;               /* input acuity data (cycles/degree)
172   double
173   hacuity(La)                     /* return visual acuity in cycles/degree */
174   double  La;
175 < {                               /* data due to S. Shaler (we should fit it!) */
176 < #define NPOINTS 20
177 <        static float    l10lum[NPOINTS] = {
172 <                -3.10503,-2.66403,-2.37703,-2.09303,-1.64403,-1.35803,
173 <                -1.07403,-0.67203,-0.38503,-0.10103,0.29397,0.58097,0.86497,
174 <                1.25697,1.54397,1.82797,2.27597,2.56297,2.84697,3.24897
175 <        };
176 <        static float    resfreq[NPOINTS] = {
177 <                2.09,3.28,3.79,4.39,6.11,8.83,10.94,18.66,23.88,31.05,37.42,
178 <                37.68,41.60,43.16,45.30,47.00,48.43,48.32,51.06,51.09
179 <        };
180 <        double  l10La;
181 <        register int    i;
182 <                                        /* check limits */
183 <        if (La <= 7.85e-4)
184 <                return(resfreq[0]);
185 <        if (La >= 1.78e3)
186 <                return(resfreq[NPOINTS-1]);
187 <                                        /* interpolate data */
188 <        l10La = log10(La);
189 <        for (i = 0; i < NPOINTS-2 && l10lum[i+1] <= l10La; i++)
190 <                ;
191 <        return( ( (l10lum[i+1] - l10La)*resfreq[i] +
192 <                        (l10La - l10lum[i])*resfreq[i+1] ) /
193 <                        (l10lum[i+1] - l10lum[i]) );
194 < #undef NPOINTS
175 > {
176 >                                        /* functional fit */
177 >        return(17.25*atan(1.4*log10(La) + 0.35) + 25.72);
178   }
179  
180  
# Line 241 | Line 224 | int    y;
224          register int    x;
225                                          /* compute foveal y position */
226          iy = dy = (y+.5)/numscans(&inpres)*fvyr - .5;
227 <        if (iy >= fvyr-1) iy--;
227 >        while (iy >= fvyr-1) iy--;
228          dy -= (double)iy;
229          for (x = 0; x < scanlen(&inpres); x++) {
230                                          /* compute foveal x position */
231                  ix = dx = (x+.5)/scanlen(&inpres)*fvxr - .5;
232 <                if (ix >= fvxr-1) ix--;
232 >                while (ix >= fvxr-1) ix--;
233                  dx -= (double)ix;
234                                          /* interpolate sample rate */
235                  sr = (1.-dy)*((1.-dx)*tsampr(ix,iy) + dx*tsampr(ix+1,iy)) +
# Line 302 | Line 285 | SCANBAR        *sb;
285          dy -= (double)iy;
286                                          /* get scanlines */
287          sl0 = getascan(sb, iy);
288 <        if (sl0 == NULL) {
289 <                fprintf(stderr, "%s: internal - cannot backspace in ascanval\n",
290 <                                progname);
291 <                exit(1);
309 <        }
288 > #ifdef DEBUG
289 >        if (sl0 == NULL)
290 >                error(INTERNAL, "cannot backspace in ascanval");
291 > #endif
292          sl1 = getascan(sb, iy+1);
293                                          /* 2D linear interpolation */
294          copycolor(col, sl0[ix]);
# Line 322 | Line 304 | SCANBAR        *sb;
304          scalecolor(col, 1.-dy);
305          scalecolor(c1y, dy);
306          addcolor(col, c1y);
307 +        for (ix = 0; ix < 3; ix++)      /* make sure no negative */
308 +                if (colval(col,ix) < 0.)
309 +                        colval(col,ix) = 0.;
310   }
311  
312  
313   SCANBAR *
314 < sballoc(sr, ns, sl)             /* allocate scanbar */
315 < int     sr;             /* sampling rate */
314 > sballoc(se, ns, sl)             /* allocate scanbar */
315 > int     se;             /* sampling rate exponent */
316   int     ns;             /* number of scanlines */
317   int     sl;             /* original scanline length */
318   {
319          SCANBAR *sbarr;
320          register SCANBAR        *sb;
321  
322 <        sbarr = sb = (SCANBAR *)malloc((sr+1)*sizeof(SCANBAR));
322 >        sbarr = sb = (SCANBAR *)malloc((se+1)*sizeof(SCANBAR));
323          if (sb == NULL)
324                  syserror("malloc");
325          do {
326 <                sb->sdata = (COLOR *)malloc((sl>>sr)*ns*sizeof(COLOR));
326 >                sb->sampe = se;
327 >                sb->len = sl>>se;
328 >                sb->nscans = ns;
329 >                sb->sdata = (COLOR *)malloc(sb->len*ns*sizeof(COLOR));
330                  if (sb->sdata == NULL)
331                          syserror("malloc");
344 –                sb->sampe = sr;
345 –                sb->nscans = ns;
346 –                sb->len = sl>>sr;
332                  sb->nread = 0;
333                  ns <<= 1;
334                  sb++;
335 <        } while (--sr >= 0);
335 >        } while (--se >= 0);
336          return(sbarr);
337   }
338  
# Line 376 | Line 361 | initacuity()                   /* initialize variable acuity sampling
361                          }
362                          fcross(cp, diffx, diffy);
363                          omega = 0.5 * sqrt(DOT(cp,cp));
364 <                        if (omega <= FTINY)
364 >                        if (omega <= FTINY*FTINY)
365                                  tsampr(x,y) = 1.;
366                          else if ((tsampr(x,y) = PI/180. / sqrt(omega) /
367                                          hacuity(plum(fovscan(y)[x]))) > maxsr)
# Line 388 | Line 373 | initacuity()                   /* initialize variable acuity sampling
373                  tsampr(x,fvyr-1) = tsampr(x,fvyr-2);
374          }
375          for (y = 0; y < fvyr; y++) {
376 <                tsampr(y,0) = tsampr(y,1);
377 <                tsampr(y,fvxr-1) = tsampr(y,fvxr-2);
376 >                tsampr(0,y) = tsampr(1,y);
377 >                tsampr(fvxr-1,y) = tsampr(fvxr-2,y);
378          }
379                                          /* initialize with next power of two */
380          rootbar = sballoc((int)(log(maxsr)/log(2.))+1, 2, scanlen(&inpres));

Diff Legend

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