src/px/pinterp.c

#ifndef lint
static char SCCSid[] = "$SunId$ LBL";
#endif

/*
 * Interpolate and extrapolate pictures with different view parameters.
 *
 *      Greg Ward       09Dec89
 */

#include "standard.h"

#include "view.h"

#include "color.h"

#define pscan(y)        (ourpict+(y)*ourview.hresolu)
#define zscan(y)        (ourzbuf+(y)*ourview.hresolu)

VIEW    ourview = STDVIEW(512);         /* desired view */

double  zeps = 0.001;                   /* allowed z epsilon */

COLR    *ourpict;                       /* output picture */
float   *ourzbuf;                       /* corresponding z-buffer */

char    *progname;

VIEW    theirview = STDVIEW(512);       /* input view */
int     gotview;                        /* got input view? */


main(argc, argv)                        /* interpolate pictures */
int     argc;
char    *argv[];
{
#define check(olen,narg)        if (argv[i][olen] || narg >= argc-i) goto badopt
        int     gotvfile = 0;
        char    *err;
        int     i;

        progname = argv[0];

        for (i = 1; i < argc && argv[i][0] == '-'; i++)
                switch (argv[i][1]) {
                case 't':                               /* threshold */
                        check(2,1);
                        zeps = atof(argv[++i]);
                        break;
                case 'v':                               /* view */
                        switch (argv[i][2]) {
                        case 't':                               /* type */
                                check(4,0);
                                ourview.type = argv[i][3];
                                break;
                        case 'p':                               /* point */
                                check(3,3);
                                ourview.vp[0] = atof(argv[++i]);
                                ourview.vp[1] = atof(argv[++i]);
                                ourview.vp[2] = atof(argv[++i]);
                                break;
                        case 'd':                               /* direction */
                                check(3,3);
                                ourview.vdir[0] = atof(argv[++i]);
                                ourview.vdir[1] = atof(argv[++i]);
                                ourview.vdir[2] = atof(argv[++i]);
                                break;
                        case 'u':                               /* up */
                                check(3,3);
                                ourview.vup[0] = atof(argv[++i]);
                                ourview.vup[1] = atof(argv[++i]);
                                ourview.vup[2] = atof(argv[++i]);
                                break;
                        case 'h':                               /* horizontal */
                                check(3,1);
                                ourview.horiz = atof(argv[++i]);
                                break;
                        case 'v':                               /* vertical */
                                check(3,1);
                                ourview.vert = atof(argv[++i]);
                                break;
                        case 'f':                               /* file */
                                check(3,1);
                                gotvfile = viewfile(argv[++i], &ourview);
                                if (gotvfile < 0) {
                                        perror(argv[i]);
                                        exit(1);
                                } else if (gotvfile == 0) {
                                        fprintf(stderr, "%s: bad view file\n",
                                                        argv[i]);
                                        exit(1);
                                }
                                break;
                        default:
                                goto badopt;
                        }
                        break;
                default:
                badopt:
                        fprintf(stderr, "%s: unknown option '%s'\n",
                                        progname, argv[i]);
                        exit(1);
                }
                                                /* check arguments */
        if (argc-i < 2 || (argc-i)%2) {
                fprintf(stderr, "Usage: %s [view args] pfile zfile ..\n",
                                progname);
                exit(1);
        }
                                                /* set view */
        if (err = setview(&ourview)) {
                fprintf(stderr, "%s: %s\n", progname, err);
                exit(1);
        }
                                                /* allocate frame */
        ourpict = (COLR *)calloc(ourview.hresolu*ourview.vresolu,sizeof(COLR));
        ourzbuf = (float *)calloc(ourview.hresolu*ourview.vresolu,sizeof(float));
        if (ourpict == NULL || ourzbuf == NULL) {
                perror(progname);
                exit(1);
        }
                                                        /* get input */
        for ( ; i < argc; i += 2)
                addpicture(argv[i], argv[i+1]);
                                                        /* fill in spaces */
        fillpicture();
                                                        /* add to header */
        printargs(argc, argv, stdout);
        if (gotvfile) {
                printf(VIEWSTR);
                fprintview(&ourview, stdout);
                printf("\n");
        }
        printf("\n");
                                                        /* write output */
        writepicture();

        exit(0);
#undef check
}


