src/util/scanner.c

#ifndef lint
static const char       RCSid[] = "$Id: scanner.c,v 1.3 2003/02/22 02:07:30 greg Exp $";
#endif
/*
 *  scanner.c - program to simulate bi-directional scanner.
 *
 *     6/10/86
 */

#include  <stdio.h>

#include  <stdlib.h>

#include  <ctype.h>

#include  <signal.h>

#include  "random.h"


#define  PI             3.14159265358979324

#define  ANGLE          short
#define  AEND           -1

#define  atorad(a)      ((PI/180.0) * (a))

char  otcom[128] = "oconv";
char  rtcom[256] = "rtrace -bf -ar .25 -ad 128";

char  *sourcetemp,                      /* temp files */
      *octreetemp;

ANGLE  alpha[181] = {90, AEND};
ANGLE  beta[181] = {30, 60, 90, 120, 150, AEND};
ANGLE  gamma[181] = {45, AEND};

char  *target;                          /* target file name */
double  targetw = 3.0;                  /* target width (inches) */
double  targeth = 3.0;                  /* target height (inches) */
int  xres = 16;                         /* x sample resolution */
int  yres = 16;                         /* y sample resolution */

static void  quit(int code);

main(argc, argv)
int  argc;
char  *argv[];
{
        char  *strcat(), *mktemp();
        int  i;

#ifdef SIGHUP
        signal(SIGHUP, quit);
#endif
        signal(SIGINT, quit);
        signal(SIGTERM, quit);
#ifdef SIGXCPU
        signal(SIGXCPU, SIG_IGN);
        signal(SIGXFSZ, SIG_IGN);
#endif

        for (i = 1; i < argc && argv[i][0] == '-'; i++)
                switch (argv[i][1]) {
                case 't':                       /* target */
                        switch (argv[i][2]) {
                        case 'w':                       /* width */
                                targetw = atof(argv[++i]);
                                break;
                        case 'h':                       /* height */
                                targeth = atof(argv[++i]);
                                break;
                        default:
                                goto badopt;
                        }
                        break;
                case 'a':
                        if (!strcmp(argv[i], "-alpha"))
                                setscan(alpha, argv[++i]);
                        else
                                switch (argv[i][2]) {
                                case 'd':               /* ambient divisions */
                                        strcat(rtcom, " -ad ");
                                        strcat(rtcom, argv[++i]);
                                        break;
                                case 'r':               /* ambient radius */
                                        strcat(rtcom, " -ar ");
                                        strcat(rtcom, argv[++i]);
                                        break;
                                default:
                                        goto badopt;
                                }
                        break;
                case 'b':
                        if (!strcmp(argv[i], "-beta"))
                                setscan(beta, argv[++i]);
                        else
                                goto badopt;
                        break;
                case 'g':
                        if (!strcmp(argv[i], "-gamma"))
                                setscan(gamma, argv[++i]);
                        else
                                goto badopt;
                        break;
                case 'x':                       /* x resolution */
                        xres = atoi(argv[++i]);
                        break;
                case 'y':                       /* y resolution */
                        yres = atoi(argv[++i]);
                        break;
                case 'l':
                        switch (argv[i][2]) {
                        case 'w':                       /* limit weight */
                                strcat(rtcom, " -lw ");
                                strcat(rtcom, argv[++i]);
                                break;
                        case 'r':                       /* limit recursion */
                                strcat(rtcom, " -lr ");
                                strcat(rtcom, argv[++i]);
                                break;
                        default:
                                goto badopt;
                        }
                        break;
                default:;
badopt:
                        fprintf(stderr, "%s: bad option: %s\n",
                                        argv[0], argv[i]);
                        quit(1);
                }

        if (i >= argc) {
                fprintf(stderr, "%s: missing target file\n", argv[0]);
                quit(1);
        } else if (i < argc-1) {
                fprintf(stderr, "%s: too many target files\n", argv[0]);
                quit(1);
        }

        target = argv[i];
        sourcetemp = mktemp("/usr/tmp/soXXXXXX");
        octreetemp = mktemp("/usr/tmp/ocXXXXXX");
        strcat(strcat(otcom, " "), target);
        strcat(strcat(otcom, " "), sourcetemp);
        strcat(strcat(otcom, " > "), octreetemp);
        strcat(strcat(rtcom, " "), octreetemp);

        doscan();

        quit(0);
}


