src/gen/genrev.c

#ifndef lint
static const char       RCSid[] = "$Id: genrev.c,v 2.16 2025/04/18 23:02:53 greg Exp $";
#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  <stdlib.h>
#include  <math.h>

#include  "rtio.h"
#include  "rterror.h"
#include  "resolu.h"
#include  "calcomp.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


void
computen(                       /* compute normal */
        double  *nzp,
        double  *nrp,
        double z0,
        double r0,
        double z1,
        double 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;
}


double
l_hermite(char *nm)
{
        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(char *nm)
{
        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(char *nm)
{
        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) );
}


int
main(
        int  argc,
        char  *argv[]
)
{
        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;

        esupport |= E_VARIABLE|E_FUNCTION|E_RCONST;
        esupport &= ~(E_OUTCHAN|E_INCHAN);
        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")) {
                        char  *fpath = getpath(argv[++i], getrlibpath(), 0);
                        if (fpath == NULL) {
                                fprintf(stderr, "%s: cannot find file '%s'\n",
                                                argv[0], argv[i]);
                                quit(1);
                        }
                        fcompile(fpath);
                } 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 = eval(argv[5]) + .5;
        if (nseg <= 0)
                goto userror;
        modname = smooth ? "Phong" : argv[1];

        fputs("# ", stdout);
        printargs(argc, argv, stdout);
        doptimize(1);
        eclock++;

        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%18.12g\t%18.12g\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%18.12g\t%18.12g\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%18.12g\n", lastz);
                        printf("\t0\t0\t%18.12g\n", z);
                        printf("\t%18.12g\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%18.12g\n", z);
                        printf("\t0\t0\t%18.12g\n", orient&IN ? 1.0 : -1.0);
                        printf("\t%18.12g\t%18.12g\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%18.12g\n", lastz);
                        printf("\t0\t0\t%18.12g\n", z);
                        printf("\t%18.12g\t%18.12g\n", lastr, r);
                }
        endfor:
                lastz = z; lastr = r;
                z = nextz; r = nextr;
                lastnz = nz; lastnr = nr;
                nz = nextnz; nr = nextnr;
        }
        return 0;

