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

Comparing src/util/ranimove2.c (file contents):
Revision 3.8 by greg, Tue Apr 19 01:15:07 2005 UTC vs.
Revision 3.12 by greg, Fri Nov 17 20:02:08 2023 UTC

# Line 4 | Line 4 | static const char      RCSid[] = "$Id$";
4   /*
5   *  ranimove2.c
6   *
7 < *  Frame refinement routines for ranimate(1).
7 > *  Frame refinement routines for ranimove(1).
8   *
9   *  Created by Gregory Ward on Wed Jan 08 2003.
10   */
# Line 26 | Line 26 | static int ray_refine(int      n);
26   static long refine_rays(long    nrays);
27  
28  
29 < extern int
29 > int
30   refine_first(void)                      /* initial refinement pass */
31   {
32          int     *esamp = (int *)zprev;  /* OK to reuse */
# Line 34 | Line 34 | refine_first(void)                     /* initial refinement pass */
34          int     nextra = 0;
35          int     x, y, xp, yp;
36          int     neigh;
37 <        register int    n, np;
37 >        int     n, np;
38  
39          if (sizeof(int) < sizeof(*zprev))
40                  error(CONSISTENCY, "code error in refine_first");
# Line 128 | Line 128 | static void subconspicuity(int x0, int y0, int x1, int
128  
129   static void
130   clr_consp(                      /* initialize a conspicuity sum */
131 <        register struct ConspSum        *cs
131 >        struct ConspSum *cs
132   )
133   {
134          if (cs == NULL)
# Line 143 | Line 143 | clr_consp(                     /* initialize a conspicuity sum */
143  
144   static void
145   sum_consp(              /* sum in conspicuity result */
146 <        register struct ConspSum        *cdest,
147 <        register struct ConspSum        *cs
146 >        struct ConspSum *cdest,
147 >        struct ConspSum *cs
148   )
149   {
150          if ((cdest == NULL) | (cs == NULL))
# Line 165 | Line 165 | est_consp(     /* estimate error conspicuity & update */
165          int     y0,
166          int     x1,
167          int     y1,
168 <        register struct ConspSum        *cs
168 >        struct ConspSum *cs
169   )
170   {
171          double  rad2, mtn2, cpd, vm, vr, csf, eest;
# Line 236 | Line 236 | est_consp(     /* estimate error conspicuity & update */
236                                                  /* put into map */
237          for ( ; y0 < y1; y0++) {
238                  float   *em0 = cerrmap + fndx(x0, y0);
239 <                register float  *emp = em0 + (x1-x0);
239 >                float   *emp = em0 + (x1-x0);
240                  while (emp-- > em0)
241                          if (eest > *emp)
242                                  *emp = eest;
# Line 263 | Line 263 | subconspicuity(        /* compute subportion of conspicuity *
263  
264          if ((x0 == x1-1) & (y0 == y1-1)) {      /* single pixel */
265                  double  hls;
266 <                register int    n = fndx(x0, y0);
266 >                int     n = fndx(x0, y0);
267                  if (sbuffer[n]) {
268                          copycolor(mysum.vsum, cbuffer[n]);
269                          copycolor(mysum.v2sum, val2map[n]);
# Line 310 | Line 310 | subconspicuity(        /* compute subportion of conspicuity *
310          sum_consp(cs, &mysum);
311   }
312  
313 < extern void
313 > void
314   conspicuity(void)                       /* compute conspicuous error map */
315   {
316          int     fhres, fvres;
# Line 375 | Line 375 | ppri_cmp(              /* pixel priority comparison */
375  
376   static int
377   ray_refine(                     /* refine the given pixel by tracing a ray */
378 <        register int    n
378 >        int     n
379   )
380   {
381          RAY     ir;
382 <        COLOR   ctmp;
382 >        COLOR   rcol, ctmp, csqr;
383          int     i;
384  
385          if (n < 0) {                    /* fetching stragglers */
# Line 407 | Line 407 | ray_refine(                    /* refine the given pixel by tracing a r
407                  } else
408                          ray_trace(&ir);
409          }
410 +        scolor_rgb(rcol, ir.rcol);
411          if (abuffer[n] == ALOWQ && asump != NULL) {
412                  if (sbuffer[n] != 1)
413                          error(CONSISTENCY, "bad code in ray_refine");
# Line 416 | Line 417 | ray_refine(                    /* refine the given pixel by tracing a r
417                                  (colval(ctmp,BLU) > 0.01)) {
418                          for (i = 0; i < 3; i++)
419                                  asump->diffsum[i] +=
420 <                                    (colval(ir.rcol,i) - colval(cbuffer[n],i))
420 >                                    (colval(rcol,i) - colval(cbuffer[n],i))
421                                          / colval(ctmp,i);
422                          asump->nsamps++;
423                  }
424                  sbuffer[n] = 0;
425          }
426 <        setcolor(ctmp,
427 <                colval(ir.rcol,RED)*colval(ir.rcol,RED),
427 <                colval(ir.rcol,GRN)*colval(ir.rcol,GRN),
428 <                colval(ir.rcol,BLU)*colval(ir.rcol,BLU));
426 >        copycolor(csqr, rcol);
427 >        multcolor(csqr, rcol);
428          if (!sbuffer[n]) {                      /* first sample */
429 <                copycolor(cbuffer[n], ir.rcol);
430 <                copycolor(val2map[n], ctmp);
429 >                copycolor(cbuffer[n], rcol);
430 >                copycolor(val2map[n], csqr);
431                  abuffer[n] = AHIGHQ;
432                  sbuffer[n] = 1;
433          } else {                                /* else sum in sample */
434 <                addcolor(cbuffer[n], ir.rcol);
435 <                addcolor(val2map[n], ctmp);
434 >                addcolor(cbuffer[n], rcol);
435 >                addcolor(val2map[n], csqr);
436                  sbuffer[n]++;
437          }
438          return(n);
# Line 463 | Line 462 | refine_rays(           /* compute refinement rays */
462          i = 0;
463                                          /* trace rays in list */
464          for (rdone = 0; rdone < nrays; rdone++) {
465 <                if (ndtset && i >= 1000 && cerrmap[pord[i]] <= FTINY)
465 >                if (ndtset && (i >= 1000) & (i < ntodo) &&
466 >                                cerrmap[pord[i]] <= FTINY)
467                          ntodo = i;
468                  if (i >= ntodo) {       /* redo conspicuity & priority */
469                          while (ray_refine(-1) >= 0)
# Line 486 | Line 486 | refine_rays(           /* compute refinement rays */
486   }
487  
488  
489 < extern int
489 > int
490   refine_frame(           /* refine current frame */
491          int     pass
492   )
# Line 499 | Line 499 | refine_frame(          /* refine current frame */
499          double  time_start, rtime_start, time_done;
500          struct AmbSum   myAmbSum;
501          long    rays_todo, nr;
502 <        register int    n;
502 >        int     n;
503                                          /* IBR refinement? */
504          if ((pass == 0) & (fcur > fbeg))
505                  return(refine_first());

Diff Legend

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