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.3 by greg, Tue Dec 12 15:53:10 1989 UTC vs.
Revision 1.7 by greg, Tue Jan 2 17:22:07 1990 UTC

# Line 31 | Line 31 | char   *progname;
31   VIEW    theirview = STDVIEW(512);       /* input view */
32   int     gotview;                        /* got input view? */
33  
34 + double  theirs2ours[4][4];              /* transformation matrix */
35  
36 +
37   main(argc, argv)                        /* interpolate pictures */
38   int     argc;
39   char    *argv[];
# Line 49 | 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 191 | Line 201 | char   *pfile, *zfile;
201                  fprintf(stderr, "%s: %s\n", pfile, err);
202                  exit(1);
203          }
204 +                                        /* compute transformation */
205 +        pixform(theirs2ours, &theirview, &ourview);
206                                          /* allocate scanlines */
207          scanin = (COLR *)malloc(xres*sizeof(COLR));
208          zin = (float *)malloc(xres*sizeof(float));
# Line 218 | Line 230 | char   *pfile, *zfile;
230   }
231  
232  
233 + pixform(xfmat, vw1, vw2)                /* compute view1 to view2 matrix */
234 + register double xfmat[4][4];
235 + register VIEW   *vw1, *vw2;
236 + {
237 +        double  m4t[4][4];
238 +
239 +        setident4(xfmat);
240 +        xfmat[0][0] = vw1->vhinc[0];
241 +        xfmat[0][1] = vw1->vhinc[1];
242 +        xfmat[0][2] = vw1->vhinc[2];
243 +        xfmat[1][0] = vw1->vvinc[0];
244 +        xfmat[1][1] = vw1->vvinc[1];
245 +        xfmat[1][2] = vw1->vvinc[2];
246 +        xfmat[2][0] = vw1->vdir[0];
247 +        xfmat[2][1] = vw1->vdir[1];
248 +        xfmat[2][2] = vw1->vdir[2];
249 +        xfmat[3][0] = vw1->vp[0];
250 +        xfmat[3][1] = vw1->vp[1];
251 +        xfmat[3][2] = vw1->vp[2];
252 +        setident4(m4t);
253 +        m4t[0][0] = vw2->vhinc[0]/vw2->vhn2;
254 +        m4t[1][0] = vw2->vhinc[1]/vw2->vhn2;
255 +        m4t[2][0] = vw2->vhinc[2]/vw2->vhn2;
256 +        m4t[3][0] = -DOT(vw2->vp,vw2->vhinc)/vw2->vhn2;
257 +        m4t[0][1] = vw2->vvinc[0]/vw2->vvn2;
258 +        m4t[1][1] = vw2->vvinc[1]/vw2->vvn2;
259 +        m4t[2][1] = vw2->vvinc[2]/vw2->vvn2;
260 +        m4t[3][1] = -DOT(vw2->vp,vw2->vvinc)/vw2->vvn2;
261 +        m4t[0][2] = vw2->vdir[0];
262 +        m4t[1][2] = vw2->vdir[1];
263 +        m4t[2][2] = vw2->vdir[2];
264 +        m4t[3][2] = -DOT(vw2->vp,vw2->vdir);
265 +        multmat4(xfmat, xfmat, m4t);
266 + }
267 +
268 +
269   addscanline(y, pline, zline)            /* add scanline to output */
270   int     y;
271   COLR    *pline;
272   float   *zline;
273   {
274 <        FVECT   p, dir;
275 <        double  xnew, ynew, znew;
274 >        extern double   sqrt();
275 >        double  pos[3];
276          register int    x;
277          register int    xpos, ypos;
278  
279          for (x = 0; x < theirview.hresolu; x++) {
280 <                rayview(p, dir, &theirview, x+.5, y+.5);
281 <                p[0] += zline[x]*dir[0];
282 <                p[1] += zline[x]*dir[1];
283 <                p[2] += zline[x]*dir[2];
284 <                pixelview(&xnew, &ynew, &znew, &ourview, p);
285 <                if (znew <= 0.0 || xnew < 0 || xnew > ourview.hresolu
286 <                                || ynew < 0 || ynew > ourview.vresolu)
280 >                pos[0] = x - .5*(theirview.hresolu-1);
281 >                pos[1] = y - .5*(theirview.vresolu-1);
282 >                pos[2] = zline[x];
283 >                if (theirview.type == VT_PER) {
284 >                        pos[2] /= sqrt( 1.
285 >                                        + pos[0]*pos[0]*theirview.vhn2
286 >                                        + pos[1]*pos[1]*theirview.vvn2 );
287 >                        pos[0] *= pos[2];
288 >                        pos[1] *= pos[2];
289 >                }
290 >                multp3(pos, pos, theirs2ours);
291 >                if (pos[2] <= 0.0)
292                          continue;
293 <                                        /* check current value at position */
294 <                xpos = xnew;
295 <                ypos = ynew;
293 >                if (ourview.type == VT_PER) {
294 >                        pos[0] /= pos[2];
295 >                        pos[1] /= pos[2];
296 >                }
297 >                pos[0] += .5*ourview.hresolu;
298 >                pos[1] += .5*ourview.vresolu;
299 >                if (pos[0] < 0 || pos[0] >= ourview.hresolu
300 >                                || pos[1] < 0 || pos[1] >= ourview.vresolu)
301 >                        continue;
302 >                                        /* check current value at pos */
303 >                xpos = pos[0];
304 >                ypos = pos[1];
305                  if (zscan(ypos)[xpos] <= 0.0
306 <                                || zscan(ypos)[xpos] - znew
306 >                                || zscan(ypos)[xpos] - pos[2]
307                                          > zeps*zscan(ypos)[xpos]) {
308 <                        zscan(ypos)[xpos] = znew;
308 >                        zscan(ypos)[xpos] = pos[2];
309                          copycolr(pscan(ypos)[xpos], pline[x]);
310                  }
311          }
# Line 263 | Line 325 | fillpicture()                          /* fill in empty spaces */
325                  return;
326          }
327          for (x = 0; x < ourview.hresolu; x++)
328 <                yback[x] = -1;
328 >                yback[x] = -2;
329 >        /*
330 >         * Xback and yback are the pixel locations of suitable
331 >         * background values in each direction.
332 >         * A value of -2 means unassigned, and -1 means
333 >         * that there is no suitable background in this direction.
334 >         */
335                                                          /* fill image */
336 <        for (y = 0; y < ourview.vresolu; y++)
336 >        for (y = 0; y < ourview.vresolu; y++) {
337 >                xback = -2;
338                  for (x = 0; x < ourview.hresolu; x++)
339 <                        if (zscan(y)[x] <= 0.0) {       /* found hole */
340 <                                xback = x-1;
341 <                                do {                    /* find boundary */
342 <                                        if (yback[x] < 0) {
343 <                                                for (i = y+1;
344 <                                                        i < ourview.vresolu;
345 <                                                                i++)
346 <                                                        if (zscan(i)[x] > 0.0)
347 <                                                                break;
348 <                                                if (i < ourview.vresolu
339 >                        if (zscan(y)[x] <= 0.0) {       /* empty pixel */
340 >                                /*
341 >                                 * First, find background from above or below.
342 >                                 * (farthest assigned pixel)
343 >                                 */
344 >                                if (yback[x] == -2) {
345 >                                        for (i = y+1; i < ourview.vresolu; i++)
346 >                                                if (zscan(i)[x] > 0.0)
347 >                                                        break;
348 >                                        if (i < ourview.vresolu
349                                  && (y <= 0 || zscan(y-1)[x] < zscan(i)[x]))
350 <                                                        yback[x] = i;
351 <                                                else
352 <                                                        yback[x] = y-1;
284 <                                        }
285 <                                } while (++x < ourview.hresolu
286 <                                                && zscan(y)[x] <= 0.0);
287 <                                i = xback;              /* pick background */
288 <                                if (x < ourview.hresolu
289 <                        && (i < 0 || zscan(y)[i] < zscan(y)[x]))
290 <                                        xback = x;
291 <                                                        /* fill hole */
292 <                                if (xback < 0) {
293 <                                        while (++i < x)
294 <                                                if (yback[i] >= 0)
295 <                                copycolr(pscan(y)[i],pscan(yback[i])[i]);
296 <                                } else {
297 <                                        while (++i < x)
298 <                                                if (yback[i] < 0
299 <                                || ABS(i-xback) <= 1 || (ABS(y-yback[i]) > 1
300 <                                && zscan(yback[i])[i] < zscan(y)[xback]))
301 <                                        copycolr(pscan(y)[i],pscan(y)[xback]);
302 <                                                else
303 <                                        copycolr(pscan(y)[i],pscan(yback[i])[i]);
350 >                                                yback[x] = i;
351 >                                        else
352 >                                                yback[x] = y-1;
353                                  }
354 <                } else
355 <                        yback[x] = -1;                  /* clear boundary */
354 >                                /*
355 >                                 * Next, find background from left or right.
356 >                                 */
357 >                                if (xback == -2) {
358 >                                        for (i = x+1; x < ourview.hresolu; i++)
359 >                                                if (zscan(y)[i] > 0.0)
360 >                                                        break;
361 >                                        if (i < ourview.hresolu
362 >                                && (x <= 0 || zscan(y)[x-1] < zscan(y)[i]))
363 >                                                xback = i;
364 >                                        else
365 >                                                xback = x-1;
366 >                                }
367 >                                if (xback < 0 && yback[x] < 0)
368 >                                        continue;       /* no background */
369 >                                /*
370 >                                 * Compare, and use the background that is
371 >                                 * farther, unless one of them is next to us.
372 >                                 */
373 >                                if (yback[x] < 0 || ABS(x-xback) <= 1
374 >                                        || ( ABS(y-yback[x]) > 1
375 >                                && zscan(yback[x])[x] < zscan(y)[xback] ))
376 >                                        copycolr(pscan(y)[x],pscan(y)[xback]);
377 >                                else
378 >                                        copycolr(pscan(y)[x],pscan(yback[x])[x]);
379 >                        } else {                                /* full pixel */
380 >                                yback[x] = -2;
381 >                                xback = -2;
382 >                        }
383 >        }
384          free((char *)yback);
385   }
386  

Diff Legend

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