headline(s)                             /* process header string */
char    *s;
{
        static char     *altname[] = {"rview","rpict","pinterp",VIEWSTR,NULL};
        register char   **an;

        printf("\t%s", s);

        for (an = altname; *an != NULL; an++)
                if (!strncmp(*an, s, strlen(*an))) {
                        if (sscanview(&theirview, s+strlen(*an)) == 0)
                                gotview++;
                        break;
                }
}


addpicture(pfile, zfile)                /* add picture to output */
char    *pfile, *zfile;
{
        FILE    *pfp, *zfp;
        COLR    *scanin;
        float   *zin;
        char    *err;
        int     xres, yres;
        int     y;
                                        /* open input files */
        if ((pfp = fopen(pfile, "r")) == NULL) {
                perror(pfile);
                exit(1);
        }
        if ((zfp = fopen(zfile, "r")) == NULL) {
                perror(zfile);
                exit(1);
        }
                                        /* get header and view */
        printf("%s:\n", pfile);
        gotview = 0;
        getheader(pfp, headline);
        if (!gotview || fgetresolu(&xres, &yres, pfp) != (YMAJOR|YDECR)) {
                fprintf(stderr, "%s: picture view error\n", pfile);
                exit(1);
        }
        theirview.hresolu = xres;
        theirview.vresolu = yres;
        if (err = setview(&theirview)) {
                fprintf(stderr, "%s: %s\n", pfile, err);
                exit(1);
        }
                                        /* allocate scanlines */
        scanin = (COLR *)malloc(xres*sizeof(COLR));
        zin = (float *)malloc(xres*sizeof(float));
        if (scanin == NULL || zin == NULL) {
                perror(progname);
                exit(1);
        }
                                        /* load image */
        for (y = yres-1; y >= 0; y--) {
                if (freadcolrs(scanin, xres, pfp) < 0) {
                        fprintf(stderr, "%s: read error\n", pfile);
                        exit(1);
                }
                if (fread(zin, sizeof(float), xres, zfp) < xres) {
                        fprintf(stderr, "%s: read error\n", zfile);
                        exit(1);
                }
                addscanline(y, scanin, zin);
        }
                                        /* clean up */
        free((char *)scanin);
        free((char *)zin);
        fclose(pfp);
        fclose(zfp);
}


addscanline(y, pline, zline)            /* add scanline to output */
int     y;
COLR    *pline;
float   *zline;
{
        FVECT   p, dir;
        double  xnew, ynew, znew;
        register int    x;
        register int    xpos, ypos;

        for (x = 0; x < theirview.hresolu; x++) {
                rayview(p, dir, &theirview, x+.5, y+.5);
                p[0] += zline[x]*dir[0];
                p[1] += zline[x]*dir[1];
                p[2] += zline[x]*dir[2];
                pixelview(&xnew, &ynew, &znew, &ourview, p);
                if (znew <= 0.0 || xnew < 0 || xnew > ourview.hresolu
                                || ynew < 0 || ynew > ourview.vresolu)
                        continue;
                                        /* check current value at position */
                xpos = xnew;
                ypos = ynew;
                if (zscan(ypos)[xpos] <= 0.0
                                || zscan(ypos)[xpos] - znew
                                        > zeps*zscan(ypos)[xpos]) {
                        zscan(ypos)[xpos] = znew;
                        copycolr(pscan(ypos)[xpos], pline[x]);
                }
        }
}


