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.14 by schorsch, Sun Jul 27 22:12:02 2003 UTC vs.
Revision 3.15 by schorsch, Thu Jan 1 11:21:55 2004 UTC

# Line 52 | 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 < void
59 < pixBeam(bp, hb)                 /* render a particular beam */
60 < BEAM    *bp;
61 < 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 111 | Line 126 | register HDBEAMI       *hb;
126   }
127  
128  
129 < int
130 < kill_occl(h, v, nl, nd, n)              /* check for occlusion errors */
131 < int     h, v;
132 < register short  nl[NNEIGH][2];
133 < int     nd[NNEIGH];
134 < int     n;
129 > static int
130 > kill_occl(              /* check for occlusion errors */
131 >        int     h,
132 >        int     v,
133 >        register short  nl[NNEIGH][2],
134 >        int     nd[NNEIGH],
135 >        int     n,
136 >        double *rf
137 > )
138   {
139          short   forequad[2][2];
140          int     d;
# Line 144 | Line 162 | int    n;
162   }
163  
164  
165 < int
166 < smooth_samp(h, v, nl, nd, n)    /* grow sample point smoothly */
167 < int     h, v;
168 < register short  nl[NNEIGH][2];
169 < int     nd[NNEIGH];
170 < int     n;
165 > static int
166 > smooth_samp(    /* grow sample point smoothly */
167 >        int     h,
168 >        int     v,
169 >        register short  nl[NNEIGH][2],
170 >        int     nd[NNEIGH],
171 >        int     n,
172 >        double *rf
173 > )
174   {
175          int     dis[NNEIGH], ndis;
176          COLOR   mykern[MAXRAD2];
# Line 206 | Line 227 | int    n;
227   }
228  
229  
230 < int
231 < random_samp(h, v, nl, nd, n, rf)        /* gather samples randomly */
232 < int     h, v;
233 < register short  nl[NNEIGH][2];
234 < int     nd[NNEIGH];
235 < int     n;
236 < double  *rf;
230 > static int
231 > random_samp(    /* gather samples randomly */
232 >        int     h,
233 >        int     v,
234 >        register short  nl[NNEIGH][2],
235 >        int     nd[NNEIGH],
236 >        int     n,
237 >        double  *rf
238 > )
239   {
240          float   rnt[NNEIGH];
241          double  rvar;
# Line 240 | Line 263 | double *rf;
263   }
264  
265  
266 < pixFinish(ransamp)              /* done with beams -- compute pixel values */
267 < double  ransamp;
266 > extern void
267 > pixFinish(              /* done with beams -- compute pixel values */
268 >        double  ransamp
269 > )
270   {
271          if (pixWeight[0] <= FTINY)
272                  init_wfunc();           /* initialize weighting function */
# Line 257 | Line 282 | double ransamp;
282   }
283  
284  
285 < reset_flags()                   /* allocate/set/reset occupancy flags */
285 > static void
286 > reset_flags(void)                       /* allocate/set/reset occupancy flags */
287   {
288          register int32  p;
289  
# Line 272 | Line 298 | reset_flags()                  /* allocate/set/reset occupancy flags
298   }
299  
300  
301 < init_wfunc()                    /* initialize weighting function */
301 > static void
302 > init_wfunc(void)                        /* initialize weighting function */
303   {
304          register int    r2;
305          register double d;
# Line 287 | Line 314 | init_wfunc()                   /* initialize weighting function */
314   }
315  
316  
317 < int
318 < findneigh(nl, nd, h, v, rnl)    /* find NNEIGH neighbors for pixel */
319 < short   nl[NNEIGH][2];
320 < int     nd[NNEIGH];
321 < int     h, v;
322 < register short  (*rnl)[NNEIGH];
317 > static int
318 > findneigh(      /* find NNEIGH neighbors for pixel */
319 >        short   nl[NNEIGH][2],
320 >        int     nd[NNEIGH],
321 >        int     h,
322 >        int     v,
323 >        register short  (*rnl)[NNEIGH]
324 > )
325   {
326          int     nn = 0;
327          int     d, n, hoff;
# Line 328 | Line 357 | register short (*rnl)[NNEIGH];
357   }
358  
359  
360 < meet_neighbors(occ, nf, dp)     /* run through samples and their neighbors */
361 < int     occ;
362 < int     (*nf)();
363 < char    *dp;
360 > static void
361 > meet_neighbors( /* run through samples and their neighbors */
362 >        int     occ,
363 >        sampfunc *nf,
364 >        double  *dp
365 > )
366   {
367          short   ln[NNEIGH][2];
368          int     nd[NNEIGH];

Diff Legend

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