src/gen/genrev.c

#ifndef lint
static const char       RCSid[] = "$Id$";
#endif
/*
 *  genrev.c - program to generate functions of rotation about z
 *
 *      The program takes as input the functions of t for z and r
 *      (the radius).  If z is increasing, the normal points
 *      outward, inward for decreasing z.  Negative radii are forbidden.
 *
 *      8/6/86
 */

#include  <stdio.h>
#include  <math.h>

#define  ZNAME          "Z`SYS`"                /* z function name */
#define  RNAME          "R`SYS`"                /* r function name */

#define  PI             3.14159265358979323846

#define  FTINY          1e-9
                                        /* orientation */
#define  OUT            01
#define  IN             02
#define  UP             04
#define  DOWN           010

double  funvalue(), l_hermite(), l_bezier(), l_bspline(), argument();

void    quit(), eputs(), wputs();


main(argc, argv)
int  argc;
char  *argv[];
{
        extern long     eclock;
        char  stmp[256];
        char  *modname;
        int  smooth = 0;
        double  t, lastz, z, nextz, lastr, r, nextr;
        double  lastnz, lastnr, nz, nr, nextnz, nextnr;
        int  i, nseg;
        int  orient;

        varset("PI", ':', PI);
        funset("hermite", 5, ':', l_hermite);
        funset("bezier", 5, ':', l_bezier);
        funset("bspline", 5, ':', l_bspline);

        if (argc < 6)
                goto userror;

        for (i = 6; i < argc; i++)
                if (!strcmp(argv[i], "-e"))
                        scompile(argv[++i], NULL, 0);
                else if (!strcmp(argv[i], "-f"))
                        fcompile(argv[++i]);
                else if (!strcmp(argv[i], "-s"))
                        smooth = 1;
                else
                        goto userror;

        sprintf(stmp, "%s(t)=%s;", ZNAME, argv[3]);
        scompile(stmp, NULL, 0);
        sprintf(stmp, "%s(t)=%s;", RNAME, argv[4]);
        scompile(stmp, NULL, 0);
        nseg = atoi(argv[5]);
        if (nseg <= 0)
                goto userror;
        modname = smooth ? "Phong" : argv[1];

        printhead(argc, argv);
        eclock = 0;

        lastnz = lastnr = 0.0;
        t = 0.0;
        lastz = funvalue(ZNAME, 1, &t);
        lastr = funvalue(RNAME, 1, &t);
        t = 1.0/nseg;
        z = funvalue(ZNAME, 1, &t);
        r = funvalue(RNAME, 1, &t);
        computen(&nz, &nr, lastz, lastr, z, r);
        for (i = 1; i <= nseg; i++) {
                if (i < nseg) {
                        t = (double)(i+1)/nseg;
                        nextz = funvalue(ZNAME, 1, &t);
                        nextr = funvalue(RNAME, 1, &t);
                        computen(&nextnz, &nextnr, z, r, nextz, nextr);
                } else
                        nextnz = nextnr = 0.0;
                orient = 0;
                if (z < lastz-FTINY)
                        orient |= DOWN;
                else if (z > lastz+FTINY)
                        orient |= UP;
                if (r < lastr-FTINY)
                        orient |= IN;
                else if (r > lastr+FTINY)
                        orient |= OUT;
                if (!orient)
                        goto endfor;
                if (smooth) {
                        printf("\n%s texfunc Phong\n", argv[1]);
                        printf("4 rev_dx rev_dy rev_dz rev.cal\n");
                        printf("0\n4\n");
                        if (orient&(UP|DOWN)) {
                                t = (nextnz - lastnz)/(z - lastz);
                                printf("\t%15.9g\t%15.9g\n",
                                                t, lastnz - t*lastz);
                        } else
                                printf("\t0\t%d\n", orient&IN ? 1 : -1);
                        if (orient&(OUT|IN))  {
                                t = (nextnr - lastnr)/(r - lastr);
                                printf("\t%15.9g\t%15.9g\n",
                                                t, lastnr - t*lastr);
                        } else
                                printf("\t0\t%d\n", orient&UP ? 1 : -1);
                }
                if (!(orient&(IN|OUT))) {
                        printf("\n%s %s %s.%d\n", modname,
                                        orient&DOWN ? "tube" : "cylinder",
                                        argv[2], i);
                        printf("0\n0\n7\n");
                        printf("\t0\t0\t%15.9g\n", lastz);
                        printf("\t0\t0\t%15.9g\n", z);
                        printf("\t%15.9g\n", r);
                } else if (!(orient&(UP|DOWN))) {
                        printf("\n%s ring %s.%d\n", modname, argv[2], i);
                        printf("0\n0\n8\n");
                        printf("\t0\t0\t%15.9g\n", z);
                        printf("\t0\t0\t%15.9g\n", orient&IN ? 1.0 : -1.0);
                        printf("\t%15.9g\t%15.9g\n", lastr, r);
                } else {
                        printf("\n%s %s %s.%d\n", modname,
                                        orient&DOWN ? "cup" : "cone",
                                        argv[2], i);
                        printf("0\n0\n8\n");
                        printf("\t0\t0\t%15.9g\n", lastz);
                        printf("\t0\t0\t%15.9g\n", z);
                        printf("\t%15.9g\t%15.9g\n", lastr, r);
                }
        endfor:
                lastz = z; lastr = r;
                z = nextz; r = nextr;
                lastnz = nz; lastnr = nr;
                nz = nextnz; nr = nextnr;
        }
        quit(0);

userror:
        fprintf(stderr,
        "Usage: %s material name z(t) r(t) nseg [-e expr] [-f file] [-s]\n",
                        argv[0]);
        quit(1);
}