void
quit(code)                      /* unlink temp files and exit */
int  code;
{
        int  i;

        unlink(sourcetemp);
        unlink(octreetemp);
        exit(code);
}


setscan(ang, arg)                       /* set up scan according to arg */
register ANGLE  *ang;
register char  *arg;
{
        int  start = 0, finish = -1, step = 1;

        for ( ; ; ) {
                switch (*arg) {
                case '\0':
                case ',':
                        while (start <= finish) {
                                *ang++ = start;
                                start += step;
                        }
                        if (*arg) {
                                arg++;
                                continue;
                        } else {
                                *ang = AEND;
                                return;
                        }
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                        start = atoi(arg);
                        finish = start;
                        step = 1;
                        break;
                case '-':
                        finish = atoi(++arg);
                        break;
                case ':':
                        step = atoi(++arg);
                        break;
                default:
                        fprintf(stderr, "Scan specification error\n");
                        quit(1);
                }
                while (isdigit(*arg))
                        arg++;
        }
}


doscan()                                /* do scan for target */
{
        FILE  *fopen(), *scanstart();
        double  readsample();
        FILE  *fp;
        ANGLE  *a, *b, *g;

        printf("Alpha\tBeta\tGamma\tDistribution for \"%s\"\n", target);
        for (g = gamma; *g != AEND; g++) {
                fp = scanstart(*g);
                for (b = beta; *b != AEND; b++)         /* read data */
                        for (a = alpha; *a != AEND; a++)
                                printf("%d\t%d\t%d\t%f\n",
                                                *a, *b, *g, readsample(fp));
                scanend(fp);
        }
}


FILE *
scanstart(g)            /* open scanner pipeline */
ANGLE  g;
{
        char  *fgets();
        int  p1[2], p2[2];
        int  pid;
        FILE  *fp;
        char  buf[128];

        makesource(g);                  /* make source */
        if (system(otcom))              /* generate new octree */
                goto err;

        if (pipe(p1) < 0)               /* get pipe1 */
                goto err;
        if ((pid = fork()) == 0) {              /* if child1 */
                close(p1[0]);
                if (p1[1] != 1) {               /* connect stdout to pipe1 */
                        dup2(p1[1], 1);
                        close(p1[1]);
                }
                if (pipe(p2) < 0)               /* get pipe2 */
                        goto err;
                if ((pid = fork()) == 0) {      /* if child2 */
                        close(p2[0]);
                        if ((fp = fdopen(p2[1], "w")) == NULL)
                                goto err;
                        sendsamples(fp);        /* send our samples to pipe2 */
                        fclose(fp);
                        _exit(0);
                }
                if (pid == -1)
                        goto err;
                close(p2[1]);
                        
                if (p2[0] != 0) {               /* for child1 pipe2 to stdin */
                        dup2(p2[0], 0);
                        close(p2[0]);
                }
                execl("/bin/sh", "sh", "-c", rtcom, 0); /* run ray tracer */
                goto err;
        }
        if (pid == -1)
                goto err;
        close(p1[1]);
        if ((fp = fdopen(p1[0], "r")) == NULL)  /* parent reads pipe1 */
                goto err;
        while (fgets(buf, sizeof(buf), fp) != NULL && buf[0] != '\n')
                /* discard header */;
        return(fp);
err:
        fprintf(stderr, "System error in scanstart\n");
        quit(1);
}


scanend(fp)             /* done with scanner input */
FILE  *fp;
{
        fclose(fp);
}


makesource(g)           /* make a source (output normalized) */
ANGLE  g;
{
        FILE  *fp, *fopen();
        double  srcdir[3], sin(), cos();

        srcdir[0] = sin(atorad(g));
        srcdir[1] = 0.0;
        srcdir[2] = -cos(atorad(g));
        if ((fp = fopen(sourcetemp, "w")) == NULL) {
                fprintf(stderr, "%s: cannot create\n", sourcetemp);
                quit(1);
        }
        fprintf(fp, "0 0 0 1\n");
        fprintf(fp, "\nvoid light scanner_light\n");
        fprintf(fp, "0\n0\n3 3283 3283 3283\n");
        fprintf(fp, "\nscanner_light source scanner_source\n");
        fprintf(fp, "0\n0\n4 %f %f %f 2\n", srcdir[0], srcdir[1], srcdir[2]);
        fclose(fp);
}


sendsamples(fp)                 /* send our samples to fp */
FILE  *fp;
{
        ANGLE  *a, *b;

        for (b = beta; *b != AEND; b++)
                for (a = alpha; *a != AEND; a++)
                        writesample(fp, *a, *b);
}


