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

Comparing ray/src/rt/ambcomp.c (file contents):
Revision 1.2 by greg, Fri Jun 7 13:43:05 1991 UTC vs.
Revision 1.5 by greg, Thu Jun 13 09:41:17 1991 UTC

# Line 54 | Line 54 | AMBSAMP  *d1, *d2;
54   }
55  
56  
57 – double
57   divsample(dp, h, r)                     /* sample a division */
58   register AMBSAMP  *dp;
59   AMBHEMI  *h;
# Line 68 | Line 67 | RAY  *r;
67          register int  i;
68  
69          if (rayorigin(&ar, r, AMBIENT, 0.5) < 0)
70 <                return(0.0);
70 >                return(-1);
71          hlist[0] = r->rno;
72          hlist[1] = dp->t;
73          hlist[2] = dp->p;
# Line 87 | Line 86 | RAY  *r;
86          rayvalue(&ar);
87          ndims--;
88          addcolor(dp->v, ar.rcol);
89 <        if (ar.rot < FHUGE)
90 <                dp->r += 1.0/ar.rot;
89 >        if (ar.rt < FHUGE)
90 >                dp->r += 1.0/ar.rt;
91                                          /* (re)initialize error */
92          if (dp->n++) {
93                  b2 = bright(dp->v)/dp->n - bright(ar.rcol);
# Line 96 | Line 95 | RAY  *r;
95                  dp->k = b2/(dp->n*dp->n);
96          } else
97                  dp->k = 0.0;
98 <        return(ar.rot);
98 >        return(0);
99   }
100  
101  
# Line 139 | Line 138 | FVECT  pg, dg;
138                          setcolor(dp->v, 0.0, 0.0, 0.0);
139                          dp->r = 0.0;
140                          dp->n = 0;
141 <                        if ((d = divsample(dp, &hemi, r)) == 0.0)
141 >                        if (divsample(dp, &hemi, r) < 0)
142                                  goto oopsy;
143                          if (div != NULL)
144                                  dp++;
# Line 149 | Line 148 | FVECT  pg, dg;
148                          }
149                  }
150          if (ns > 0) {                   /* perform super-sampling */
151 <                comperrs(div, hemi);                    /* compute errors */
151 >                comperrs(div, &hemi);                   /* compute errors */
152                  qsort(div, ndivs, sizeof(AMBSAMP), ambcmp);     /* sort divs */
154 –                dp = div + ndivs;                       /* skim excess */
155 –                for (i = ndivs; i > ns; i--) {
156 –                        dp--;
157 –                        addcolor(acol, dp->v);
158 –                        arad += dp->r;
159 –                }
153                                                  /* super-sample */
154                  for (i = ns; i > 0; i--) {
155                          copystruct(&dnew, div);
156 <                        if ((d = divsample(&dnew, &hemi)) == 0.0)
156 >                        if (divsample(&dnew, &hemi, r) < 0)
157                                  goto oopsy;
165 –                        if (d < FHUGE)
166 –                                arad += 1.0 / d;
158                                                          /* reinsert */
159                          dp = div;
160                          j = ndivs < i ? ndivs : i;
# Line 172 | Line 163 | FVECT  pg, dg;
163                                  dp++;
164                          }
165                          copystruct(dp, &dnew);
175 –                                                        /* extract darkest */
176 –                        if (i <= ndivs) {
177 –                                dp = div + i-1;
178 –                                arad += dp->r;
179 –                                if (dp->n > 1) {
180 –                                        b = 1.0/dp->n;
181 –                                        scalecolor(dp->v, b);
182 –                                        dp->r *= b;
183 –                                        dp->n = 1;
184 –                                }
185 –                                addcolor(acol, dp->v);
186 –                        }
166                  }
167                  if (pg != NULL || dg != NULL)   /* restore order */
168                          qsort(div, ndivs, sizeof(AMBSAMP), ambnorm);
169          }
170                                          /* compute returned values */
171 <        if (pg != NULL)
172 <                posgradient(pg, div, &hemi);
173 <        if (dg != NULL)
174 <                dirgradient(dg, div, &hemi);
175 <        if (div != NULL)
171 >        if (div != NULL) {
172 >                for (i = ndivs, dp = div; i-- > 0; dp++) {
173 >                        arad += dp->r;
174 >                        if (dp->n > 1) {
175 >                                b = 1.0/dp->n;
176 >                                scalecolor(dp->v, b);
177 >                                dp->r *= b;
178 >                                dp->n = 1;
179 >                        }
180 >                        addcolor(acol, dp->v);
181 >                }
182 >                b = bright(acol);
183 >                if (b > FTINY)
184 >                        b = ndivs/b;
185 >                else
186 >                        b = 0.0;
187 >                if (pg != NULL) {
188 >                        posgradient(pg, div, &hemi);
189 >                        for (i = 0; i < 3; i++)
190 >                                pg[i] *= b;
191 >                }
192 >                if (dg != NULL) {
193 >                        dirgradient(dg, div, &hemi);
194 >                        for (i = 0; i < 3; i++)
195 >                                dg[i] *= b;
196 >                }
197                  free((char *)div);
198 +        }
199          b = 1.0/ndivs;
200          scalecolor(acol, b);
201          if (arad <= FTINY)
# Line 231 | Line 232 | RAY  *r;
232          if (i >= 3)
233                  error(CONSISTENCY, "bad ray direction in inithemi");
234          hp->uy[i] = 1.0;
235 <        fcross(hp->ux, hp->uz, hp->uy);
235 >        fcross(hp->ux, hp->uy, hp->uz);
236          normalize(hp->ux);
237 <        fcross(hp->uy, hp->ux, hp->uz);
237 >        fcross(hp->uy, hp->uz, hp->ux);
238   }
239  
240  
# Line 260 | Line 261 | register AMBHEMI  *hp;
261                                  b2 *= b2 * 0.25;
262                                  dp[0].k += b2;
263                                  dp[-1].k += b2;
264 <                        }
265 <                        if (j == hp->np-1) {    /* around */
265 <                                b2 = bright(dp[-(hp->np-1)].v) - b;
264 >                        } else {                /* around */
265 >                                b2 = bright(dp[hp->np-1].v) - b;
266                                  b2 *= b2 * 0.25;
267                                  dp[0].k += b2;
268 <                                dp[-(hp->np-1)].k += b2;
268 >                                dp[hp->np-1].k += b2;
269                          }
270                          dp++;
271                  }
# Line 323 | Line 323 | AMBHEMI  *hp;
323                          dp += hp->np;
324                  }
325                  if (hp->nt > 1) {
326 <                        mag0 /= (double)(hp->nt-1);
326 >                        mag0 /= (double)hp->np;
327                          mag1 /= (double)hp->nt;
328                  }
329                  phi = 2.0*PI * (double)j/hp->np;
# Line 332 | Line 332 | AMBHEMI  *hp;
332                  yd += mag0*sinp + mag1*cosp;
333          }
334          for (i = 0; i < 3; i++)
335 <                gv[i] = (xd*hp->ux[i] + yd*hp->uy[i])/hp->np;
335 >                gv[i] = (xd*hp->ux[i] + yd*hp->uy[i])/PI;
336   }
337  
338  
# Line 364 | Line 364 | AMBHEMI  *hp;
364                  yd += mag * sin(phi);
365          }
366          for (i = 0; i < 3; i++)
367 <                gv[i] = (xd*hp->ux[i] + yd*hp->uy[i])/(hp->nt*hp->np);
367 >                gv[i] = (xd*hp->ux[i] + yd*hp->uy[i])*PI/(hp->nt*hp->np);
368   }

Diff Legend

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