computen(nzp, nrp, z0, r0, z1, r1)              /* compute normal */
double  *nzp, *nrp, z0, r0, z1, r1;
{
        double  dr, dz, len;

        dz = r0 - r1;                           /* right angle vector */
        dr = z1 - z0;
        len = sqrt(dr*dr + dz*dz);
        *nzp = dz/len;
        *nrp = dr/len;
}


void
eputs(msg)
char  *msg;
{
        fputs(msg, stderr);
}


void
wputs(msg)
char  *msg;
{
        eputs(msg);
}


void
quit(code)
int  code;
{
        exit(code);
}


printhead(ac, av)               /* print command header */
register int  ac;
register char  **av;
{
        putchar('#');
        while (ac--) {
                putchar(' ');
                fputs(*av++, stdout);
        }
        putchar('\n');
}


double
l_hermite()                     
{
        double  t;
        
        t = argument(5);
        return( argument(1)*((2.0*t-3.0)*t*t+1.0) +
                argument(2)*(-2.0*t+3.0)*t*t +
                argument(3)*((t-2.0)*t+1.0)*t +
                argument(4)*(t-1.0)*t*t );
}


double
l_bezier()
{
        double  t;

        t = argument(5);
        return( argument(1) * (1.+t*(-3.+t*(3.-t))) +
                argument(2) * 3.*t*(1.+t*(-2.+t)) +
                argument(3) * 3.*t*t*(1.-t) +
                argument(4) * t*t*t );
}