writesample(fp, a, b)           /* write out sample ray grid */
FILE  *fp;
ANGLE  a, b;
{
        double  sin(), cos();
        float  sp[6];
        int  i, j;

        sp[3] = -sin(atorad(b)-(PI/2.0)) * sin(atorad(a));
        sp[4] = -cos(atorad(a));
        sp[5] = -sin(atorad(b)) * sin(atorad(a));

        for (j = 0; j < yres; j++)
                for (i = 0; i < xres; i++) {
                        sp[0] = -100.0*sp[3] +
                                        (i - xres/2.0 + frandom())*targetw/xres;
                        sp[1] = -100.0*sp[4] +
                                        (j - yres/2.0 + frandom())*targeth/yres;
                        sp[2] = -100.0*sp[5];
                        fwrite(sp, sizeof(*sp), 6, fp);
                        if (ferror(fp)) {
                                fprintf(stderr, "Data write error\n");
                                quit(1);
                        }
                }
}


double
readsample(fp)                  /* read in sample ray grid */
FILE  *fp;
{
        double  sum;
        float  col[3];
        int  i;

        sum = 0.0;
        i = xres*yres;
        while (i--) {
                if (fread(col, sizeof(*col), 3, fp) != 3) {
                        fprintf(stderr, "Data read error\n");
                        quit(1);
                }
                sum += col[1];
        }
        return(sum / (xres*yres));
}
Revision:	1.4
Committed:	Thu Jun 26 00:58:11 2003 UTC (20 years, 10 months ago) by schorsch
Content type:	text/plain
Branch:	MAIN
Changes since 1.3:	+6 -2 lines
Log Message:	Abstracted process and path handling for Windows. Renamed FLOAT to RREAL because of conflict on Windows. Added conditional compiles for some signal handlers.
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	schorsch	1.4	static const char RCSid[] = "$Id: scanner.c,v 1.3 2003/02/22 02:07:30 greg Exp $";
3	greg	1.1	#endif
4			/*
5			* scanner.c - program to simulate bi-directional scanner.
6			*
7			* 6/10/86
8			*/
9
10	greg	1.3	#include <stdio.h>
11
12			#include <stdlib.h>
13	greg	1.1
14	greg	1.3	#include <ctype.h>
15	greg	1.1
16	greg	1.3	#include <signal.h>
17	greg	1.1
18			#include "random.h"
19
20
21			#define PI 3.14159265358979324
22
23			#define ANGLE short
24			#define AEND -1
25
26			#define atorad(a) ((PI/180.0) * (a))
27
28			char otcom[128] = "oconv";
29			char rtcom[256] = "rtrace -bf -ar .25 -ad 128";
30
31			char sourcetemp, / temp files */
32			*octreetemp;
33
34			ANGLE alpha[181] = {90, AEND};
35			ANGLE beta[181] = {30, 60, 90, 120, 150, AEND};
36			ANGLE gamma[181] = {45, AEND};
37
38			char target; / target file name */
39			double targetw = 3.0; /* target width (inches) */
40			double targeth = 3.0; /* target height (inches) */
41			int xres = 16; /* x sample resolution */
42			int yres = 16; /* y sample resolution */
43
44	schorsch	1.4	static void quit(int code);
45	greg	1.1
46			main(argc, argv)
47			int argc;
48			char *argv[];
49			{
50			char strcat(), mktemp();
51			int i;
52
53	schorsch	1.4	#ifdef SIGHUP
54	greg	1.1	signal(SIGHUP, quit);
55	schorsch	1.4	#endif
56	greg	1.1	signal(SIGINT, quit);
57			signal(SIGTERM, quit);
58	schorsch	1.4	#ifdef SIGXCPU
59	greg	1.1	signal(SIGXCPU, SIG_IGN);
60			signal(SIGXFSZ, SIG_IGN);
61	schorsch	1.4	#endif
62	greg	1.1
63			for (i = 1; i < argc && argv[i][0] == '-'; i++)
64			switch (argv[i][1]) {
65			case 't': /* target */
66			switch (argv[i][2]) {
67			case 'w': /* width */
68			targetw = atof(argv[++i]);
69			break;
70			case 'h': /* height */
71			targeth = atof(argv[++i]);
72			break;
73			default:
74			goto badopt;
75			}
76			break;
77			case 'a':
78			if (!strcmp(argv[i], "-alpha"))
79			setscan(alpha, argv[++i]);
80			else
81			switch (argv[i][2]) {
82			case 'd': /* ambient divisions */
83			strcat(rtcom, " -ad ");
84			strcat(rtcom, argv[++i]);
85			break;
86			case 'r': /* ambient radius */
87			strcat(rtcom, " -ar ");
88			strcat(rtcom, argv[++i]);
89			break;
90			default:
91			goto badopt;
92			}
93			break;
94			case 'b':
95			if (!strcmp(argv[i], "-beta"))
96			setscan(beta, argv[++i]);
97			else
98			goto badopt;
99			break;
100			case 'g':
101			if (!strcmp(argv[i], "-gamma"))
102			setscan(gamma, argv[++i]);
103			else
104			goto badopt;
105			break;
106			case 'x': /* x resolution */
107			xres = atoi(argv[++i]);
108			break;
109			case 'y': /* y resolution */
110			yres = atoi(argv[++i]);
111			break;
112			case 'l':
113			switch (argv[i][2]) {
114			case 'w': /* limit weight */
115			strcat(rtcom, " -lw ");
116			strcat(rtcom, argv[++i]);
117			break;
118			case 'r': /* limit recursion */
119			strcat(rtcom, " -lr ");
120			strcat(rtcom, argv[++i]);
121			break;
122			default:
123			goto badopt;
124			}
125			break;
126			default:;
127			badopt:
128			fprintf(stderr, "%s: bad option: %s\n",
129			argv[0], argv[i]);
130			quit(1);
131			}
132
133			if (i >= argc) {
134			fprintf(stderr, "%s: missing target file\n", argv[0]);
135			quit(1);
136			} else if (i < argc-1) {
137			fprintf(stderr, "%s: too many target files\n", argv[0]);
138			quit(1);
139			}
140
141			target = argv[i];
142			sourcetemp = mktemp("/usr/tmp/soXXXXXX");
143			octreetemp = mktemp("/usr/tmp/ocXXXXXX");
144			strcat(strcat(otcom, " "), target);
145			strcat(strcat(otcom, " "), sourcetemp);
146			strcat(strcat(otcom, " > "), octreetemp);
147			strcat(strcat(rtcom, " "), octreetemp);
148
149			doscan();
150
151			quit(0);
152			}
153
154
155	greg	1.3	void
156	greg	1.1	quit(code) /* unlink temp files and exit */
157			int code;
158			{
159			int i;
160
161			unlink(sourcetemp);
162			unlink(octreetemp);
163			exit(code);
164			}
165
166
167			setscan(ang, arg) /* set up scan according to arg */
168			register ANGLE *ang;
169			register char *arg;
170			{
171			int start = 0, finish = -1, step = 1;
172
173			for ( ; ; ) {
174			switch (*arg) {
175			case '\0':
176			case ',':
177			while (start <= finish) {
178			*ang++ = start;
179			start += step;
180			}
181			if (*arg) {
182			arg++;
183			continue;
184			} else {
185			*ang = AEND;
186			return;
187			}
188			case '0':
189			case '1':
190			case '2':
191			case '3':
192			case '4':
193			case '5':
194			case '6':
195			case '7':
196			case '8':
197			case '9':
198			start = atoi(arg);
199			finish = start;
200			step = 1;
201			break;
202			case '-':
203			finish = atoi(++arg);
204			break;
205			case ':':
206			step = atoi(++arg);
207			break;
208			default:
209			fprintf(stderr, "Scan specification error\n");
210			quit(1);
211			}
212			while (isdigit(*arg))
213			arg++;
214			}
215			}
216
217
218			doscan() /* do scan for target */
219			{
220			FILE fopen(), scanstart();
221			double readsample();
222			FILE *fp;
223			ANGLE a, b, *g;
224
225			printf("Alpha\tBeta\tGamma\tDistribution for \"%s\"\n", target);
226			for (g = gamma; *g != AEND; g++) {
227			fp = scanstart(*g);
228			for (b = beta; b != AEND; b++) / read data */
229			for (a = alpha; *a != AEND; a++)
230			printf("%d\t%d\t%d\t%f\n",
231			a, b, *g, readsample(fp));
232			scanend(fp);
233			}
234			}
235
236
237			FILE *
238			scanstart(g) /* open scanner pipeline */
239			ANGLE g;
240			{
241			char *fgets();
242			int p1[2], p2[2];
243			int pid;
244			FILE *fp;
245			char buf[128];
246
247			makesource(g); /* make source */
248			if (system(otcom)) /* generate new octree */
249			goto err;
250
251			if (pipe(p1) < 0) /* get pipe1 */
252			goto err;
253			if ((pid = fork()) == 0) { /* if child1 */
254			close(p1[0]);
255			if (p1[1] != 1) { /* connect stdout to pipe1 */
256			dup2(p1[1], 1);
257			close(p1[1]);
258			}
259			if (pipe(p2) < 0) /* get pipe2 */
260			goto err;
261			if ((pid = fork()) == 0) { /* if child2 */
262			close(p2[0]);
263			if ((fp = fdopen(p2[1], "w")) == NULL)
264			goto err;
265			sendsamples(fp); /* send our samples to pipe2 */
266			fclose(fp);
267			_exit(0);
268			}
269			if (pid == -1)
270			goto err;
271			close(p2[1]);
272
273			if (p2[0] != 0) { /* for child1 pipe2 to stdin */
274			dup2(p2[0], 0);
275			close(p2[0]);
276			}
277			execl("/bin/sh", "sh", "-c", rtcom, 0); /* run ray tracer */
278			goto err;
279			}
280			if (pid == -1)
281			goto err;
282			close(p1[1]);
283			if ((fp = fdopen(p1[0], "r")) == NULL) /* parent reads pipe1 */
284			goto err;
285			while (fgets(buf, sizeof(buf), fp) != NULL && buf[0] != '\n')
286			/* discard header */;
287			return(fp);
288			err:
289			fprintf(stderr, "System error in scanstart\n");
290			quit(1);
291			}
292
293
294			scanend(fp) /* done with scanner input */
295			FILE *fp;
296			{
297			fclose(fp);
298			}
299
300
301			makesource(g) /* make a source (output normalized) */
302			ANGLE g;
303			{
304			FILE fp, fopen();
305			double srcdir[3], sin(), cos();
306
307			srcdir[0] = sin(atorad(g));
308			srcdir[1] = 0.0;
309			srcdir[2] = -cos(atorad(g));
310			if ((fp = fopen(sourcetemp, "w")) == NULL) {
311			fprintf(stderr, "%s: cannot create\n", sourcetemp);
312			quit(1);
313			}
314			fprintf(fp, "0 0 0 1\n");
315			fprintf(fp, "\nvoid light scanner_light\n");
316			fprintf(fp, "0\n0\n3 3283 3283 3283\n");
317			fprintf(fp, "\nscanner_light source scanner_source\n");
318			fprintf(fp, "0\n0\n4 %f %f %f 2\n", srcdir[0], srcdir[1], srcdir[2]);
319			fclose(fp);
320			}
321
322
323			sendsamples(fp) /* send our samples to fp */
324			FILE *fp;
325			{
326			ANGLE a, b;
327
328			for (b = beta; *b != AEND; b++)
329			for (a = alpha; *a != AEND; a++)
330			writesample(fp, a, b);
331			}
332
333
334			writesample(fp, a, b) /* write out sample ray grid */
335			FILE *fp;
336			ANGLE a, b;
337			{
338			double sin(), cos();
339			float sp[6];
340			int i, j;
341
342			sp[3] = -sin(atorad(b)-(PI/2.0)) * sin(atorad(a));
343			sp[4] = -cos(atorad(a));
344			sp[5] = -sin(atorad(b)) * sin(atorad(a));
345
346			for (j = 0; j < yres; j++)
347			for (i = 0; i < xres; i++) {
348			sp[0] = -100.0*sp[3] +
349			(i - xres/2.0 + frandom())*targetw/xres;
350			sp[1] = -100.0*sp[4] +
351			(j - yres/2.0 + frandom())*targeth/yres;
352			sp[2] = -100.0*sp[5];
353			fwrite(sp, sizeof(*sp), 6, fp);
354			if (ferror(fp)) {
355			fprintf(stderr, "Data write error\n");
356			quit(1);
357			}
358			}
359			}
360
361
362			double
363			readsample(fp) /* read in sample ray grid */
364			FILE *fp;
365			{
366			double sum;
367			float col[3];
368			int i;
369
370			sum = 0.0;
371			i = xres*yres;
372			while (i--) {
373			if (fread(col, sizeof(*col), 3, fp) != 3) {
374			fprintf(stderr, "Data read error\n");
375			quit(1);
376			}
377			sum += col[1];
378			}
379			return(sum / (xres*yres));
380			}