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

Comparing ray/src/util/ranimove1.c (file contents):
Revision 3.2 by greg, Tue Feb 25 02:47:24 2003 UTC vs.
Revision 3.19 by greg, Sun Sep 30 19:18:41 2012 UTC

# Line 4 | Line 4 | static const char      RCSid[] = "$Id$";
4   /*
5   *  ranimove1.c
6   *
7 < *  Basic frame rendering routines for ranimate(1).
7 > *  Basic frame rendering routines for ranimove(1).
8   *
9   *  Created by Gregory Ward on Wed Jan 08 2003.
10   */
11  
12   #include "copyright.h"
13  
14 + #include <string.h>
15 +
16 + #include "platform.h"
17   #include "ranimove.h"
18   #include "otypes.h"
19 + #include "source.h"
20   #include "random.h"
21  
22   double          acctab[256];    /* accuracy value table */
# Line 26 | Line 30 | float          *zbuffer;       /* depth at each pixel */
30   OBJECT          *obuffer;       /* object id at each pixel */
31   short           *xmbuffer;      /* x motion at each pixel */
32   short           *ymbuffer;      /* y motion at each pixel */
33 < BYTE            *abuffer;       /* accuracy at each pixel */
34 < BYTE            *sbuffer;       /* sample count per pixel */
33 > uby8            *abuffer;       /* accuracy at each pixel */
34 > uby8            *sbuffer;       /* sample count per pixel */
35  
36   VIEW            vwprev;         /* last frame's view */
37   COLOR           *cprev;         /* last frame colors */
38   float           *zprev;         /* last frame depth */
39   OBJECT          *oprev;         /* last frame objects */
40 < BYTE            *aprev;         /* last frame accuracy */
40 > uby8            *aprev;         /* last frame accuracy */
41  
42   float           *cerrmap;       /* conspicuous error map */
43   COLOR           *val2map;       /* value-squared map for variance */
# Line 43 | Line 47 | double         frm_stop;       /* when to stop rendering this frame
47   double          hlsmax;         /* maximum high-level saliency this frame */
48  
49  
50 + static void next_frame(void);
51 + static int sample_here(int      x, int  y);
52 + static int offset_cmp(const void        *p1, const void *p2);
53 + static void setmotion(int       n, FVECT        wpos);
54 + static void init_frame_sample(void);
55 +
56 +
57 + #if 0
58   void
59 < write_map(mp, fn)               /* write out float map (debugging) */
60 < float   *mp;
61 < char    *fn;
59 > write_map(              /* write out float map (debugging) */
60 >        float   *mp,
61 >        char    *fn
62 > )
63   {
64          FILE    *fp = fopen(fn, "w");
65          COLOR   scanbuf[2048];
# Line 67 | Line 80 | char   *fn;
80          }
81          fclose(fp);
82   }
83 + #endif
84  
85  
86   static void
87 < next_frame()                    /* prepare next frame buffer */
87 > next_frame(void)                        /* prepare next frame buffer */
88   {
89          VIEW    *fv;
90          char    *err;
91                                          /* get previous view */
92          if (vw.type != 0)
93 <                copystruct(&vwprev, &vw);
93 >                vwprev = vw;
94          else if (fcur > 1 && (fv = getview(fcur-1)) != NULL) {
95 <                copystruct(&vwprev, fv);
95 >                vwprev = *fv;
96                  if (setview(&vwprev) != NULL)
97                          vwprev.type = 0;
98          }
# Line 87 | Line 101 | next_frame()                   /* prepare next frame buffer */
101                  sprintf(errmsg, "cannot get view for frame %d", fcur);
102                  error(USER, errmsg);
103          }
104 <        copystruct(&vw, fv);
104 >        vw = *fv;
105          if ((err = setview(&vw)) != NULL) {
106                  sprintf(errmsg, "view error at frame %d: %s", fcur, err);
107                  error(USER, errmsg);
108          }
109          if (cbuffer == NULL) {
110 +                int     n;
111                                          /* compute resolution and allocate */
112                  switch (sscanf(vval(RESOLUTION), "%d %d %lf",
113                                  &hres, &vres, &pixaspect)) {
# Line 103 | Line 118 | next_frame()                   /* prepare next frame buffer */
118                          pixaspect = 1.;
119                          /* fall through */
120                  case 3:
121 <                        if ((hres > 0 & vres > 0))
121 >                        if ((hres > 0) & (vres > 0))
122                                  break;
123                          /* fall through */
124                  default:
# Line 116 | Line 131 | next_frame()                   /* prepare next frame buffer */
131                  obuffer = (OBJECT *)malloc(sizeof(OBJECT)*hres*vres);
132                  xmbuffer = (short *)malloc(sizeof(short)*hres*vres);
133                  ymbuffer = (short *)malloc(sizeof(short)*hres*vres);
134 <                abuffer = (BYTE *)calloc(hres*vres, sizeof(BYTE));
135 <                sbuffer = (BYTE *)calloc(hres*vres, sizeof(BYTE));
134 >                abuffer = (uby8 *)calloc(hres*vres, sizeof(uby8));
135 >                sbuffer = (uby8 *)calloc(hres*vres, sizeof(uby8));
136                  cprev = (COLOR *)malloc(sizeof(COLOR)*hres*vres);
137                  zprev = (float *)malloc(sizeof(float)*hres*vres);
138                  oprev = (OBJECT *)malloc(sizeof(OBJECT)*hres*vres);
139 <                aprev = (BYTE *)malloc(sizeof(BYTE)*hres*vres);
140 <                if ((cbuffer==NULL | zbuffer==NULL | obuffer==NULL |
141 <                                xmbuffer==NULL | ymbuffer==NULL |
142 <                                abuffer==NULL | sbuffer==NULL |
143 <                                cprev==NULL | zprev == NULL |
144 <                                oprev==NULL | aprev==NULL))
139 >                aprev = (uby8 *)malloc(sizeof(uby8)*hres*vres);
140 >                if ((cbuffer==NULL) | (zbuffer==NULL) | (obuffer==NULL) |
141 >                                (xmbuffer==NULL) | (ymbuffer==NULL) |
142 >                                (abuffer==NULL) | (sbuffer==NULL) |
143 >                                (cprev==NULL) | (zprev == NULL) |
144 >                                (oprev==NULL) | (aprev==NULL))
145                          error(SYSTEM, "out of memory in init_frame");
146 +                for (n = hres*vres; n--; ) {
147 +                        zprev[n] = -1.f;
148 +                        xmbuffer[n] = ymbuffer[n] = MO_UNK;
149 +                        oprev[n] = OVOID;
150 +                }
151                  frm_stop = getTime() + rtperfrm;
152          } else {
153                  COLOR   *cp;            /* else just swap buffers */
154                  float   *fp;
155                  OBJECT  *op;
156 <                BYTE    *bp;
156 >                uby8    *bp;
157                  cp = cprev; cprev = cbuffer; cbuffer = cp;
158                  fp = zprev; zprev = zbuffer; zbuffer = fp;
159                  op = oprev; oprev = obuffer; obuffer = op;
160                  bp = aprev; aprev = abuffer; abuffer = bp;
161 <                bzero(abuffer, sizeof(BYTE)*hres*vres);
162 <                bzero(sbuffer, sizeof(BYTE)*hres*vres);
161 >                memset(abuffer, '\0', sizeof(uby8)*hres*vres);
162 >                memset(sbuffer, '\0', sizeof(uby8)*hres*vres);
163                  frm_stop += rtperfrm;
164          }
165          cerrmap = NULL;
# Line 152 | Line 172 | next_frame()                   /* prepare next frame buffer */
172  
173  
174   static int
175 < sample_here(x, y)               /* 4x4 quincunx sample at this pixel? */
176 < register int    x, y;
175 > sample_here(            /* 4x4 quincunx sample at this pixel? */
176 >        int     x,
177 >        int     y
178 > )
179   {
180          if (y & 0x1)            /* every other row has samples */
181                  return(0);
# Line 164 | Line 186 | register int   x, y;
186  
187  
188   void
189 < sample_pos(hv, x, y, sn)        /* compute jittered sample position */
190 < double  hv[2];
191 < int     x, y;
192 < int     sn;
189 > sample_pos(     /* compute jittered sample position */
190 >        double  hv[2],
191 >        int     x,
192 >        int     y,
193 >        int     sn
194 > )
195   {
196          int     hl[2];
197  
# Line 179 | Line 203 | int    sn;
203  
204  
205   double
206 < sample_wt(xo, yo)               /* compute interpolant sample weight */
207 < int     xo, yo;
206 > sample_wt(              /* compute interpolant sample weight */
207 >        int     xo,
208 >        int yo
209 > )
210   {
211          static double   etab[400];
212 <        int     rad2 = xo*xo + yo*yo;
212 >        /* we can't use the name rad2 here, for some reason Visual C
213 >           thinks that is a constant (compiler bug?) */
214 >        int     rad_2 = xo*xo + yo*yo;
215          int     i;
216  
217          if (etab[0] <= FTINY)           /* initialize exponent table */
# Line 191 | Line 219 | int    xo, yo;
219                          etab[i] = exp(-0.1*i);
220  
221                                          /* look up Gaussian */
222 <        i = (int)((10.*3./(double)SAMPDIST2)*rad2 + .5);
222 >        i = (int)((10.*3./(double)SAMPDIST2)*rad_2 + .5);
223          if (i >= 400)
224                  return(0.0);
225          return(etab[i]);
# Line 199 | Line 227 | int    xo, yo;
227  
228  
229   static int
230 < offset_cmp(p1, p2)              /* compare offset distances */
231 < const void      *p1, *p2;
230 > offset_cmp(             /* compare offset distances */
231 >        const void      *p1,
232 >        const void      *p2
233 > )
234   {
235          return(*(const int *)p1 - *(const int *)p2);
236   }
237  
238  
239   int
240 < getclosest(iarr, nc, x, y)      /* get nc closest neighbors on same object */
241 < int     *iarr;
242 < int     nc;
243 < int     x, y;
240 > getclosest(     /* get nc closest neighbors on same object */
241 >        int     *iarr,
242 >        int     nc,
243 >        int     x,
244 >        int     y
245 > )
246   {
247   #define NSCHECK         ((2*SAMPDIST+1)*(2*SAMPDIST+1))
248          static int      hro, vro;
249          static int      ioffs[NSCHECK];
250          OBJECT  myobj;
251          int     i0, nf;
252 <        register int    i, j;
252 >        int     i, j;
253                                          /* get our object number */
254          myobj = obuffer[fndx(x, y)];
255                                          /* special case for borders */
256 <        if ((x < SAMPDIST | x >= hres-SAMPDIST |
257 <                        y < SAMPDIST | y >= vres-SAMPDIST)) {
256 >        if ((x < SAMPDIST) | (x >= hres-SAMPDIST) |
257 >                        (y < SAMPDIST) | (y >= vres-SAMPDIST)) {
258                  int     tndx[NSCHECK][2];
259                  nf = 0;
260                  for (j = y - SAMPDIST; j <= y + SAMPDIST; j++) {
# Line 234 | Line 266 | int    x, y;
266                          i0 = fndx(i, j);
267                          if (!sbuffer[i0])
268                                  continue;
269 <                        if ((myobj != OVOID & obuffer[i0] != myobj))
269 >                        if ((myobj != OVOID) & (obuffer[i0] != myobj))
270                                  continue;
271                          tndx[nf][0] = (i-x)*(i-x) + (j-y)*(j-y);
272                          tndx[nf][1] = i0;
# Line 249 | Line 281 | int    x, y;
281                  return(nf);
282          }
283                                          /* initialize offset array */
284 <        if ((hres != hro | vres != vro)) {
284 >        if ((hres != hro) | (vres != vro)) {
285                  int     toffs[NSCHECK][2];
286                  i0 = fndx(SAMPDIST, SAMPDIST);
287                  nf = 0;
# Line 268 | Line 300 | int    x, y;
300          }
301                                          /* find up to nc neighbors */
302          i0 = fndx(x, y);
303 <        for (j = 0, nf = 0; (j < NSCHECK & nf < nc); j++) {
303 >        for (j = 0, nf = 0; (j < NSCHECK) & (nf < nc); j++) {
304                  i = i0 + ioffs[j];
305 <                if (sbuffer[i] && (myobj == OVOID | obuffer[i] == myobj))
305 >                if (sbuffer[i] && (myobj == OVOID) | (obuffer[i] == myobj))
306                          iarr[nf++] = i;
307          }
308                                          /* return number found */
# Line 280 | Line 312 | int    x, y;
312  
313  
314   static void
315 < setmotion(n, wpos)              /* compute motion vector for this pixel */
316 < register int    n;
317 < FVECT   wpos;
315 > setmotion(              /* compute motion vector for this pixel */
316 >                int     n,
317 >                FVECT   wpos
318 > )
319   {
320          FVECT   ovp;
288 –        MAT4    xfm;
289 –        double  d;
321          int     moi;
322          int     xp, yp;
323                                          /* ID object and update maximum HLS */
# Line 306 | Line 337 | FVECT  wpos;
337          yp = (int)(ovp[1]*vres);
338          xmbuffer[n] = xp - (n % hres);
339          ymbuffer[n] = yp - (n / hres);
340 <        if ((xp < 0 | xp >= hres))
340 >        if ((xp < 0) | (xp >= hres))
341                  return;
342 <        if ((yp < 0 | yp >= vres))
342 >        if ((yp < 0) | (yp >= vres))
343                  return;
344          n = fndx(xp, yp);
345 <        if ((zprev[n] < 0.97*ovp[2] | zprev[n] > 1.03*ovp[2]))
345 >        if ((zprev[n] < 0.97*ovp[2]) | (zprev[n] > 1.03*ovp[2]))
346                  oprev[n] = OVOID;       /* assume it's a bad match */
347   }
348  
349  
350   static void
351 < init_frame_sample()             /* sample our initial frame */
351 > init_frame_sample(void)         /* sample our initial frame */
352   {
353          RAY     ir;
354          int     x, y;
355 <        register int    n;
355 >        int     n;
356  
357          if (!silent) {
358                  printf("\tComputing initial samples...");
# Line 344 | Line 375 | init_frame_sample()            /* sample our initial frame */
375                          continue;
376                  }
377                  if (!sample_here(x, y)) {       /* just cast */
378 <                        rayorigin(&ir, NULL, PRIMARY, 1.0);
378 >                        rayorigin(&ir, PRIMARY, NULL, NULL);
379                          if (!localhit(&ir, &thescene)) {
380 <                                if (ir.ro != &Aftplane)
381 <                                        sourcehit(&ir);
380 >                                if (ir.ro != &Aftplane && sourcehit(&ir)) {
381 >                                        rayshade(&ir, ir.ro->omod);
382 >                                        rayparticipate(&ir);
383 >                                }
384                                  copycolor(cbuffer[n], ir.rcol);
385                                  zbuffer[n] = ir.rot;
386                                  obuffer[n] = ir.robj;
# Line 362 | Line 395 | init_frame_sample()            /* sample our initial frame */
395                  }
396                  if (nprocs > 1) {               /* get sample */
397                          int     rval;
398 <                        rayorigin(&ir, NULL, PRIMARY, 1.0);
398 >                        rayorigin(&ir, PRIMARY, NULL, NULL);
399                          ir.rno = n;
400                          rval = ray_pqueue(&ir);
401                          if (!rval)
# Line 376 | Line 409 | init_frame_sample()            /* sample our initial frame */
409                  zbuffer[n] = ir.rot;
410                  obuffer[n] = ir.robj;
411                  sbuffer[n] = 1;
412 <                if (ir.rot >= FHUGE)
412 >                if (ir.rot >= 0.99*FHUGE)
413                          abuffer[n] = ADISTANT;
414                  else {
415                          abuffer[n] = ALOWQ;
# Line 404 | Line 437 | init_frame_sample()            /* sample our initial frame */
437                  n = fndx(x, y);
438                  if ((obj = obuffer[n]) == OVOID)
439                          continue;
440 <                if ((obuffer[n+1] != OVOID & obuffer[n+1] != obj)) {
440 >                if ((obuffer[n+1] != OVOID) & (obuffer[n+1] != obj)) {
441                          obuffer[n] = OVOID;
442                          obuffer[n+1] = OVOID;
443                  }
444 <                if ((obuffer[n+hres] != OVOID & obuffer[n+hres] != obj)) {
444 >                if ((obuffer[n+hres] != OVOID) & (obuffer[n+hres] != obj)) {
445                          obuffer[n] = OVOID;
446                          obuffer[n+hres] = OVOID;
447                  }
# Line 420 | Line 453 | init_frame_sample()            /* sample our initial frame */
453  
454  
455   int
456 < getambcolor(clr, obj)           /* get ambient color for object if we can */
457 < COLOR   clr;
458 < int     obj;
456 > getambcolor(            /* get ambient color for object if we can */
457 >                COLOR   clr,
458 >                int     obj
459 > )
460   {
461 <        register OBJREC *op;
461 >        OBJREC  *op;
462  
463          if (obj == OVOID)
464                  return(0);
465 <        op = objptr(obj);
466 <        if ((op->otype == OBJ_INSTANCE & op->omod == OVOID))
465 >        op = objptr(obj);               /* search for material */
466 >        if (op->omod == OVOID)
467                  return(0);
468 <                                        /* search for material */
469 <        do {
470 <                if (op->omod == OVOID || ofun[op->otype].flags & T_X)
437 <                        return(0);
438 <                op = objptr(op->omod);
439 <        } while (!ismaterial(op->otype));
468 >        op = findmaterial(objptr(op->omod));
469 >        if (op == NULL)
470 >                return(0);
471          /*
472           * Since this routine is called to compute the difference
473           * from rendering with and without interreflections,
# Line 450 | Line 481 | int    obj;
481                          if (lv[0] == op->oname[0] &&
482                                          !strcmp(lv+1, op->oname+1))
483                                  break;
484 <                if ((lv != NULL) != hirendparams.ambincl)
484 >                if ((lv != NULL) ^ hirendparams.ambincl)
485                          return(0);
486          }
487          switch (op->otype) {
# Line 490 | Line 521 | int    obj;
521  
522  
523   double
524 < estimaterr(cs, cs2, ns, ns0)    /* estimate relative error from samples */
525 < COLOR   cs, cs2;
526 < int     ns;
524 > estimaterr(             /* estimate relative error from samples */
525 >                COLOR   cs,
526 >                COLOR   cs2,
527 >                int     ns,
528 >                int ns0
529 > )
530   {
531          double  d, d2, brt;
532  
# Line 513 | Line 547 | int    ns;
547  
548  
549   double
550 < comperr(neigh, nc, ns0)         /* estimate relative error in neighborhood */
551 < int     *neigh;
552 < int     nc;
553 < int     ns0;
550 > comperr(                /* estimate relative error in neighborhood */
551 >                int     *neigh,
552 >                int     nc,
553 >                int     ns0
554 > )
555   {
556          COLOR   csum, csum2;
557          COLOR   ctmp;
558          int     i;
559          int     ns;
560 <        register int    n;
560 >        int     n;
561                                          /* add together samples */
562          setcolor(csum, 0., 0., 0.);
563          setcolor(csum2, 0., 0., 0.);
564 <        for (i = 0, ns = 0; (i < nc & ns < NSAMPOK); i++) {
564 >        for (i = 0, ns = 0; (i < nc) & (ns < NSAMPOK); i++) {
565                  n = neigh[i];
566                  addcolor(csum, cbuffer[n]);
567                  if (val2map != NULL) {
# Line 548 | Line 583 | int    ns0;
583  
584  
585   void
586 < comp_frame_error()              /* initialize frame error values */
586 > comp_frame_error(void)          /* initialize frame error values */
587   {
588 <        BYTE    *edone = NULL;
588 >        uby8    *edone = NULL;
589          COLOR   objamb;
590          double  eest;
591          int     neigh[NSAMPOK];
592          int     nc;
593 <        int     x, y, i, j;
594 <        register int    n;
593 >        int     x, y, i;
594 >        int     n;
595  
596          if (!silent) {
597                  printf("\tComputing error map\n");
# Line 574 | Line 609 | comp_frame_error()             /* initialize frame error values *
609                   * error should be less than the ambient value divided
610                   * by the returned ray value -- we take half of this.
611                   */
612 <                edone = (BYTE *)calloc(hres*vres, sizeof(BYTE));
613 <                for (y = vres; y--; )
614 <                    for (x = hres; x--; ) {
580 <                        n = fndx(x, y);
581 <                        if ((abuffer[n] != ALOWQ | obuffer[n] == OVOID))
612 >                edone = (uby8 *)calloc(hres*vres, sizeof(uby8));
613 >                for (n = hres*vres; n--; ) {
614 >                        if ((abuffer[n] != ALOWQ) | (obuffer[n] == OVOID))
615                                  continue;
616                          if (!getambcolor(objamb, obuffer[n]))
617                                  continue;
# Line 594 | Line 627 | comp_frame_error()             /* initialize frame error values *
627                          else if (i >= ADISTANT/2) i = ADISTANT/2-1;
628                          abuffer[n] = i;
629                          edone[n] = 1;
630 <                    }
630 >                }
631          }
632                                          /* final statistical estimate */
633          for (y = vres; y--; )
# Line 627 | Line 660 | comp_frame_error()             /* initialize frame error values *
660  
661  
662   void
663 < init_frame()                    /* render base (low quality) frame */
663 > init_frame(void)                        /* render base (low quality) frame */
664   {
665          int     restart;
633 –
666                                          /* allocate/swap buffers */
667          next_frame();
668                                          /* check rendering status */
669          restart = (!nobjects || vdef(MOVE));
670          if (!restart && curparams != &lorendparams && nprocs > 1)
671                  restart = -1;
640 –        if (restart > 0)
641 –                if (nprocs > 1)
642 –                        ray_pdone(1);
643 –                else
644 –                        ray_done(1);
672                                          /* post low quality parameters */
673          if (curparams != &lorendparams)
674                  ray_restore(curparams = &lorendparams);
# Line 673 | Line 700 | init_frame()                   /* render base (low quality) frame */
700          init_frame_sample();
701                                          /* initialize frame error */
702          comp_frame_error();
703 < return;
703 > #if 0
704   {
705          float   *ebuf = (float *)malloc(sizeof(float)*hres*vres);
706          char    fnm[256];
707 <        register int    n;
707 >        int     n;
708          for (n = hres*vres; n--; )
709                  ebuf[n] = acctab[abuffer[n]];
710          sprintf(fnm, vval(BASENAME), fcur);
# Line 685 | Line 712 | return;
712          write_map(ebuf, fnm);
713          free((void *)ebuf);
714   }
715 + #endif
716   }
717  
718  
719   void
720 < filter_frame()                  /* interpolation, motion-blur, and exposure */
720 > filter_frame(void)                      /* interpolation, motion-blur, and exposure */
721   {
722 <        double  expval = expspec_val(getexp(fcur));
723 <        int     x, y;
724 <        int     neigh[NPINTERP];
725 <        int     nc;
726 <        COLOR   cval;
727 <        double  w, wsum;
728 <        register int    n;
722 >        const double    expval = expspec_val(getexp(fcur));
723 >        int             x, y;
724 >        int             neigh[NPINTERP];
725 >        int             nc;
726 >        COLOR           cval;
727 >        double          w, wsum;
728 >        int             n;
729  
730   #if 0
731 < /* XXX TEMPORARY!! */
732 < conspicuity();
733 < write_map(cerrmap, "outcmap.pic");
734 < {
735 <        float   *ebuf = (float *)malloc(sizeof(float)*hres*vres);
736 <        for (n = hres*vres; n--; )
737 <                ebuf[n] = acctab[abuffer[n]];
738 <        write_map(ebuf, "outerr.pic");
739 <        free((void *)ebuf);
740 < }
731 >        /* XXX TEMPORARY!! */
732 >        conspicuity();
733 >        write_map(cerrmap, "outcmap.pic");
734 >        {
735 >                float   *ebuf = (float *)malloc(sizeof(float)*hres*vres);
736 >                for (n = hres*vres; n--; )
737 >                        ebuf[n] = acctab[abuffer[n]];
738 >                write_map(ebuf, "outerr.pic");
739 >                free((void *)ebuf);
740 >        }
741   #endif
742  
743          if (!silent) {
# Line 717 | Line 745 | write_map(cerrmap, "outcmap.pic");
745                  fflush(stdout);
746          }
747                                          /* normalize samples */
748 <        for (y = vres; y--; )
721 <            for (x = hres; x--; ) {
722 <                n = fndx(x, y);
748 >        for (n = hres*vres; n--; ) {
749                  if (sbuffer[n] <= 1)
750                          continue;
751                  w = 1.0/(double)sbuffer[n];
752                  scalecolor(cbuffer[n], w);
753 <            }
753 >        }
754                                          /* interpolate samples */
755          for (y = vres; y--; )
756              for (x = hres; x--; ) {
# Line 733 | Line 759 | write_map(cerrmap, "outcmap.pic");
759                          continue;
760                  nc = getclosest(neigh, NPINTERP, x, y);
761                  setcolor(cbuffer[n], 0., 0., 0.);
762 +                if (nc <= 0) {          /* no acceptable neighbors */
763 +                        if (y < vres-1)
764 +                                nc = fndx(x, y+1);
765 +                        else if (x < hres-1)
766 +                                nc = fndx(x+1, y);
767 +                        else
768 +                                continue;
769 +                        copycolor(cbuffer[n], cbuffer[nc]);
770 +                        continue;
771 +                }
772                  wsum = 0.;
773                  while (nc-- > 0) {
774                          copycolor(cval, cbuffer[neigh[nc]]);
# Line 742 | Line 778 | write_map(cerrmap, "outcmap.pic");
778                          addcolor(cbuffer[n], cval);
779                          wsum += w;
780                  }
781 <                if (wsum > FTINY) {
782 <                        w = 1.0/wsum;
747 <                        scalecolor(cbuffer[n], w);
748 <                }
781 >                w = 1.0/wsum;
782 >                scalecolor(cbuffer[n], w);
783              }
784                                          /* motion blur if requested */
785          if (mblur > .02) {
752 –                int     len;
786                  int     xs, ys, xl, yl;
787                  int     rise, run;
788                  long    rise2, run2;
789                  int     n2;
790                  int     cnt;
791                                          /* sum in motion streaks */
792 <                bzero(outbuffer, sizeof(COLOR)*hres*vres);
793 <                bzero(wbuffer, sizeof(float)*hres*vres);
792 >                memset(outbuffer, '\0', sizeof(COLOR)*hres*vres);
793 >                memset(wbuffer, '\0', sizeof(float)*hres*vres);
794                  for (y = vres; y--; )
795                      for (x = hres; x--; ) {
796                          n = fndx(x, y);
# Line 786 | Line 819 | write_map(cerrmap, "outcmap.pic");
819                                  scalecolor(cval, w);
820                                  while (cnt)
821                                          if (rise2 >= run2) {
822 <                                                if ((xl >= 0 & xl < hres &
823 <                                                        yl >= 0 & yl < vres)) {
822 >                                                if ((xl >= 0) & (xl < hres) &
823 >                                                    (yl >= 0) & (yl < vres)) {
824                                                          n2 = fndx(xl, yl);
825                                                          addcolor(outbuffer[n2],
826                                                                          cval);
# Line 807 | Line 840 | write_map(cerrmap, "outcmap.pic");
840                                  scalecolor(cval, w);
841                                  while (cnt)
842                                          if (run2 >= rise2) {
843 <                                                if ((xl >= 0 & xl < hres &
844 <                                                        yl >= 0 & yl < vres)) {
843 >                                                if ((xl >= 0) & (xl < hres) &
844 >                                                    (yl >= 0) & (yl < vres)) {
845                                                          n2 = fndx(xl, yl);
846                                                          addcolor(outbuffer[n2],
847                                                                          cval);
# Line 824 | Line 857 | write_map(cerrmap, "outcmap.pic");
857                          }
858                      }
859                                          /* compute final results */
860 <                for (y = vres; y--; )
828 <                    for (x = hres; x--; ) {
829 <                        n = fndx(x, y);
860 >                for (n = hres*vres; n--; ) {
861                          if (wbuffer[n] <= FTINY)
862                                  continue;
863 <                        w = 1./wbuffer[n];
863 >                        w = expval/wbuffer[n];
864                          scalecolor(outbuffer[n], w);
865 <                    }
866 <        } else
867 <                for (n = hres*vres; n--; )
868 <                        copycolor(outbuffer[n], cbuffer[n]);
838 < /*
839 < for (n = hres*vres; n--; )
840 <        if (!sbuffer[n])
841 <                setcolor(outbuffer[n], 0., 0., 0.);
842 < */
843 <                                /* adjust exposure */
844 <        if ((expval < 0.99 | expval > 1.01))
845 <                for (n = hres*vres; n--; )
865 >                }
866 >        } else {                        /* no blur -- just exposure */
867 >                memcpy(outbuffer, cbuffer, sizeof(COLOR)*hres*vres);
868 >                for (n = ((expval < 0.99) | (expval > 1.01))*hres*vres; n--; )
869                          scalecolor(outbuffer[n], expval);
870 < return;
871 < {
872 <        float   *sbuf = (float *)malloc(sizeof(float)*hres*vres);
873 <        char    fnm[256];
874 <        sprintf(fnm, vval(BASENAME), fcur);
875 <        strcat(fnm, "_outsamp.pic");
876 <        for (n = hres*vres; n--; )
877 <                sbuf[n] = (float)sbuffer[n];
878 <        write_map(sbuf, fnm);
879 <        free((void *)sbuf);
870 >        }
871 >        /*
872 >           for (n = hres*vres; n--; )
873 >                   if (!sbuffer[n])
874 >                           setcolor(outbuffer[n], 0., 0., 0.);
875 >         */
876 > #if 0
877 >        {
878 >                float   *sbuf = (float *)malloc(sizeof(float)*hres*vres);
879 >                char    fnm[256];
880 >                sprintf(fnm, vval(BASENAME), fcur);
881 >                strcat(fnm, "_outsamp.pic");
882 >                for (n = hres*vres; n--; )
883 >                        sbuf[n] = (float)sbuffer[n];
884 >                write_map(sbuf, fnm);
885 >                free((void *)sbuf);
886 >        }
887 > #endif
888   }
858 – }
889  
890  
891   void
892 < send_frame()                    /* send frame to destination */
892 > send_frame(void)                        /* send frame to destination */
893   {
894 <        char    pfname[1024];
894 >        char    fname[1024];
895          double  d;
896          FILE    *fp;
897          int     y;
898                                          /* open output picture */
899 <        sprintf(pfname, vval(BASENAME), fcur);
900 <        strcat(pfname, ".pic");
901 <        fp = fopen(pfname, "w");
899 >        sprintf(fname, vval(BASENAME), fcur);
900 >        strcat(fname, ".hdr");
901 >        fp = fopen(fname, "w");
902          if (fp == NULL) {
903 <                sprintf(errmsg, "cannot open output frame \"%s\"", pfname);
903 >                sprintf(errmsg, "cannot open output frame \"%s\"", fname);
904                  error(SYSTEM, errmsg);
905          }
906 < #ifdef MSDOS
877 <        setmode(fileno(fp), O_BINARY);
878 < #endif
906 >        SET_FILE_BINARY(fp);
907          if (!silent) {
908 <                printf("\tWriting to \"%s\"\n", pfname);
908 >                printf("\tWriting to \"%s\"\n", fname);
909                  fflush(stdout);
910          }
911                                          /* write header */
# Line 888 | Line 916 | send_frame()                   /* send frame to destination */
916          fputnow(fp);
917          fputs(VIEWSTR, fp); fprintview(&vw, fp); fputc('\n', fp);
918          d = expspec_val(getexp(fcur));
919 <        if ((d < 0.99 | d > 1.01))
919 >        if ((d < 0.99) | (d > 1.01))
920                  fputexpos(d, fp);
921          d = viewaspect(&vw) * hres / vres;
922 <        if ((d < 0.99 | d > 1.01))
922 >        if ((d < 0.99) | (d > 1.01))
923                  fputaspect(d, fp);
924          fputformat(COLRFMT, fp);
925          fputc('\n', fp);                /* end header */
# Line 906 | Line 934 | send_frame()                   /* send frame to destination */
934                          goto writerr;
935          if (fclose(fp) == EOF)
936                  goto writerr;
937 +        if (vdef(ZNAME)) {              /* output z-buffer */
938 +                sprintf(fname, vval(ZNAME), fcur);
939 +                strcat(fname, ".zbf");
940 +                fp = fopen(fname, "w");
941 +                if (fp == NULL) {
942 +                        sprintf(errmsg, "cannot open z-file \"%s\"\n", fname);
943 +                        error(SYSTEM, errmsg);
944 +                }
945 +                SET_FILE_BINARY(fp);
946 +                if (!silent) {
947 +                        printf("\tWriting depths to \"%s\"\n", fname);
948 +                        fflush(stdout);
949 +                }
950 +                for (y = vres; y--; )
951 +                        if (fwrite(zbuffer+y*hres, sizeof(float),
952 +                                                hres, fp) != hres)
953 +                                goto writerr;
954 +                if (fclose(fp) == EOF)
955 +                        goto writerr;
956 +        }
957 +        if (vdef(MNAME)) {              /* output motion buffer */
958 +                unsigned short  *mbuffer = (unsigned short *)malloc(
959 +                                                sizeof(unsigned short)*3*hres);
960 +                int             x;
961 +                if (mbuffer == NULL)
962 +                        error(SYSTEM, "out of memory in send_frame()");
963 +                sprintf(fname, vval(MNAME), fcur);
964 +                strcat(fname, ".mvo");
965 +                fp = fopen(fname, "w");
966 +                if (fp == NULL) {
967 +                        sprintf(errmsg, "cannot open motion file \"%s\"\n",
968 +                                                        fname);
969 +                        error(SYSTEM, errmsg);
970 +                }
971 +                SET_FILE_BINARY(fp);
972 +                if (!silent) {
973 +                        printf("\tWriting motion vectors to \"%s\"\n", fname);
974 +                        fflush(stdout);
975 +                }
976 +                for (y = vres; y--; ) {
977 +                        for (x = hres; x--; ) {
978 +                                mbuffer[3*x] = xmbuffer[fndx(x,y)] + 0x8000;
979 +                                mbuffer[3*x+1] = ymbuffer[fndx(x,y)] + 0x8000;
980 +                                mbuffer[3*x+2] = (oprev[fndx(x,y)]!=OVOID)*0x8000;
981 +                        }
982 +                        if (fwrite(mbuffer, sizeof(*mbuffer),
983 +                                                3*hres, fp) != 3*hres)
984 +                                goto writerr;
985 +                }
986 +                free((void *)mbuffer);
987 +                if (fclose(fp) == EOF)
988 +                        goto writerr;
989 +        }
990          return;                         /* all is well */
991   writerr:
992 <        sprintf(errmsg, "error writing frame \"%s\"", pfname);
992 >        sprintf(errmsg, "error writing file \"%s\"", fname);
993          error(SYSTEM, errmsg);
994   }
995  
996  
997   void
998 < free_frame()                    /* free frame allocation */
998 > free_frame(void)                        /* free frame allocation */
999   {
1000          if (cbuffer == NULL)
1001                  return;

Diff Legend

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