double
l_bspline()
{
        double  t;

        t = argument(5);
        return( argument(1) * (1./6.+t*(-1./2.+t*(1./2.-1./6.*t))) +
                argument(2) * (2./3.+t*t*(-1.+1./2.*t)) +
                argument(3) * (1./6.+t*(1./2.+t*(1./2.-1./2.*t))) +
                argument(4) * (1./6.*t*t*t) );
}
Revision:	2.4
Committed:	Sat Feb 22 02:07:23 2003 UTC (21 years, 2 months ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad3R5
Changes since 2.3:	+6 -4 lines
Log Message:	Changes and check-in for 3.5 release Includes new source files and modifications not recorded for many years See ray/doc/notes/ReleaseNotes for notes between 3.1 and 3.5 release
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.4	static const char RCSid[] = "$Id$";
3	greg	1.1	#endif
4	greg	1.2	/*
5	greg	1.1	* genrev.c - program to generate functions of rotation about z
6			*
7			* The program takes as input the functions of t for z and r
8			* (the radius). If z is increasing, the normal points
9			* outward, inward for decreasing z. Negative radii are forbidden.
10			*
11			* 8/6/86
12			*/
13
14			#include <stdio.h>
15	greg	2.2	#include <math.h>
16	greg	1.1
17	greg	1.10	#define ZNAME "Z`SYS`" /* z function name */
18			#define RNAME "R`SYS`" /* r function name */
19	greg	1.1
20			#define PI 3.14159265358979323846
21
22			#define FTINY 1e-9
23			/* orientation */
24			#define OUT 01
25			#define IN 02
26			#define UP 04
27			#define DOWN 010
28
29	greg	1.5	double funvalue(), l_hermite(), l_bezier(), l_bspline(), argument();
30	greg	1.1
31	greg	2.4	void quit(), eputs(), wputs();
32
33	greg	1.1
34			main(argc, argv)
35			int argc;
36			char *argv[];
37			{
38	greg	1.6	extern long eclock;
39	greg	1.1	char stmp[256];
40			char *modname;
41			int smooth = 0;
42			double t, lastz, z, nextz, lastr, r, nextr;
43			double lastnz, lastnr, nz, nr, nextnz, nextnr;
44			int i, nseg;
45			int orient;
46
47	greg	1.8	varset("PI", ':', PI);
48	greg	1.9	funset("hermite", 5, ':', l_hermite);
49			funset("bezier", 5, ':', l_bezier);
50			funset("bspline", 5, ':', l_bspline);
51	greg	1.1
52			if (argc < 6)
53			goto userror;
54
55			for (i = 6; i < argc; i++)
56			if (!strcmp(argv[i], "-e"))
57	greg	1.7	scompile(argv[++i], NULL, 0);
58	greg	1.1	else if (!strcmp(argv[i], "-f"))
59			fcompile(argv[++i]);
60			else if (!strcmp(argv[i], "-s"))
61			smooth = 1;
62			else
63			goto userror;
64
65			sprintf(stmp, "%s(t)=%s;", ZNAME, argv[3]);
66	greg	1.7	scompile(stmp, NULL, 0);
67	greg	1.1	sprintf(stmp, "%s(t)=%s;", RNAME, argv[4]);
68	greg	1.7	scompile(stmp, NULL, 0);
69	greg	1.1	nseg = atoi(argv[5]);
70			if (nseg <= 0)
71			goto userror;
72	greg	1.3	modname = smooth ? "Phong" : argv[1];
73	greg	1.1
74			printhead(argc, argv);
75	greg	1.6	eclock = 0;
76	greg	1.1
77			lastnz = lastnr = 0.0;
78			t = 0.0;
79			lastz = funvalue(ZNAME, 1, &t);
80			lastr = funvalue(RNAME, 1, &t);
81			t = 1.0/nseg;
82			z = funvalue(ZNAME, 1, &t);
83			r = funvalue(RNAME, 1, &t);
84			computen(&nz, &nr, lastz, lastr, z, r);
85			for (i = 1; i <= nseg; i++) {
86			if (i < nseg) {
87			t = (double)(i+1)/nseg;
88			nextz = funvalue(ZNAME, 1, &t);
89			nextr = funvalue(RNAME, 1, &t);
90			computen(&nextnz, &nextnr, z, r, nextz, nextr);
91			} else
92			nextnz = nextnr = 0.0;
93			orient = 0;
94			if (z < lastz-FTINY)
95			orient \|= DOWN;
96			else if (z > lastz+FTINY)
97			orient \|= UP;
98			if (r < lastr-FTINY)
99			orient \|= IN;
100			else if (r > lastr+FTINY)
101			orient \|= OUT;
102			if (!orient)
103			goto endfor;
104			if (smooth) {
105	greg	1.3	printf("\n%s texfunc Phong\n", argv[1]);
106	greg	1.1	printf("4 rev_dx rev_dy rev_dz rev.cal\n");
107			printf("0\n4\n");
108			if (orient&(UP\|DOWN)) {
109			t = (nextnz - lastnz)/(z - lastz);
110			printf("\t%15.9g\t%15.9g\n",
111			t, lastnz - t*lastz);
112			} else
113			printf("\t0\t%d\n", orient&IN ? 1 : -1);
114			if (orient&(OUT\|IN)) {
115			t = (nextnr - lastnr)/(r - lastr);
116			printf("\t%15.9g\t%15.9g\n",
117			t, lastnr - t*lastr);
118			} else
119			printf("\t0\t%d\n", orient&UP ? 1 : -1);
120			}
121			if (!(orient&(IN\|OUT))) {
122			printf("\n%s %s %s.%d\n", modname,
123			orient&DOWN ? "tube" : "cylinder",
124			argv[2], i);
125			printf("0\n0\n7\n");
126			printf("\t0\t0\t%15.9g\n", lastz);
127			printf("\t0\t0\t%15.9g\n", z);
128			printf("\t%15.9g\n", r);
129			} else if (!(orient&(UP\|DOWN))) {
130			printf("\n%s ring %s.%d\n", modname, argv[2], i);
131			printf("0\n0\n8\n");
132			printf("\t0\t0\t%15.9g\n", z);
133			printf("\t0\t0\t%15.9g\n", orient&IN ? 1.0 : -1.0);
134			printf("\t%15.9g\t%15.9g\n", lastr, r);
135			} else {
136			printf("\n%s %s %s.%d\n", modname,
137			orient&DOWN ? "cup" : "cone",
138			argv[2], i);
139			printf("0\n0\n8\n");
140			printf("\t0\t0\t%15.9g\n", lastz);
141			printf("\t0\t0\t%15.9g\n", z);
142			printf("\t%15.9g\t%15.9g\n", lastr, r);
143			}
144			endfor:
145			lastz = z; lastr = r;
146			z = nextz; r = nextr;
147			lastnz = nz; lastnr = nr;
148			nz = nextnz; nr = nextnr;
149			}
150			quit(0);
151
152			userror:
153			fprintf(stderr,
154			"Usage: %s material name z(t) r(t) nseg [-e expr] [-f file] [-s]\n",
155			argv[0]);
156			quit(1);
157			}
158
159
160			computen(nzp, nrp, z0, r0, z1, r1) /* compute normal */
161			double nzp, nrp, z0, r0, z1, r1;
162			{
163			double dr, dz, len;
164
165			dz = r0 - r1; /* right angle vector */
166			dr = z1 - z0;
167			len = sqrt(drdr + dzdz);
168			*nzp = dz/len;
169			*nrp = dr/len;
170			}
171
172
173	greg	2.4	void
174	greg	1.1	eputs(msg)
175			char *msg;
176			{
177			fputs(msg, stderr);
178			}
179
180
181	greg	2.4	void
182	greg	1.1	wputs(msg)
183			char *msg;
184			{
185			eputs(msg);
186			}
187
188
189	greg	2.4	void
190	greg	1.1	quit(code)
191	greg	2.3	int code;
192	greg	1.1	{
193			exit(code);
194			}
195
196
197			printhead(ac, av) /* print command header */
198			register int ac;
199			register char **av;
200			{
201			putchar('#');
202			while (ac--) {
203			putchar(' ');
204			fputs(*av++, stdout);
205			}
206			putchar('\n');
207			}
208
209
210			double
211			l_hermite()
212			{
213			double t;
214
215			t = argument(5);
216			return( argument(1)((2.0t-3.0)tt+1.0) +
217			argument(2)(-2.0t+3.0)tt +
218			argument(3)((t-2.0)t+1.0)*t +
219			argument(4)(t-1.0)t*t );
220	greg	1.4	}
221
222
223			double
224			l_bezier()
225			{
226			double t;
227
228			t = argument(5);
229			return( argument(1) * (1.+t(-3.+t(3.-t))) +
230			argument(2) * 3.t(1.+t*(-2.+t)) +
231			argument(3) * 3.tt*(1.-t) +
232			argument(4) * ttt );
233	greg	1.5	}
234
235
236			double
237			l_bspline()
238			{
239			double t;
240
241			t = argument(5);
242			return( argument(1) * (1./6.+t(-1./2.+t(1./2.-1./6.*t))) +
243			argument(2) * (2./3.+tt(-1.+1./2.*t)) +
244			argument(3) * (1./6.+t(1./2.+t(1./2.-1./2.*t))) +
245			argument(4) * (1./6.tt*t) );
246	greg	1.1	}