fillpicture()                           /* fill in empty spaces */
{
        int     *yback, xback;
        int     y;
        COLR    pfill;
        register int    x, i;
                                                        /* get back buffer */
        yback = (int *)malloc(ourview.hresolu*sizeof(int));
        if (yback == NULL) {
                perror(progname);
                return;
        }
        for (x = 0; x < ourview.hresolu; x++)
                yback[x] = -1;
                                                        /* fill image */
        for (y = 0; y < ourview.vresolu; y++)
                for (x = 0; x < ourview.hresolu; x++)
                        if (zscan(y)[x] <= 0.0) {       /* found hole */
                                xback = x-1;
                                do {                    /* find boundary */
                                        if (yback[x] < 0) {
                                                for (i = y+1;
                                                        i < ourview.vresolu;
                                                                i++)
                                                        if (zscan(i)[x] > 0.0)
                                                                break;
                                                if (i < ourview.vresolu
                                && (y <= 0 || zscan(y-1)[x] < zscan(i)[x]))
                                                        yback[x] = i;
                                                else
                                                        yback[x] = y-1;
                                        }
                                } while (++x < ourview.hresolu
                                                && zscan(y)[x] <= 0.0);
                                i = xback;              /* pick background */
                                if (x < ourview.hresolu
                        && (i < 0 || zscan(y)[i] < zscan(y)[x]))
                                        xback = x;
                                                        /* fill hole */
                                if (xback < 0) {
                                        while (++i < x)
                                                if (yback[i] >= 0)
                                copycolr(pscan(y)[i],pscan(yback[i])[i]);
                                } else {
                                        while (++i < x)
                                                if (yback[i] < 0 ||
                                zscan(yback[i])[i] < zscan(y)[xback])
                                        copycolr(pscan(y)[i],pscan(y)[xback]);
                                                else
                                        copycolr(pscan(y)[i],pscan(yback[i])[i]);
                                }
                } else
                        yback[x] = -1;                  /* clear boundary */
        free((char *)yback);
}