userror:
        fprintf(stderr,
        "Usage: %s material name z(t) r(t) nseg [-e expr] [-f file] [-s]\n",
                        argv[0]);
        return 1;
}
Revision:	2.17
Committed:	Wed Apr 23 01:57:04 2025 UTC (10 days, 20 hours ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 2.16:	+13 -8 lines
Log Message:	fix: Functio prototypes and other fixes to reduce compiler warnings
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.17	static const char RCSid[] = "$Id: genrev.c,v 2.16 2025/04/18 23:02:53 greg Exp $";
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	schorsch	2.5	#include <stdlib.h>
15	greg	2.2	#include <math.h>
16	schorsch	2.7
17	greg	2.12	#include "rtio.h"
18	schorsch	2.7	#include "rterror.h"
19	greg	2.8	#include "resolu.h"
20	greg	2.6	#include "calcomp.h"
21	greg	1.1
22	greg	1.10	#define ZNAME "Z`SYS`" /* z function name */
23			#define RNAME "R`SYS`" /* r function name */
24	greg	1.1
25			#define PI 3.14159265358979323846
26
27			#define FTINY 1e-9
28			/* orientation */
29			#define OUT 01
30			#define IN 02
31			#define UP 04
32			#define DOWN 010
33
34
35	schorsch	2.7	void
36	greg	2.17	computen( /* compute normal */
37			double *nzp,
38			double *nrp,
39			double z0,
40			double r0,
41			double z1,
42			double r1
43			)
44	schorsch	2.5	{
45			double dr, dz, len;
46
47			dz = r0 - r1; /* right angle vector */
48			dr = z1 - z0;
49			len = sqrt(drdr + dzdz);
50			*nzp = dz/len;
51			*nrp = dr/len;
52			}
53
54
55			double
56	greg	2.6	l_hermite(char *nm)
57	schorsch	2.5	{
58			double t;
59
60			t = argument(5);
61			return( argument(1)((2.0t-3.0)tt+1.0) +
62			argument(2)(-2.0t+3.0)tt +
63			argument(3)((t-2.0)t+1.0)*t +
64			argument(4)(t-1.0)t*t );
65			}
66
67
68			double
69	greg	2.6	l_bezier(char *nm)
70	schorsch	2.5	{
71			double t;
72
73			t = argument(5);
74			return( argument(1) * (1.+t(-3.+t(3.-t))) +
75			argument(2) * 3.t(1.+t*(-2.+t)) +
76			argument(3) * 3.tt*(1.-t) +
77			argument(4) * ttt );
78			}
79
80
81			double
82	greg	2.6	l_bspline(char *nm)
83	schorsch	2.5	{
84			double t;
85
86			t = argument(5);
87			return( argument(1) * (1./6.+t(-1./2.+t(1./2.-1./6.*t))) +
88			argument(2) * (2./3.+tt(-1.+1./2.*t)) +
89			argument(3) * (1./6.+t(1./2.+t(1./2.-1./2.*t))) +
90			argument(4) * (1./6.tt*t) );
91			}
92
93
94	schorsch	2.7	int
95	greg	2.17	main(
96			int argc,
97			char *argv[]
98			)
99	greg	1.1	{
100			char stmp[256];
101			char *modname;
102			int smooth = 0;
103			double t, lastz, z, nextz, lastr, r, nextr;
104			double lastnz, lastnr, nz, nr, nextnz, nextnr;
105			int i, nseg;
106			int orient;
107
108	greg	2.11	esupport \|= E_VARIABLE\|E_FUNCTION\|E_RCONST;
109			esupport &= ~(E_OUTCHAN\|E_INCHAN);
110	greg	1.8	varset("PI", ':', PI);
111	greg	1.9	funset("hermite", 5, ':', l_hermite);
112			funset("bezier", 5, ':', l_bezier);
113			funset("bspline", 5, ':', l_bspline);
114	greg	1.1
115			if (argc < 6)
116			goto userror;
117
118			for (i = 6; i < argc; i++)
119			if (!strcmp(argv[i], "-e"))
120	greg	1.7	scompile(argv[++i], NULL, 0);
121	greg	2.12	else if (!strcmp(argv[i], "-f")) {
122			char *fpath = getpath(argv[++i], getrlibpath(), 0);
123			if (fpath == NULL) {
124			fprintf(stderr, "%s: cannot find file '%s'\n",
125			argv[0], argv[i]);
126			quit(1);
127			}
128			fcompile(fpath);
129			} else if (!strcmp(argv[i], "-s"))
130	greg	1.1	smooth = 1;
131			else
132			goto userror;
133
134			sprintf(stmp, "%s(t)=%s;", ZNAME, argv[3]);
135	greg	1.7	scompile(stmp, NULL, 0);
136	greg	1.1	sprintf(stmp, "%s(t)=%s;", RNAME, argv[4]);
137	greg	1.7	scompile(stmp, NULL, 0);
138	greg	2.13	nseg = eval(argv[5]) + .5;
139	greg	1.1	if (nseg <= 0)
140			goto userror;
141	greg	1.3	modname = smooth ? "Phong" : argv[1];
142	greg	1.1
143	greg	2.8	fputs("# ", stdout);
144			printargs(argc, argv, stdout);
145	greg	2.16	doptimize(1);
146			eclock++;
147	greg	1.1
148			lastnz = lastnr = 0.0;
149			t = 0.0;
150			lastz = funvalue(ZNAME, 1, &t);
151			lastr = funvalue(RNAME, 1, &t);
152			t = 1.0/nseg;
153			z = funvalue(ZNAME, 1, &t);
154			r = funvalue(RNAME, 1, &t);
155			computen(&nz, &nr, lastz, lastr, z, r);
156			for (i = 1; i <= nseg; i++) {
157			if (i < nseg) {
158			t = (double)(i+1)/nseg;
159			nextz = funvalue(ZNAME, 1, &t);
160			nextr = funvalue(RNAME, 1, &t);
161			computen(&nextnz, &nextnr, z, r, nextz, nextr);
162			} else
163			nextnz = nextnr = 0.0;
164			orient = 0;
165			if (z < lastz-FTINY)
166			orient \|= DOWN;
167			else if (z > lastz+FTINY)
168			orient \|= UP;
169			if (r < lastr-FTINY)
170			orient \|= IN;
171			else if (r > lastr+FTINY)
172			orient \|= OUT;
173			if (!orient)
174			goto endfor;
175			if (smooth) {
176	greg	1.3	printf("\n%s texfunc Phong\n", argv[1]);
177	greg	1.1	printf("4 rev_dx rev_dy rev_dz rev.cal\n");
178			printf("0\n4\n");
179			if (orient&(UP\|DOWN)) {
180			t = (nextnz - lastnz)/(z - lastz);
181	greg	2.9	printf("\t%18.12g\t%18.12g\n",
182	greg	1.1	t, lastnz - t*lastz);
183			} else
184			printf("\t0\t%d\n", orient&IN ? 1 : -1);
185			if (orient&(OUT\|IN)) {
186			t = (nextnr - lastnr)/(r - lastr);
187	greg	2.9	printf("\t%18.12g\t%18.12g\n",
188	greg	1.1	t, lastnr - t*lastr);
189			} else
190			printf("\t0\t%d\n", orient&UP ? 1 : -1);
191			}
192			if (!(orient&(IN\|OUT))) {
193			printf("\n%s %s %s.%d\n", modname,
194			orient&DOWN ? "tube" : "cylinder",
195			argv[2], i);
196			printf("0\n0\n7\n");
197	greg	2.9	printf("\t0\t0\t%18.12g\n", lastz);
198			printf("\t0\t0\t%18.12g\n", z);
199			printf("\t%18.12g\n", r);
200	greg	1.1	} else if (!(orient&(UP\|DOWN))) {
201			printf("\n%s ring %s.%d\n", modname, argv[2], i);
202			printf("0\n0\n8\n");
203	greg	2.9	printf("\t0\t0\t%18.12g\n", z);
204			printf("\t0\t0\t%18.12g\n", orient&IN ? 1.0 : -1.0);
205			printf("\t%18.12g\t%18.12g\n", lastr, r);
206	greg	1.1	} else {
207			printf("\n%s %s %s.%d\n", modname,
208			orient&DOWN ? "cup" : "cone",
209			argv[2], i);
210			printf("0\n0\n8\n");
211	greg	2.9	printf("\t0\t0\t%18.12g\n", lastz);
212			printf("\t0\t0\t%18.12g\n", z);
213			printf("\t%18.12g\t%18.12g\n", lastr, r);
214	greg	1.1	}
215			endfor:
216			lastz = z; lastr = r;
217			z = nextz; r = nextr;
218			lastnz = nz; lastnr = nr;
219			nz = nextnz; nr = nextnr;
220			}
221	schorsch	2.7	return 0;
222	greg	1.1
223			userror:
224			fprintf(stderr,
225			"Usage: %s material name z(t) r(t) nseg [-e expr] [-f file] [-s]\n",
226			argv[0]);
227	schorsch	2.7	return 1;
228	greg	1.1	}