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

Comparing ray/src/px/pinterp.c (file contents):
Revision 1.5 by greg, Fri Dec 22 10:08:33 1989 UTC vs.
Revision 1.9 by greg, Wed Jan 3 12:52:30 1990 UTC

# Line 21 | Line 21 | static char SCCSid[] = "$SunId$ LBL";
21  
22   VIEW    ourview = STDVIEW(512);         /* desired view */
23  
24 < double  zeps = 0.001;                   /* allowed z epsilon */
24 > double  zeps = .02;                     /* allowed z epsilon */
25  
26   COLR    *ourpict;                       /* output picture */
27   float   *ourzbuf;                       /* corresponding z-buffer */
# Line 51 | Line 51 | char   *argv[];
51                          check(2,1);
52                          zeps = atof(argv[++i]);
53                          break;
54 +                case 'x':                               /* x resolution */
55 +                        check(2,1);
56 +                        ourview.hresolu = atoi(argv[++i]);
57 +                        break;
58 +                case 'y':                               /* y resolution */
59 +                        check(2,1);
60 +                        ourview.vresolu = atoi(argv[++i]);
61 +                        break;
62                  case 'v':                               /* view */
63                          switch (argv[i][2]) {
64                          case 't':                               /* type */
# Line 165 | Line 173 | addpicture(pfile, zfile)               /* add picture to output */
173   char    *pfile, *zfile;
174   {
175          FILE    *pfp, *zfp;
168        COLR    *scanin;
169        float   *zin;
176          char    *err;
177 <        int     xres, yres;
177 >        COLR    *scanin;
178 >        float   *zin, *zlast;
179 >        int     *plast;
180          int     y;
181                                          /* open input files */
182          if ((pfp = fopen(pfile, "r")) == NULL) {
# Line 183 | Line 191 | char   *pfile, *zfile;
191          printf("%s:\n", pfile);
192          gotview = 0;
193          getheader(pfp, headline);
194 <        if (!gotview || fgetresolu(&xres, &yres, pfp) != (YMAJOR|YDECR)) {
194 >        if (!gotview || fgetresolu(&theirview.hresolu, &theirview.vresolu, pfp)
195 >                        != (YMAJOR|YDECR)) {
196                  fprintf(stderr, "%s: picture view error\n", pfile);
197                  exit(1);
198          }
190        theirview.hresolu = xres;
191        theirview.vresolu = yres;
199          if (err = setview(&theirview)) {
200                  fprintf(stderr, "%s: %s\n", pfile, err);
201                  exit(1);
# Line 196 | Line 203 | char   *pfile, *zfile;
203                                          /* compute transformation */
204          pixform(theirs2ours, &theirview, &ourview);
205                                          /* allocate scanlines */
206 <        scanin = (COLR *)malloc(xres*sizeof(COLR));
207 <        zin = (float *)malloc(xres*sizeof(float));
208 <        if (scanin == NULL || zin == NULL) {
206 >        scanin = (COLR *)malloc(theirview.hresolu*sizeof(COLR));
207 >        zin = (float *)malloc(theirview.hresolu*sizeof(float));
208 >        zlast = (float *)calloc(theirview.hresolu, sizeof(float));
209 >        plast = (int *)calloc(theirview.hresolu, sizeof(int));
210 >        if (scanin == NULL || zin == NULL || zlast == NULL || plast == NULL) {
211                  perror(progname);
212                  exit(1);
213          }
214                                          /* load image */
215 <        for (y = yres-1; y >= 0; y--) {
216 <                if (freadcolrs(scanin, xres, pfp) < 0) {
215 >        for (y = theirview.vresolu-1; y >= 0; y--) {
216 >                if (freadcolrs(scanin, theirview.hresolu, pfp) < 0) {
217                          fprintf(stderr, "%s: read error\n", pfile);
218                          exit(1);
219                  }
220 <                if (fread(zin, sizeof(float), xres, zfp) < xres) {
220 >                if (fread(zin, sizeof(float), theirview.hresolu, zfp)
221 >                                < theirview.hresolu) {
222                          fprintf(stderr, "%s: read error\n", zfile);
223                          exit(1);
224                  }
225 <                addscanline(y, scanin, zin);
225 >                addscanline(y, scanin, zin, plast, zlast);
226          }
227                                          /* clean up */
228          free((char *)scanin);
229          free((char *)zin);
230 +        free((char *)plast);
231 +        free((char *)zlast);
232          fclose(pfp);
233          fclose(zfp);
234   }
# Line 258 | Line 270 | register VIEW  *vw1, *vw2;
270   }
271  
272  
273 < addscanline(y, pline, zline)            /* add scanline to output */
273 > addscanline(y, pline, zline, lasty, lastyz)     /* add scanline to output */
274   int     y;
275   COLR    *pline;
276   float   *zline;
277 + int     *lasty;                 /* input/output */
278 + float   *lastyz;                /* input/output */
279   {
280 <        extern double   sqrt();
280 >        extern double   sqrt(), fabs();
281          double  pos[3];
282 +        int     lastx = 0;
283 +        double  lastxz = 0;
284 +        double  zt;
285 +        int     xpos, ypos;
286          register int    x;
269        register int    xpos, ypos;
287  
288 <        for (x = 0; x < theirview.hresolu; x++) {
288 >        for (x = theirview.hresolu-1; x >= 0; x--) {
289                  pos[0] = x - .5*(theirview.hresolu-1);
290                  pos[1] = y - .5*(theirview.vresolu-1);
291                  pos[2] = zline[x];
292                  if (theirview.type == VT_PER) {
293 +                        /*
294 +                         * The following (single) statement can go
295 +                         * if z is along the view direction rather
296 +                         * than an eye ray.
297 +                         */
298                          pos[2] /= sqrt( 1.
299                                          + pos[0]*pos[0]*theirview.vhn2
300                                          + pos[1]*pos[1]*theirview.vvn2 );
# Line 280 | Line 302 | float  *zline;
302                          pos[1] *= pos[2];
303                  }
304                  multp3(pos, pos, theirs2ours);
305 <                if (pos[2] <= 0.0)
305 >                if (pos[2] <= 0)
306                          continue;
307                  if (ourview.type == VT_PER) {
308                          pos[0] /= pos[2];
# Line 288 | Line 310 | float  *zline;
310                  }
311                  pos[0] += .5*ourview.hresolu;
312                  pos[1] += .5*ourview.vresolu;
313 <                if (pos[0] < 0 || pos[0] > ourview.hresolu
314 <                                || pos[1] < 0 || pos[1] > ourview.vresolu)
313 >                if (pos[0] < 0 || (xpos = pos[0]) >= ourview.hresolu
314 >                        || pos[1] < 0 || (ypos = pos[1]) >= ourview.vresolu)
315                          continue;
316 <                                        /* check current value at pos */
317 <                xpos = pos[0];
318 <                ypos = pos[1];
319 <                if (zscan(ypos)[xpos] <= 0.0
320 <                                || zscan(ypos)[xpos] - pos[2]
321 <                                        > zeps*zscan(ypos)[xpos]) {
322 <                        zscan(ypos)[xpos] = pos[2];
323 <                        copycolr(pscan(ypos)[xpos], pline[x]);
324 <                }
316 >                                        /* add pixel to our image */
317 >                zt = 2.*zeps*zline[x];
318 >                addpixel(xpos, ypos,
319 >                        (fabs(zline[x]-lastxz) <= zt) ? lastx - xpos : 1,
320 >                        (fabs(zline[x]-lastyz[x]) <= zt) ? lasty[x] - ypos : 1,
321 >                        pline[x], pos[2]);
322 >                lastx = xpos;
323 >                lasty[x] = ypos;
324 >                lastxz = lastyz[x] = zline[x];
325          }
326   }
327  
328  
329 + addpixel(xstart, ystart, width, height, pix, z) /* fill in area for pixel */
330 + int     xstart, ystart;
331 + int     width, height;
332 + COLR    pix;
333 + double  z;
334 + {
335 +        register int    x, y;
336 +                                        /* make width and height positive */
337 +        if (width < 0) {
338 +                width = -width;
339 +                xstart = xstart-width+1;
340 +        } else if (width == 0)
341 +                width = 1;
342 +        if (height < 0) {
343 +                height = -height;
344 +                ystart = ystart-height+1;
345 +        } else if (height == 0)
346 +                height = 1;
347 +                                        /* fill pixel(s) within rectangle */
348 +        for (y = ystart; y < ystart+height; y++)
349 +                for (x = xstart; x < xstart+width; x++)
350 +                        if (zscan(y)[x] <= 0
351 +                                        || zscan(y)[x]-z > zeps*zscan(y)[x]) {
352 +                                zscan(y)[x] = z;
353 +                                copycolr(pscan(y)[x], pix);
354 +                        }
355 + }
356 +
357 +
358   fillpicture()                           /* fill in empty spaces */
359   {
360          int     *yback, xback;
# Line 318 | Line 369 | fillpicture()                          /* fill in empty spaces */
369          }
370          for (x = 0; x < ourview.hresolu; x++)
371                  yback[x] = -2;
372 +        /*
373 +         * Xback and yback are the pixel locations of suitable
374 +         * background values in each direction.
375 +         * A value of -2 means unassigned, and -1 means
376 +         * that there is no suitable background in this direction.
377 +         */
378                                                          /* fill image */
379          for (y = 0; y < ourview.vresolu; y++) {
380                  xback = -2;
381                  for (x = 0; x < ourview.hresolu; x++)
382 <                        if (zscan(y)[x] <= 0.0) {       /* empty pixel */
382 >                        if (zscan(y)[x] <= 0) {         /* empty pixel */
383 >                                /*
384 >                                 * First, find background from above or below.
385 >                                 * (farthest assigned pixel)
386 >                                 */
387                                  if (yback[x] == -2) {
388                                          for (i = y+1; i < ourview.vresolu; i++)
389 <                                                if (zscan(i)[x] > 0.0)
389 >                                                if (zscan(i)[x] > 0)
390                                                          break;
391                                          if (i < ourview.vresolu
392                                  && (y <= 0 || zscan(y-1)[x] < zscan(i)[x]))
# Line 333 | Line 394 | fillpicture()                          /* fill in empty spaces */
394                                          else
395                                                  yback[x] = y-1;
396                                  }
397 +                                /*
398 +                                 * Next, find background from left or right.
399 +                                 */
400                                  if (xback == -2) {
401                                          for (i = x+1; x < ourview.hresolu; i++)
402 <                                                if (zscan(y)[i] > 0.0)
402 >                                                if (zscan(y)[i] > 0)
403                                                          break;
404                                          if (i < ourview.hresolu
405                                  && (x <= 0 || zscan(y)[x-1] < zscan(y)[i]))
# Line 344 | Line 408 | fillpicture()                          /* fill in empty spaces */
408                                                  xback = x-1;
409                                  }
410                                  if (xback < 0 && yback[x] < 0)
411 <                                        continue;
411 >                                        continue;       /* no background */
412 >                                /*
413 >                                 * Compare, and use the background that is
414 >                                 * farther, unless one of them is next to us.
415 >                                 */
416                                  if (yback[x] < 0 || ABS(x-xback) <= 1
417                                          || ( ABS(y-yback[x]) > 1
418                                  && zscan(yback[x])[x] < zscan(y)[xback] ))

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines