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

Comparing ray/src/hd/rhpict2.c (file contents):
Revision 3.6 by gwlarson, Tue Mar 9 14:23:51 1999 UTC vs.
Revision 3.16 by greg, Wed Jan 24 04:39:52 2018 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1999 Silicon Graphics, Inc. */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ SGI";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   * Rendering routines for rhpict.
6   */
7  
8 + #include <string.h>
9 +
10   #include "holo.h"
11   #include "view.h"
12   #include "random.h"
# Line 22 | Line 21 | static char SCCSid[] = "$SunId$ SGI";
21   #define MAXRAD          64      /* maximum kernel radius */
22   #endif
23   #ifndef NNEIGH
24 < #define NNEIGH          7       /* find this many neighbors */
24 > #define NNEIGH          5       /* find this many neighbors */
25   #endif
26  
27   #define NINF            16382
# Line 38 | Line 37 | static char SCCSid[] = "$SunId$ SGI";
37   #define CLR4(f,i)       FL4OP(f,i,&=~)
38   #define TGL4(f,i)       FL4OP(f,i,^=)
39   #define FL4NELS(n)      (((n)+0x1f)>>5)
40 < #define CLR4ALL(f,n)    bzero((char *)(f),FL4NELS(n)*sizeof(int4))
40 > #define CLR4ALL(f,n)    memset((char *)(f),'\0',FL4NELS(n)*sizeof(int32))
41   #endif
42  
43 < static int4     *pixFlags;      /* pixel occupancy flags */
43 > static int32    *pixFlags;      /* pixel occupancy flags */
44   static float    pixWeight[MAXRAD2];     /* pixel weighting function */
45   static short    isqrttab[MAXRAD2];      /* integer square root table */
46  
47 < #define isqrt(i2)       ((int)isqrttab[(int)(i2)])
47 > #define isqrt(i2)       (isqrttab[i2])
48  
49   extern VIEW     myview;         /* current output view */
50   extern COLOR    *mypixel;       /* pixels being rendered */
# Line 53 | Line 52 | extern float   *myweight;      /* weights (used to compute fi
52   extern float    *mydepth;       /* depth values (visibility culling) */
53   extern int      hres, vres;     /* current horizontal and vertical res. */
54  
55 + extern void pixFinish(double ransamp);
56 + extern void pixBeam(BEAM *bp, HDBEAMI *hb);
57  
58 < pixBeam(bp, hb)                 /* render a particular beam */
59 < BEAM    *bp;
60 < register HDBEAMI        *hb;
58 > typedef int (sampfunc)(int h, int v, short nl[NNEIGH][2], int nd[NNEIGH],
59 >                int n, double *rf);
60 > static sampfunc kill_occl;
61 > static sampfunc smooth_samp;
62 > static sampfunc random_samp;
63 > static void meet_neighbors(int occ, sampfunc *nf, double *dp);
64 > static void reset_flags(void);
65 > static void init_wfunc(void);
66 > static int findneigh(short nl[NNEIGH][2], int nd[NNEIGH], int h, int v,
67 >                register short (*rnl)[NNEIGH]);
68 >
69 >
70 > extern void
71 > pixBeam(                        /* render a particular beam */
72 >        BEAM    *bp,
73 >        register HDBEAMI        *hb
74 > )
75   {
76          GCOORD  gc[2];
77          register RAYVAL *rv;
# Line 64 | Line 79 | register HDBEAMI       *hb;
79          double  d, prox;
80          COLOR   col;
81          int     n;
82 <        register int4   p;
82 >        register int32  p;
83  
84          if (!hdbcoord(gc, hb->h, hb->b))
85                  error(CONSISTENCY, "bad beam in render_beam");
# Line 84 | Line 99 | register HDBEAMI       *hb;
99                          VSUM(wp, myview.vp, rdir, FHUGE);
100                          prox = 1.;
101                  }
102 <                viewloc(ip, &myview, wp);       /* frustum clipping */
103 <                if (ip[2] < 0.)
89 <                        continue;
90 <                if (ip[0] < 0. || ip[0] >= 1.)
91 <                        continue;
92 <                if (ip[1] < 0. || ip[1] >= 1.)
93 <                        continue;
102 >                if (viewloc(ip, &myview, wp) != 1)
103 >                        continue;               /* frustum clipping */
104                  if (myview.vaft > FTINY && ip[2] > myview.vaft - myview.vfore)
105                          continue;               /* not exact for VT_PER */
106                  p = (int)(ip[1]*vres)*hres + (int)(ip[0]*hres);
# Line 111 | Line 121 | register HDBEAMI       *hb;
121   }
122  
123  
124 < int
125 < kill_occl(h, v, nl, n)          /* check for occlusion errors */
126 < int     h, v;
127 < register short  nl[NNEIGH][2];
128 < int     n;
124 > static int
125 > kill_occl(              /* check for occlusion errors */
126 >        int     h,
127 >        int     v,
128 >        register short  nl[NNEIGH][2],
129 >        int     nd[NNEIGH],
130 >        int     n,
131 >        double *rf
132 > )
133   {
134          short   forequad[2][2];
135          int     d;
136 <        register int4   i, p;
136 >        register int    i;
137 >        register int32  p;
138  
139          if (n <= 0) {
140   #ifdef DEBUG
# Line 130 | Line 145 | int    n;
145          p = v*hres + h;
146          forequad[0][0] = forequad[0][1] = forequad[1][0] = forequad[1][1] = 0;
147          for (i = n; i--; ) {
148 <                d = (h-nl[i][0])*(h-nl[i][0]) + (v-nl[i][1])*(v-nl[i][1]);
134 <                d = isqrt(d);
148 >                d = isqrt(nd[i]);
149                  if (mydepth[nl[i][1]*hres+nl[i][0]]*(1.+DEPS*d) < mydepth[p])
150                          forequad[nl[i][0]<h][nl[i][1]<v] = 1;
151          }
# Line 143 | Line 157 | int    n;
157   }
158  
159  
160 < int
161 < smooth_samp(h, v, nl, n)        /* grow sample point smoothly */
162 < int     h, v;
163 < register short  nl[NNEIGH][2];
164 < int     n;
160 > static int
161 > smooth_samp(    /* grow sample point smoothly */
162 >        int     h,
163 >        int     v,
164 >        register short  nl[NNEIGH][2],
165 >        int     nd[NNEIGH],
166 >        int     n,
167 >        double *rf
168 > )
169   {
170          int     dis[NNEIGH], ndis;
171          COLOR   mykern[MAXRAD2];
172 <        int4    maxr2;
172 >        int     maxr2;
173          double  d;
174 <        register int4   p, r2;
174 >        register int32  p;
175 >        register int    r2;
176          int     i, r, maxr, h2, v2;
177  
178          if (n <= 0)
179                  return(1);
180          p = v*hres + h;                         /* build kernel values */
181 <        maxr2 = (h-nl[n-1][0])*(h-nl[n-1][0]) + (v-nl[n-1][1])*(v-nl[n-1][1]);
181 >        maxr2 = nd[n-1];
182          DCHECK(maxr2>=MAXRAD2, CONSISTENCY, "out of range neighbor");
183          maxr = isqrt(maxr2);
184          for (v2 = 1; v2 <= maxr; v2++)
# Line 171 | Line 190 | int    n;
190                  }
191          ndis = 0;                               /* find discontinuities */
192          for (i = n; i--; ) {
193 <                r2 = (h-nl[i][0])*(h-nl[i][0]) + (v-nl[i][1])*(v-nl[i][1]);
175 <                r = isqrt(r2);
193 >                r = isqrt(nd[i]);
194                  d = mydepth[nl[i][1]*hres+nl[i][0]] / mydepth[p];
195                  d = d>=1. ? d-1. : 1.-d;
196                  if (d > r*DEPS || bigdiff(mypixel[p],
# Line 204 | Line 222 | int    n;
222   }
223  
224  
225 < int
226 < random_samp(h, v, nl, n)        /* grow sample point noisily */
227 < int     h, v;
228 < register short  nl[NNEIGH][2];
229 < int     n;
225 > static int
226 > random_samp(    /* gather samples randomly */
227 >        int     h,
228 >        int     v,
229 >        register short  nl[NNEIGH][2],
230 >        int     nd[NNEIGH],
231 >        int     n,
232 >        double  *rf
233 > )
234   {
235 <        float   nwt[NNEIGH];
236 <        int4    maxr2;
237 <        register int4   p, r2;
238 <        register int    i;
217 <        int     maxr, h2, v2;
218 <        COLOR   ctmp;
235 >        float   rnt[NNEIGH];
236 >        double  rvar;
237 >        register int32  p, pn;
238 >        register int    ni;
239  
240          if (n <= 0)
241                  return(1);
242 <        p = v*hres + h;                         /* compute kernel radius */
243 <        maxr2 = (h-nl[n-1][0])*(h-nl[n-1][0]) + (v-nl[n-1][1])*(v-nl[n-1][1]);
244 <        DCHECK(maxr2>=MAXRAD2, CONSISTENCY, "out of range neighbor");
245 <        maxr = isqrt(maxr2);
246 <                                                /* compute neighbor weights */
247 <        for (i = n; i--; ) {
248 <                r2 = (nl[i][0]-h)*(nl[i][0]-h) + (nl[i][1]-v)*(nl[i][1]-v);
249 <                nwt[i] = pixWeight[r2];
242 >        p = v*hres + h;
243 >        if (*rf <= FTINY)               /* straight Voronoi regions */
244 >                ni = 0;
245 >        else {                          /* weighted choice */
246 >                DCHECK(nd[n-1]>=MAXRAD2, CONSISTENCY, "out of range neighbor");
247 >                rnt[0] = pixWeight[nd[0]];
248 >                for (ni = 1; ni < n; ni++)
249 >                        rnt[ni] = rnt[ni-1] + pixWeight[nd[ni]];
250 >                rvar = rnt[n-1]*pow(frandom(), 1. / *rf);
251 >                for (ni = 0; rvar > rnt[ni]+FTINY; ni++)
252 >                        ;
253          }
254 <                                                /* sample kernel */
255 <        for (v2 = v-maxr; v2 <= v+maxr; v2++) {
256 <                if (v2 < 0) v2 = 0;
234 <                else if (v2 >= vres) break;
235 <                for (h2 = h-maxr; h2 <= h+maxr; h2++) {
236 <                        if (h2 < 0) h2 = 0;
237 <                        else if (h2 >= hres) break;
238 <                        r2 = (h2-h)*(h2-h) + (v2-v)*(v2-v);
239 <                        if (r2 > maxr2) continue;
240 <                        if (CHK4(pixFlags, v2*hres+h2))
241 <                                continue;       /* occupied */
242 <                        if (frandom() > pixWeight[r2]) {
243 <                                                /* pick neighbor instead */
244 <                                i = random() % n;
245 <                                r2 = nl[i][1]*hres + nl[i][0];
246 <                                copycolor(ctmp, mypixel[r2]);
247 <                                scalecolor(ctmp, nwt[i]);
248 <                                addcolor(mypixel[v2*hres+h2], ctmp);
249 <                                myweight[v2*hres+h2] += nwt[i] * myweight[r2];
250 <                                continue;
251 <                        }
252 <                        addcolor(mypixel[v2*hres+h2], mypixel[p]);
253 <                        myweight[v2*hres+h2] += myweight[p];
254 <                }
255 <        }
254 >        pn = nl[ni][1]*hres + nl[ni][0];
255 >        addcolor(mypixel[p], mypixel[pn]);
256 >        myweight[p] += myweight[pn];
257          return(1);
258   }
259  
260  
261 < pixFinish(ransamp)              /* done with beams -- compute pixel values */
262 < int     ransamp;
261 > extern void
262 > pixFinish(              /* done with beams -- compute pixel values */
263 >        double  ransamp
264 > )
265   {
266          if (pixWeight[0] <= FTINY)
267                  init_wfunc();           /* initialize weighting function */
268          reset_flags();                  /* set occupancy flags */
269 <        meet_neighbors(kill_occl);      /* eliminate occlusion errors */
269 >        meet_neighbors(1,kill_occl,NULL); /* identify occlusion errors */
270          reset_flags();                  /* reset occupancy flags */
271 <        if (ransamp)                    /* spread samples over image */
272 <                meet_neighbors(random_samp);
271 >        if (ransamp >= 0.)              /* spread samples over image */
272 >                meet_neighbors(0,random_samp,&ransamp);
273          else
274 <                meet_neighbors(smooth_samp);
275 <        free((char *)pixFlags);         /* free pixel flags */
274 >                meet_neighbors(1,smooth_samp,NULL);
275 >        free((void *)pixFlags);         /* free pixel flags */
276          pixFlags = NULL;
277   }
278  
279  
280 < reset_flags()                   /* allocate/set/reset occupancy flags */
280 > static void
281 > reset_flags(void)                       /* allocate/set/reset occupancy flags */
282   {
283 <        register int4   p;
283 >        register int32  p;
284  
285          if (pixFlags == NULL) {
286 <                pixFlags = (int4 *)calloc(FL4NELS(hres*vres), sizeof(int4));
286 >                pixFlags = (int32 *)calloc(FL4NELS(hres*vres), sizeof(int32));
287                  CHECK(pixFlags==NULL, SYSTEM, "out of memory in reset_flags");
288          } else
289                  CLR4ALL(pixFlags, hres*vres);
# Line 289 | Line 293 | reset_flags()                  /* allocate/set/reset occupancy flags
293   }
294  
295  
296 < init_wfunc()                    /* initialize weighting function */
296 > static void
297 > init_wfunc(void)                        /* initialize weighting function */
298   {
299 <        register int4   r2;
299 >        register int    r2;
300          register double d;
301  
302          for (r2 = MAXRAD2; --r2; ) {
# Line 304 | Line 309 | init_wfunc()                   /* initialize weighting function */
309   }
310  
311  
312 < int
313 < findneigh(nl, h, v, rnl)        /* find NNEIGH neighbors for pixel */
314 < short   nl[NNEIGH][2];
315 < int     h, v;
316 < register short  (*rnl)[NNEIGH];
312 > static int
313 > findneigh(      /* find NNEIGH neighbors for pixel */
314 >        short   nl[NNEIGH][2],
315 >        int     nd[NNEIGH],
316 >        int     h,
317 >        int     v,
318 >        register short  (*rnl)[NNEIGH]
319 > )
320   {
321          int     nn = 0;
322 <        int4    d, nd[NNEIGH];
315 <        int     n, hoff;
322 >        int     d, n, hoff;
323          register int    h2, n2;
324  
325          nd[NNEIGH-1] = MAXRAD2;
326 <        for (hoff = 1; hoff < hres; hoff = (hoff<0) - hoff) {
326 >        for (hoff = 0; hoff < hres; hoff = (hoff<=0) - hoff) {
327                  h2 = h + hoff;
328 <                if (h2 < 0 | h2 >= hres)
328 >                if ((h2 < 0) | (h2 >= hres))
329                          continue;
330                  if ((h2-h)*(h2-h) >= nd[NNEIGH-1])
331                          break;
332                  for (n = 0; n < NNEIGH && rnl[h2][n] < NINF; n++) {
333                          d = (h2-h)*(h2-h) + (v-rnl[h2][n])*(v-rnl[h2][n]);
334 <                        if (d >= nd[NNEIGH-1])
334 >                        if ((d == 0) | (d >= nd[NNEIGH-1]))
335                                  continue;
336                          if (nn < NNEIGH)        /* insert neighbor */
337                                  nn++;
# Line 345 | Line 352 | register short (*rnl)[NNEIGH];
352   }
353  
354  
355 < meet_neighbors(nf)              /* run through samples and their neighbors */
356 < int     (*nf)();
355 > static void
356 > meet_neighbors( /* run through samples and their neighbors */
357 >        int     occ,
358 >        sampfunc *nf,
359 >        double  *dp
360 > )
361   {
362          short   ln[NNEIGH][2];
363 +        int     nd[NNEIGH];
364          int     h, v, n, v2;
365          register short  (*rnl)[NNEIGH];
366                                          /* initialize bottom row list */
# Line 367 | Line 379 | int    (*nf)();
379          v = 0;                          /* do each row */
380          for ( ; ; ) {
381                  for (h = 0; h < hres; h++) {
382 <                        if (!CHK4(pixFlags, v*hres+h))
383 <                                continue;       /* no one home */
384 <                        n = findneigh(ln, h, v, rnl);
385 <                        (*nf)(h, v, ln, n);     /* call on neighbors */
382 >                        if (!CHK4(pixFlags, v*hres+h) != !occ)
383 >                                continue;       /* occupancy mismatch */
384 >                                                /* find neighbors */
385 >                        n = findneigh(ln, nd, h, v, rnl);
386 >                                                /* call on neighbors */
387 >                        (*nf)(h, v, ln, nd, n, dp);
388                  }
389                  if (++v >= vres)                /* reinitialize row list */
390                          break;
# Line 385 | Line 399 | int    (*nf)();
399                                  }
400                          }
401          }
402 <        free((char *)rnl);              /* free row list */
402 >        free((void *)rnl);              /* free row list */
403   }

Diff Legend

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