writepicture()                          /* write out picture */
{
        int     y;

        fputresolu(YMAJOR|YDECR, ourview.hresolu, ourview.vresolu, stdout);
        for (y = ourview.vresolu-1; y >= 0; y--)
                if (fwritecolrs(pscan(y), ourview.hresolu, stdout) < 0) {
                        perror(progname);
                        exit(1);
                }
}
Revision:	1.2
Committed:	Tue Dec 12 11:21:25 1989 UTC (34 years, 4 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 1.1:	+50 -23 lines
Log Message:	enhanced fillpicture() function
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2			static char SCCSid[] = "$SunId$ LBL";
3			#endif
4
5			/*
6			* Interpolate and extrapolate pictures with different view parameters.
7			*
8			* Greg Ward 09Dec89
9			*/
10
11			#include "standard.h"
12
13			#include "view.h"
14
15			#include "color.h"
16
17			#define pscan(y) (ourpict+(y)*ourview.hresolu)
18			#define zscan(y) (ourzbuf+(y)*ourview.hresolu)
19
20			VIEW ourview = STDVIEW(512); /* desired view */
21
22			double zeps = 0.001; /* allowed z epsilon */
23
24			COLR ourpict; / output picture */
25			float ourzbuf; / corresponding z-buffer */
26
27			char *progname;
28
29			VIEW theirview = STDVIEW(512); /* input view */
30			int gotview; /* got input view? */
31
32
33			main(argc, argv) /* interpolate pictures */
34			int argc;
35			char *argv[];
36			{
37			#define check(olen,narg) if (argv[i][olen] \|\| narg >= argc-i) goto badopt
38			int gotvfile = 0;
39			char *err;
40			int i;
41
42			progname = argv[0];
43
44			for (i = 1; i < argc && argv[i][0] == '-'; i++)
45			switch (argv[i][1]) {
46			case 't': /* threshold */
47			check(2,1);
48			zeps = atof(argv[++i]);
49			break;
50			case 'v': /* view */
51			switch (argv[i][2]) {
52			case 't': /* type */
53			check(4,0);
54			ourview.type = argv[i][3];
55			break;
56			case 'p': /* point */
57			check(3,3);
58			ourview.vp[0] = atof(argv[++i]);
59			ourview.vp[1] = atof(argv[++i]);
60			ourview.vp[2] = atof(argv[++i]);
61			break;
62			case 'd': /* direction */
63			check(3,3);
64			ourview.vdir[0] = atof(argv[++i]);
65			ourview.vdir[1] = atof(argv[++i]);
66			ourview.vdir[2] = atof(argv[++i]);
67			break;
68			case 'u': /* up */
69			check(3,3);
70			ourview.vup[0] = atof(argv[++i]);
71			ourview.vup[1] = atof(argv[++i]);
72			ourview.vup[2] = atof(argv[++i]);
73			break;
74			case 'h': /* horizontal */
75			check(3,1);
76			ourview.horiz = atof(argv[++i]);
77			break;
78			case 'v': /* vertical */
79			check(3,1);
80			ourview.vert = atof(argv[++i]);
81			break;
82			case 'f': /* file */
83			check(3,1);
84			gotvfile = viewfile(argv[++i], &ourview);
85			if (gotvfile < 0) {
86			perror(argv[i]);
87			exit(1);
88			} else if (gotvfile == 0) {
89			fprintf(stderr, "%s: bad view file\n",
90			argv[i]);
91			exit(1);
92			}
93			break;
94			default:
95			goto badopt;
96			}
97			break;
98			default:
99			badopt:
100			fprintf(stderr, "%s: unknown option '%s'\n",
101			progname, argv[i]);
102			exit(1);
103			}
104			/* check arguments */
105			if (argc-i < 2 \|\| (argc-i)%2) {
106			fprintf(stderr, "Usage: %s [view args] pfile zfile ..\n",
107			progname);
108			exit(1);
109			}
110			/* set view */
111			if (err = setview(&ourview)) {
112			fprintf(stderr, "%s: %s\n", progname, err);
113			exit(1);
114			}
115			/* allocate frame */
116			ourpict = (COLR )calloc(ourview.hresoluourview.vresolu,sizeof(COLR));
117			ourzbuf = (float )calloc(ourview.hresoluourview.vresolu,sizeof(float));
118			if (ourpict == NULL \|\| ourzbuf == NULL) {
119			perror(progname);
120			exit(1);
121			}
122			/* get input */
123			for ( ; i < argc; i += 2)
124			addpicture(argv[i], argv[i+1]);
125			/* fill in spaces */
126			fillpicture();
127			/* add to header */
128			printargs(argc, argv, stdout);
129			if (gotvfile) {
130			printf(VIEWSTR);
131			fprintview(&ourview, stdout);
132			printf("\n");
133			}
134			printf("\n");
135			/* write output */
136			writepicture();
137
138			exit(0);
139			#undef check
140			}
141
142
143			headline(s) /* process header string */
144			char *s;
145			{
146			static char *altname[] = {"rview","rpict","pinterp",VIEWSTR,NULL};
147			register char **an;
148
149			printf("\t%s", s);
150
151			for (an = altname; *an != NULL; an++)
152			if (!strncmp(an, s, strlen(an))) {
153			if (sscanview(&theirview, s+strlen(*an)) == 0)
154			gotview++;
155			break;
156			}
157			}
158
159
160			addpicture(pfile, zfile) /* add picture to output */
161			char pfile, zfile;
162			{
163			FILE pfp, zfp;
164			COLR *scanin;
165			float *zin;
166			char *err;
167			int xres, yres;
168			int y;
169			/* open input files */
170			if ((pfp = fopen(pfile, "r")) == NULL) {
171			perror(pfile);
172			exit(1);
173			}
174			if ((zfp = fopen(zfile, "r")) == NULL) {
175			perror(zfile);
176			exit(1);
177			}
178			/* get header and view */
179			printf("%s:\n", pfile);
180			gotview = 0;
181			getheader(pfp, headline);
182			if (!gotview \|\| fgetresolu(&xres, &yres, pfp) != (YMAJOR\|YDECR)) {
183			fprintf(stderr, "%s: picture view error\n", pfile);
184			exit(1);
185			}
186			theirview.hresolu = xres;
187			theirview.vresolu = yres;
188			if (err = setview(&theirview)) {
189			fprintf(stderr, "%s: %s\n", pfile, err);
190			exit(1);
191			}
192			/* allocate scanlines */
193			scanin = (COLR )malloc(xressizeof(COLR));
194			zin = (float )malloc(xressizeof(float));
195			if (scanin == NULL \|\| zin == NULL) {
196			perror(progname);
197			exit(1);
198			}
199			/* load image */
200			for (y = yres-1; y >= 0; y--) {
201			if (freadcolrs(scanin, xres, pfp) < 0) {
202			fprintf(stderr, "%s: read error\n", pfile);
203			exit(1);
204			}
205			if (fread(zin, sizeof(float), xres, zfp) < xres) {
206			fprintf(stderr, "%s: read error\n", zfile);
207			exit(1);
208			}
209			addscanline(y, scanin, zin);
210			}
211			/* clean up */
212			free((char *)scanin);
213			free((char *)zin);
214			fclose(pfp);
215			fclose(zfp);
216			}
217
218
219			addscanline(y, pline, zline) /* add scanline to output */
220			int y;
221			COLR *pline;
222			float *zline;
223			{
224			FVECT p, dir;
225			double xnew, ynew, znew;
226			register int x;
227			register int xpos, ypos;
228
229			for (x = 0; x < theirview.hresolu; x++) {
230			rayview(p, dir, &theirview, x+.5, y+.5);
231			p[0] += zline[x]*dir[0];
232			p[1] += zline[x]*dir[1];
233			p[2] += zline[x]*dir[2];
234			pixelview(&xnew, &ynew, &znew, &ourview, p);
235			if (znew <= 0.0 \|\| xnew < 0 \|\| xnew > ourview.hresolu
236			\|\| ynew < 0 \|\| ynew > ourview.vresolu)
237			continue;
238			/* check current value at position */
239			xpos = xnew;
240			ypos = ynew;
241			if (zscan(ypos)[xpos] <= 0.0
242			\|\| zscan(ypos)[xpos] - znew
243			> zeps*zscan(ypos)[xpos]) {
244			zscan(ypos)[xpos] = znew;
245			copycolr(pscan(ypos)[xpos], pline[x]);
246			}
247			}
248			}
249
250
251			fillpicture() /* fill in empty spaces */
252			{
253	greg	1.2	int *yback, xback;
254	greg	1.1	int y;
255	greg	1.2	COLR pfill;
256			register int x, i;
257			/* get back buffer */
258			yback = (int )malloc(ourview.hresolusizeof(int));
259			if (yback == NULL) {
260			perror(progname);
261			return;
262			}
263			for (x = 0; x < ourview.hresolu; x++)
264			yback[x] = -1;
265			/* fill image */
266			for (y = 0; y < ourview.vresolu; y++)
267	greg	1.1	for (x = 0; x < ourview.hresolu; x++)
268	greg	1.2	if (zscan(y)[x] <= 0.0) { /* found hole */
269			xback = x-1;
270			do { /* find boundary */
271			if (yback[x] < 0) {
272			for (i = y+1;
273			i < ourview.vresolu;
274			i++)
275			if (zscan(i)[x] > 0.0)
276			break;
277			if (i < ourview.vresolu
278			&& (y <= 0 \|\| zscan(y-1)[x] < zscan(i)[x]))
279			yback[x] = i;
280			else
281			yback[x] = y-1;
282			}
283			} while (++x < ourview.hresolu
284			&& zscan(y)[x] <= 0.0);
285			i = xback; /* pick background */
286			if (x < ourview.hresolu
287			&& (i < 0 \|\| zscan(y)[i] < zscan(y)[x]))
288			xback = x;
289			/* fill hole */
290			if (xback < 0) {
291			while (++i < x)
292			if (yback[i] >= 0)
293			copycolr(pscan(y)[i],pscan(yback[i])[i]);
294			} else {
295			while (++i < x)
296			if (yback[i] < 0 \|\|
297			zscan(yback[i])[i] < zscan(y)[xback])
298			copycolr(pscan(y)[i],pscan(y)[xback]);
299			else
300			copycolr(pscan(y)[i],pscan(yback[i])[i]);
301			}
302			} else
303			yback[x] = -1; /* clear boundary */
304			free((char *)yback);
305	greg	1.1	}
306
307
308			writepicture() /* write out picture */
309			{
310			int y;
311
312			fputresolu(YMAJOR\|YDECR, ourview.hresolu, ourview.vresolu, stdout);
313			for (y = ourview.vresolu-1; y >= 0; y--)
314			if (fwritecolrs(pscan(y), ourview.hresolu, stdout) < 0) {
315			perror(progname);
316			exit(1);
317			}
318			}