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

Comparing src/util/ranimove1.c (file contents):
Revision 3.15 by greg, Mon Nov 10 19:08:20 2008 UTC vs.
Revision 3.28 by greg, Tue Jul 1 19:40:35 2025 UTC

# Line 16 | Line 16 | static const char      RCSid[] = "$Id$";
16   #include "platform.h"
17   #include "ranimove.h"
18   #include "otypes.h"
19 + #include "otspecial.h"
20   #include "source.h"
21   #include "random.h"
22  
# Line 30 | Line 31 | float          *zbuffer;       /* depth at each pixel */
31   OBJECT          *obuffer;       /* object id at each pixel */
32   short           *xmbuffer;      /* x motion at each pixel */
33   short           *ymbuffer;      /* y motion at each pixel */
34 < BYTE            *abuffer;       /* accuracy at each pixel */
35 < BYTE            *sbuffer;       /* sample count per pixel */
34 > uby8            *abuffer;       /* accuracy at each pixel */
35 > uby8            *sbuffer;       /* sample count per pixel */
36  
37   VIEW            vwprev;         /* last frame's view */
38   COLOR           *cprev;         /* last frame colors */
39   float           *zprev;         /* last frame depth */
40   OBJECT          *oprev;         /* last frame objects */
41 < BYTE            *aprev;         /* last frame accuracy */
41 > uby8            *aprev;         /* last frame accuracy */
42  
43   float           *cerrmap;       /* conspicuous error map */
44   COLOR           *val2map;       /* value-squared map for variance */
# Line 48 | Line 49 | double         hlsmax;         /* maximum high-level saliency this f
49  
50  
51   static void next_frame(void);
52 < static int sample_here(int      x, int  y);
53 < static int offset_cmp(const void        *p1, const void *p2);
54 < static void setmotion(int       n, FVECT        wpos);
52 > static int sample_here(int x, int y);
53 > static int offset_cmp(const void *p1, const void *p2);
54 > static void setmotion(int n, FVECT wpos);
55   static void init_frame_sample(void);
56  
57  
58   #if 0
59 < extern void
59 > void
60   write_map(              /* write out float map (debugging) */
61          float   *mp,
62          char    *fn
# Line 107 | Line 108 | next_frame(void)                       /* prepare next frame buffer */
108                  error(USER, errmsg);
109          }
110          if (cbuffer == NULL) {
111 +                int     n;
112                                          /* compute resolution and allocate */
113                  switch (sscanf(vval(RESOLUTION), "%d %d %lf",
114                                  &hres, &vres, &pixaspect)) {
# Line 130 | Line 132 | next_frame(void)                       /* prepare next frame buffer */
132                  obuffer = (OBJECT *)malloc(sizeof(OBJECT)*hres*vres);
133                  xmbuffer = (short *)malloc(sizeof(short)*hres*vres);
134                  ymbuffer = (short *)malloc(sizeof(short)*hres*vres);
135 <                abuffer = (BYTE *)calloc(hres*vres, sizeof(BYTE));
136 <                sbuffer = (BYTE *)calloc(hres*vres, sizeof(BYTE));
135 >                abuffer = (uby8 *)calloc(hres*vres, sizeof(uby8));
136 >                sbuffer = (uby8 *)calloc(hres*vres, sizeof(uby8));
137                  cprev = (COLOR *)malloc(sizeof(COLOR)*hres*vres);
138                  zprev = (float *)malloc(sizeof(float)*hres*vres);
139                  oprev = (OBJECT *)malloc(sizeof(OBJECT)*hres*vres);
140 <                aprev = (BYTE *)malloc(sizeof(BYTE)*hres*vres);
140 >                aprev = (uby8 *)malloc(sizeof(uby8)*hres*vres);
141                  if ((cbuffer==NULL) | (zbuffer==NULL) | (obuffer==NULL) |
142                                  (xmbuffer==NULL) | (ymbuffer==NULL) |
143                                  (abuffer==NULL) | (sbuffer==NULL) |
144                                  (cprev==NULL) | (zprev == NULL) |
145                                  (oprev==NULL) | (aprev==NULL))
146                          error(SYSTEM, "out of memory in init_frame");
147 +                for (n = hres*vres; n--; ) {
148 +                        zprev[n] = -1.f;
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 <                memset(abuffer, '\0', sizeof(BYTE)*hres*vres);
162 <                memset(sbuffer, '\0', 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 167 | Line 173 | next_frame(void)                       /* prepare next frame buffer */
173  
174   static int
175   sample_here(            /* 4x4 quincunx sample at this pixel? */
176 <        register int    x,
177 <        register int    y
176 >        int     x,
177 >        int     y
178   )
179   {
180          if (y & 0x1)            /* every other row has samples */
# Line 179 | Line 185 | sample_here(           /* 4x4 quincunx sample at this pixel? */
185   }
186  
187  
188 < extern void
188 > void
189   sample_pos(     /* compute jittered sample position */
190          double  hv[2],
191          int     x,
# Line 196 | Line 202 | sample_pos(    /* compute jittered sample position */
202   }
203  
204  
205 < extern double
205 > double
206   sample_wt(              /* compute interpolant sample weight */
207          int     xo,
208          int yo
# Line 230 | Line 236 | offset_cmp(            /* compare offset distances */
236   }
237  
238  
239 < extern int
239 > int
240   getclosest(     /* get nc closest neighbors on same object */
241          int     *iarr,
242          int     nc,
# Line 243 | Line 249 | getclosest(    /* get nc closest neighbors on same object
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 */
# Line 307 | Line 313 | getclosest(    /* get nc closest neighbors on same object
313  
314   static void
315   setmotion(              /* compute motion vector for this pixel */
316 <                register int    n,
316 >                int     n,
317                  FVECT   wpos
318   )
319   {
# Line 324 | Line 330 | setmotion(             /* compute motion vector for this pixel */
330                  multp3(ovp, wpos, obj_move[moi].bxfm);
331                  wpos = ovp;
332          }
333 <        viewloc(ovp, &vwprev, wpos);
328 <        if (ovp[2] <= FTINY)
333 >        if (viewloc(ovp, &vwprev, wpos) != VL_GOOD)
334                  return;
335          xp = (int)(ovp[0]*hres);
336          yp = (int)(ovp[1]*vres);
# Line 346 | Line 351 | init_frame_sample(void)                /* sample our initial frame *
351   {
352          RAY     ir;
353          int     x, y;
354 <        register int    n;
354 >        int     n;
355  
356          if (!silent) {
357                  printf("\tComputing initial samples...");
# Line 357 | Line 362 | init_frame_sample(void)                /* sample our initial frame *
362              for (x = hres; x--; ) {
363                  double  hv[2];
364                  n = fndx(x, y);
365 <                xmbuffer[n] = MO_UNK;
361 <                ymbuffer[n] = MO_UNK;
365 >                xmbuffer[n] = ymbuffer[n] = MO_UNK;
366                  sample_pos(hv, x, y, 0);
367                  ir.rmax = viewray(ir.rorg, ir.rdir, &vw, hv[0], hv[1]);
368                  if (ir.rmax < -FTINY) {
# Line 371 | Line 375 | init_frame_sample(void)                /* sample our initial frame *
375                  if (!sample_here(x, y)) {       /* just cast */
376                          rayorigin(&ir, PRIMARY, NULL, NULL);
377                          if (!localhit(&ir, &thescene)) {
378 <                                if (ir.ro != &Aftplane)
379 <                                        sourcehit(&ir);
380 <                                copycolor(cbuffer[n], ir.rcol);
378 >                                if (ir.ro != &Aftplane && sourcehit(&ir)) {
379 >                                        rayshade(&ir, ir.ro->omod);
380 >                                        rayparticipate(&ir);
381 >                                }
382 >                                scolor_rgb(cbuffer[n], ir.rcol);
383                                  zbuffer[n] = ir.rot;
384                                  obuffer[n] = ir.robj;
385                                  abuffer[n] = ADISTANT;
# Line 397 | Line 403 | init_frame_sample(void)                /* sample our initial frame *
403                          n = ir.rno;
404                  } else
405                          ray_trace(&ir);
406 <                copycolor(cbuffer[n], ir.rcol);
406 >                scolor_rgb(cbuffer[n], ir.rcol);
407                  zbuffer[n] = ir.rot;
408                  obuffer[n] = ir.robj;
409                  sbuffer[n] = 1;
410 <                if (ir.rot >= FHUGE)
410 >                if (ir.rot >= 0.99*FHUGE)
411                          abuffer[n] = ADISTANT;
412                  else {
413                          abuffer[n] = ALOWQ;
# Line 411 | Line 417 | init_frame_sample(void)                /* sample our initial frame *
417          if (nprocs > 1)                 /* get stragglers */
418                  while (ray_presult(&ir, 0)) {
419                          n = ir.rno;
420 <                        copycolor(cbuffer[n], ir.rcol);
420 >                        scolor_rgb(cbuffer[n], ir.rcol);
421                          zbuffer[n] = ir.rot;
422                          obuffer[n] = ir.robj;
423                          sbuffer[n] = 1;
424 <                        if (ir.rot >= FHUGE)
424 >                        if (ir.rot >= 0.99*FHUGE)
425                                  abuffer[n] = ADISTANT;
426                          else {
427                                  abuffer[n] = ALOWQ;
# Line 444 | Line 450 | init_frame_sample(void)                /* sample our initial frame *
450   }
451  
452  
453 < extern int
453 > int
454   getambcolor(            /* get ambient color for object if we can */
455                  COLOR   clr,
456                  int     obj
457   )
458   {
459 <        register OBJREC *op;
459 >        OBJREC  *op;
460  
461          if (obj == OVOID)
462                  return(0);
463 <        op = objptr(obj);
464 <        if ((op->otype == OBJ_INSTANCE) & (op->omod == OVOID))
463 >        op = objptr(obj);               /* search for material */
464 >        if (op->omod == OVOID)
465                  return(0);
466 <                                        /* search for material */
467 <        do {
468 <                if (op->omod == OVOID || ofun[op->otype].flags & T_X)
463 <                        return(0);
464 <                op = objptr(op->omod);
465 <        } while (!ismaterial(op->otype));
466 >        op = findmaterial(objptr(op->omod));
467 >        if (op == NULL)
468 >                return(0);
469          /*
470           * Since this routine is called to compute the difference
471           * from rendering with and without interreflections,
# Line 476 | Line 479 | getambcolor(           /* get ambient color for object if we ca
479                          if (lv[0] == op->oname[0] &&
480                                          !strcmp(lv+1, op->oname+1))
481                                  break;
482 <                if ((lv != NULL) != hirendparams.ambincl)
482 >                if ((lv != NULL) ^ hirendparams.ambincl)
483                          return(0);
484          }
485          switch (op->otype) {
# Line 515 | Line 518 | getambcolor(           /* get ambient color for object if we ca
518   }
519  
520  
521 < extern double
521 > double
522   estimaterr(             /* estimate relative error from samples */
523                  COLOR   cs,
524                  COLOR   cs2,
# Line 541 | Line 544 | estimaterr(            /* estimate relative error from samples *
544   }
545  
546  
547 < extern double
547 > double
548   comperr(                /* estimate relative error in neighborhood */
549                  int     *neigh,
550                  int     nc,
# Line 552 | Line 555 | comperr(               /* estimate relative error in neighborhood *
555          COLOR   ctmp;
556          int     i;
557          int     ns;
558 <        register int    n;
558 >        int     n;
559                                          /* add together samples */
560          setcolor(csum, 0., 0., 0.);
561          setcolor(csum2, 0., 0., 0.);
# Line 577 | Line 580 | comperr(               /* estimate relative error in neighborhood *
580   }
581  
582  
583 < extern void
583 > void
584   comp_frame_error(void)          /* initialize frame error values */
585   {
586 <        BYTE    *edone = NULL;
586 >        uby8    *edone = NULL;
587          COLOR   objamb;
588          double  eest;
589          int     neigh[NSAMPOK];
590          int     nc;
591          int     x, y, i;
592 <        register int    n;
592 >        int     n;
593  
594          if (!silent) {
595                  printf("\tComputing error map\n");
# Line 604 | Line 607 | comp_frame_error(void)         /* initialize frame error valu
607                   * error should be less than the ambient value divided
608                   * by the returned ray value -- we take half of this.
609                   */
610 <                edone = (BYTE *)calloc(hres*vres, sizeof(BYTE));
611 <                for (y = vres; y--; )
609 <                    for (x = hres; x--; ) {
610 <                        n = fndx(x, y);
610 >                edone = (uby8 *)calloc(hres*vres, sizeof(uby8));
611 >                for (n = hres*vres; n--; ) {
612                          if ((abuffer[n] != ALOWQ) | (obuffer[n] == OVOID))
613                                  continue;
614                          if (!getambcolor(objamb, obuffer[n]))
# Line 624 | Line 625 | comp_frame_error(void)         /* initialize frame error valu
625                          else if (i >= ADISTANT/2) i = ADISTANT/2-1;
626                          abuffer[n] = i;
627                          edone[n] = 1;
628 <                    }
628 >                }
629          }
630                                          /* final statistical estimate */
631          for (y = vres; y--; )
# Line 656 | Line 657 | comp_frame_error(void)         /* initialize frame error valu
657   }
658  
659  
660 < extern void
660 > void
661   init_frame(void)                        /* render base (low quality) frame */
662   {
663          int     restart;
# Line 701 | Line 702 | init_frame(void)                       /* render base (low quality) frame
702   {
703          float   *ebuf = (float *)malloc(sizeof(float)*hres*vres);
704          char    fnm[256];
705 <        register int    n;
705 >        int     n;
706          for (n = hres*vres; n--; )
707                  ebuf[n] = acctab[abuffer[n]];
708          sprintf(fnm, vval(BASENAME), fcur);
# Line 713 | Line 714 | init_frame(void)                       /* render base (low quality) frame
714   }
715  
716  
717 < extern void
717 > void
718   filter_frame(void)                      /* interpolation, motion-blur, and exposure */
719   {
720 <        double  expval = expspec_val(getexp(fcur));
721 <        int     x, y;
722 <        int     neigh[NPINTERP];
723 <        int     nc;
724 <        COLOR   cval;
725 <        double  w, wsum;
726 <        register int    n;
720 >        const double    expval = expspec_val(getexp(fcur));
721 >        int             x, y;
722 >        int             neigh[NPINTERP];
723 >        int             nc;
724 >        COLOR           cval;
725 >        double          w, wsum;
726 >        int             n;
727  
728   #if 0
729          /* XXX TEMPORARY!! */
# Line 736 | Line 737 | filter_frame(void)                     /* interpolation, motion-blur, an
737                  free((void *)ebuf);
738          }
739   #endif
739 –
740          if (!silent) {
741                  printf("\tFiltering frame\n");
742                  fflush(stdout);
743          }
744                                          /* normalize samples */
745 <        for (y = vres; y--; )
746 <            for (x = hres; x--; ) {
747 <                n = fndx(x, y);
745 >        for (n = hres*vres; n--; ) {
746                  if (sbuffer[n] <= 1)
747                          continue;
748                  w = 1.0/(double)sbuffer[n];
749                  scalecolor(cbuffer[n], w);
750 <            }
750 >        }
751                                          /* interpolate samples */
752          for (y = vres; y--; )
753              for (x = hres; x--; ) {
# Line 856 | Line 854 | filter_frame(void)                     /* interpolation, motion-blur, an
854                          }
855                      }
856                                          /* compute final results */
857 <                for (y = vres; y--; )
860 <                    for (x = hres; x--; ) {
861 <                        n = fndx(x, y);
857 >                for (n = hres*vres; n--; ) {
858                          if (wbuffer[n] <= FTINY)
859                                  continue;
860 <                        w = 1./wbuffer[n];
860 >                        w = expval/wbuffer[n];
861                          scalecolor(outbuffer[n], w);
862 <                    }
863 <        } else
864 <                for (n = hres*vres; n--; )
865 <                        copycolor(outbuffer[n], cbuffer[n]);
862 >                }
863 >        } else {                        /* no blur -- just exposure */
864 >                memcpy(outbuffer, cbuffer, sizeof(COLOR)*hres*vres);
865 >                for (n = ((expval < 0.99) | (expval > 1.01))*hres*vres; n--; )
866 >                        scalecolor(outbuffer[n], expval);
867 >        }
868          /*
869             for (n = hres*vres; n--; )
870                     if (!sbuffer[n])
871                             setcolor(outbuffer[n], 0., 0., 0.);
872           */
875 –        /* adjust exposure */
876 –        if ((expval < 0.99) | (expval > 1.01))
877 –                for (n = hres*vres; n--; )
878 –                        scalecolor(outbuffer[n], expval);
873   #if 0
874          {
875                  float   *sbuf = (float *)malloc(sizeof(float)*hres*vres);
# Line 891 | Line 885 | filter_frame(void)                     /* interpolation, motion-blur, an
885   }
886  
887  
888 < extern void
888 > void
889   send_frame(void)                        /* send frame to destination */
890   {
891 <        char    pfname[1024];
891 >        char    fname[1024];
892          double  d;
893          FILE    *fp;
894          int     y;
895                                          /* open output picture */
896 <        sprintf(pfname, vval(BASENAME), fcur);
897 <        strcat(pfname, ".hdr");
898 <        fp = fopen(pfname, "w");
896 >        sprintf(fname, vval(BASENAME), fcur);
897 >        strcat(fname, ".hdr");
898 >        fp = fopen(fname, "w");
899          if (fp == NULL) {
900 <                sprintf(errmsg, "cannot open output frame \"%s\"", pfname);
900 >                sprintf(errmsg, "cannot open output frame \"%s\"", fname);
901                  error(SYSTEM, errmsg);
902          }
903          SET_FILE_BINARY(fp);
904          if (!silent) {
905 <                printf("\tWriting to \"%s\"\n", pfname);
905 >                printf("\tWriting to \"%s\"\n", fname);
906                  fflush(stdout);
907          }
908                                          /* write header */
# Line 922 | Line 916 | send_frame(void)                       /* send frame to destination */
916          if ((d < 0.99) | (d > 1.01))
917                  fputexpos(d, fp);
918          d = viewaspect(&vw) * hres / vres;
919 <        if ((d < 0.99) | (d > 1.01))
919 >        if ((d < 0.999) | (d > 1.001))
920                  fputaspect(d, fp);
921          fputformat(COLRFMT, fp);
922          fputc('\n', fp);                /* end header */
# Line 937 | Line 931 | send_frame(void)                       /* send frame to destination */
931                          goto writerr;
932          if (fclose(fp) == EOF)
933                  goto writerr;
934 +        if (vdef(ZNAME)) {              /* output z-buffer */
935 +                sprintf(fname, vval(ZNAME), fcur);
936 +                strcat(fname, ".zbf");
937 +                fp = fopen(fname, "w");
938 +                if (fp == NULL) {
939 +                        sprintf(errmsg, "cannot open z-file \"%s\"\n", fname);
940 +                        error(SYSTEM, errmsg);
941 +                }
942 +                SET_FILE_BINARY(fp);
943 +                if (!silent) {
944 +                        printf("\tWriting depths to \"%s\"\n", fname);
945 +                        fflush(stdout);
946 +                }
947 +                for (y = vres; y--; )
948 +                        if (fwrite(zbuffer+y*hres, sizeof(float),
949 +                                                hres, fp) != hres)
950 +                                goto writerr;
951 +                if (fclose(fp) == EOF)
952 +                        goto writerr;
953 +        }
954 +        if (vdef(MNAME)) {              /* output motion buffer */
955 +                unsigned short  *mbuffer = (unsigned short *)malloc(
956 +                                                sizeof(unsigned short)*3*hres);
957 +                int             x, n;
958 +                if (mbuffer == NULL)
959 +                        error(SYSTEM, "out of memory in send_frame");
960 +                sprintf(fname, vval(MNAME), fcur);
961 +                strcat(fname, ".mvo");
962 +                fp = fopen(fname, "w");
963 +                if (fp == NULL) {
964 +                        sprintf(errmsg, "cannot open motion file \"%s\"\n",
965 +                                                        fname);
966 +                        error(SYSTEM, errmsg);
967 +                }
968 +                SET_FILE_BINARY(fp);
969 +                if (!silent) {
970 +                        printf("\tWriting motion vectors to \"%s\"\n", fname);
971 +                        fflush(stdout);
972 +                }
973 +                for (y = vres; y--; ) {
974 +                        for (x = hres; x--; ) {
975 +                                n = fndx(x,y);
976 +                                mbuffer[3*x] = xmbuffer[n] + 0x8000;
977 +                                mbuffer[3*x+1] = ymbuffer[n] + 0x8000;
978 +                                mbuffer[3*x+2] = (oprev[n]!=OVOID)*0x8000;
979 +                        }
980 +                        if (fwrite(mbuffer, sizeof(*mbuffer),
981 +                                                3*hres, fp) != 3*hres)
982 +                                goto writerr;
983 +                }
984 +                free((void *)mbuffer);
985 +                if (fclose(fp) == EOF)
986 +                        goto writerr;
987 +        }
988          return;                         /* all is well */
989   writerr:
990 <        sprintf(errmsg, "error writing frame \"%s\"", pfname);
990 >        sprintf(errmsg, "error writing file \"%s\"", fname);
991          error(SYSTEM, errmsg);
992   }
993  
994  
995 < extern void
995 > void
996   free_frame(void)                        /* free frame allocation */
997   {
998          if (cbuffer == NULL)

Diff Legend

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