ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/Development/ray/src/gen/genprism.c
(Generate patch)

Comparing ray/src/gen/genprism.c (file contents):
Revision 2.7 by greg, Tue Mar 19 20:59:22 1996 UTC vs.
Revision 2.15 by greg, Thu Aug 14 19:32:00 2025 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1996 Regents of the University of California */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ LBL";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   *  genprism.c - generate a prism.
6   *              2D vertices in the xy plane are given on the
# Line 12 | Line 9 | static char SCCSid[] = "$SunId$ LBL";
9   *              orientation.
10   */
11  
12 < #include  <stdio.h>
13 <
12 > #include  "rtio.h"
13 > #include  "paths.h"
14   #include  <math.h>
18 –
15   #include  <ctype.h>
16  
17   #define  MAXVERT        1024            /* maximum # vertices */
18  
19   #define  FTINY          1e-6
20  
25 – #ifdef  DCL_ATOF
26 – extern double  atof();
27 – #endif
28 –
21   char  *pmtype;          /* material type */
22   char  *pname;           /* name */
23  
# Line 43 | Line 35 | int  do_ends = 1;              /* include end caps */
35   int  iscomplete = 0;            /* polygon is already completed */
36   double  crad = 0.0;             /* radius for corners (sign from lvdir) */
37  
46 – extern double  compute_rounding();
38  
39 <
40 < main(argc, argv)
50 < int  argc;
51 < char  **argv;
39 > void
40 > readverts(char *fname)          /* read vertices from a file */
41   {
42 <        int  an;
54 <        
55 <        if (argc < 4)
56 <                goto userr;
42 >        FILE  *fp;
43  
44 <        pmtype = argv[1];
45 <        pname = argv[2];
46 <
47 <        if (!strcmp(argv[3], "-")) {
48 <                readverts(NULL);
63 <                an = 4;
64 <        } else if (isdigit(argv[3][0])) {
65 <                nverts = atoi(argv[3]);
66 <                if (argc-3 < 2*nverts)
67 <                        goto userr;
68 <                for (an = 0; an < nverts; an++) {
69 <                        vert[an][0] = atof(argv[2*an+4]);
70 <                        vert[an][1] = atof(argv[2*an+5]);
71 <                }
72 <                an = 2*nverts+4;
73 <        } else {
74 <                readverts(argv[3]);
75 <                an = 4;
76 <        }
77 <        if (nverts < 3) {
78 <                fprintf(stderr, "%s: not enough vertices\n", argv[0]);
44 >        if (fname == NULL) {
45 >                fp = stdin;
46 >                fname = "<stdin>";
47 >        } else if ((fp = fopen(fname, "r")) == NULL) {
48 >                fprintf(stderr, "%s: cannot open\n", fname);
49                  exit(1);
50          }
51 <
52 <        for ( ; an < argc; an++) {
83 <                if (argv[an][0] != '-')
84 <                        goto userr;
85 <                switch (argv[an][1]) {
86 <                case 'l':                               /* length vector */
87 <                        lvect[0] = atof(argv[++an]);
88 <                        lvect[1] = atof(argv[++an]);
89 <                        lvect[2] = atof(argv[++an]);
90 <                        if (lvect[2] < -FTINY)
91 <                                lvdir = -1;
92 <                        else if (lvect[2] > FTINY)
93 <                                lvdir = 1;
94 <                        else {
95 <                                fprintf(stderr,
96 <                                        "%s: illegal extrusion vector\n",
97 <                                                argv[0]);
98 <                                exit(1);
99 <                        }
100 <                        llen = sqrt(lvect[0]*lvect[0] + lvect[1]*lvect[1] +
101 <                                        lvect[2]*lvect[2]);
51 >        while (fscanf(fp, "%lf %lf", &vert[nverts][0], &vert[nverts][1]) == 2)
52 >                if (++nverts >= MAXVERT)
53                          break;
54 <                case 'r':                               /* radius */
55 <                        crad = atof(argv[++an]);
56 <                        break;
57 <                case 'e':                               /* ends */
58 <                        do_ends = !do_ends;
59 <                        break;
109 <                case 'c':                               /* complete */
110 <                        iscomplete = !iscomplete;
111 <                        break;
112 <                default:
113 <                        goto userr;
114 <                }
115 <        }
116 <        if (crad > FTINY) {
117 <                if (crad > lvdir*lvect[2]) {
118 <                        fprintf(stderr, "%s: rounding greater than height\n",
119 <                                        argv[0]);
54 >
55 >        if (!feof(fp)) {
56 >                if (nverts < MAXVERT) {
57 >                        fprintf(stderr, "%s: warning - non-numerical data\n", fname);
58 >                } else {
59 >                        fprintf(stderr, "%s: too many vertices\n", fname);
60                          exit(1);
61                  }
122 –                crad *= lvdir;          /* simplifies formulas */
123 –                compute_rounding();
124 –                printhead(argc, argv);
125 –                if (do_ends)
126 –                        printrends();
127 –                printsides(1);
128 –        } else {
129 –                printhead(argc, argv);
130 –                if (do_ends)
131 –                        printends();
132 –                printsides(0);
62          }
63 <        exit(0);
135 < userr:
136 <        fprintf(stderr, "Usage: %s material name ", argv[0]);
137 <        fprintf(stderr, "{ - | vfile | N v1 v2 .. vN } ");
138 <        fprintf(stderr, "[-l lvect][-r radius][-c][-e]\n");
139 <        exit(1);
63 >        fclose(fp);
64   }
65  
66  
67 < readverts(fname)                /* read vertices from a file */
68 < char  *fname;
67 > void
68 > side(int n0, int n1)                    /* print single side */
69   {
70 <        FILE  *fp;
70 >        printf("\n%s polygon %s.%d\n", pmtype, pname, n0+1);
71 >        printf("0\n0\n12\n");
72 >        printf("\t%18.12g\t%18.12g\t%18.12g\n", vert[n0][0],
73 >                        vert[n0][1], 0.0);
74 >        printf("\t%18.12g\t%18.12g\t%18.12g\n", vert[n0][0]+lvect[0],
75 >                        vert[n0][1]+lvect[1], lvect[2]);
76 >        printf("\t%18.12g\t%18.12g\t%18.12g\n", vert[n1][0]+lvect[0],
77 >                        vert[n1][1]+lvect[1], lvect[2]);
78 >        printf("\t%18.12g\t%18.12g\t%18.12g\n", vert[n1][0],
79 >                        vert[n1][1], 0.0);
80 > }
81  
82 <        if (fname == NULL)
83 <                fp = stdin;
84 <        else if ((fp = fopen(fname, "r")) == NULL) {
85 <                fprintf(stderr, "%s: cannot open\n", fname);
86 <                exit(1);
87 <        }
88 <        while (fscanf(fp, "%lf %lf", &vert[nverts][0], &vert[nverts][1]) == 2)
89 <                nverts++;
90 <        fclose(fp);
82 >
83 > void
84 > rside(int n0, int n1)                   /* print side with rounded edge */
85 > {
86 >        double  s, c, t[3];
87 >
88 >                                        /* compute tanget offset vector */
89 >        s = lvdir*(lvect[1]*u[n1][0] - lvect[0]*u[n1][1])/llen;
90 >        if (s < -FTINY || s > FTINY) {
91 >                c = sqrt(1. - s*s);
92 >                t[0] = (c - 1.)*u[n1][1];
93 >                t[1] = (1. - c)*u[n1][0];
94 >                t[2] = s;
95 >        } else
96 >                t[0] = t[1] = t[2] = 0.;
97 >                                        /* output side */
98 >        printf("\n%s polygon %s.%d\n", pmtype, pname, n0+1);
99 >        printf("0\n0\n12\n");
100 >        printf("\t%18.12g\t%18.12g\t%18.12g\n",
101 >                        vert[n0][0] + crad*(t[0] - a[n0]*u[n1][0]),
102 >                        vert[n0][1] + crad*(t[1] - a[n0]*u[n1][1]),
103 >                        crad*(t[2] + 1.));
104 >        printf("\t%18.12g\t%18.12g\t%18.12g\n",
105 >                        vert[n0][0] + lvect[0] + crad*(t[0] - a[n0]*u[n1][0]),
106 >                        vert[n0][1] + lvect[1] + crad*(t[1] - a[n0]*u[n1][1]),
107 >                        lvect[2] + crad*(t[2] - 1.));
108 >        printf("\t%18.12g\t%18.12g\t%18.12g\n",
109 >                        vert[n1][0] + lvect[0] + crad*(t[0] + a[n1]*u[n1][0]),
110 >                        vert[n1][1] + lvect[1] + crad*(t[1] + a[n1]*u[n1][1]),
111 >                        lvect[2] + crad*(t[2] - 1.));
112 >        printf("\t%18.12g\t%18.12g\t%18.12g\n",
113 >                        vert[n1][0] + crad*(t[0] + a[n1]*u[n1][0]),
114 >                        vert[n1][1] + crad*(t[1] + a[n1]*u[n1][1]),
115 >                        crad*(t[2] + 1.));
116 >                                        /* output joining edge */
117 >        if (lvdir*a[n1] < 0.)
118 >                return;
119 >        printf("\n%s cylinder %s.e%d\n", pmtype, pname, n0+1);
120 >        printf("0\n0\n7\n");
121 >        printf("\t%18.12g\t%18.12g\t%18.12g\n",
122 >                vert[n1][0] + crad*(a[n1]*u[n1][0] - u[n1][1]),
123 >                vert[n1][1] + crad*(a[n1]*u[n1][1] + u[n1][0]),
124 >                crad);
125 >        printf("\t%18.12g\t%18.12g\t%18.12g\n",
126 >                vert[n1][0] + lvect[0] + crad*(a[n1]*u[n1][0] - u[n1][1]),
127 >                vert[n1][1] + lvect[1] + crad*(a[n1]*u[n1][1] + u[n1][0]),
128 >                lvect[2] - crad);
129 >        printf("\t%18.12g\n", lvdir*crad);
130   }
131  
132  
133   double
134   compute_rounding()              /* compute vectors for rounding operations */
135   {
136 <        register int  i;
137 <        register double *v0, *v1;
136 >        int  i;
137 >        double  *v0, *v1;
138          double  l, asum;
139  
140          v0 = vert[nverts-1];
# Line 201 | Line 174 | compute_rounding()             /* compute vectors for rounding op
174   }
175  
176  
177 + void
178   printends()                     /* print ends of prism */
179   {
180 <        register int  i;
180 >        int  i;
181                                                  /* bottom face */
182          printf("\n%s polygon %s.b\n", pmtype, pname);
183          printf("0\n0\n%d\n", nverts*3);
# Line 219 | Line 193 | printends()                    /* print ends of prism */
193   }
194  
195  
196 < printrends()                    /* print ends of prism with rounding */
196 > void
197 > printrends()            /* print ends of prism with rounding */
198   {
199 <        register int  i;
199 >        int  i;
200          double  c0[3], c1[3], cl[3];
201                                                  /* bottom face */
202          printf("\n%s polygon %s.b\n", pmtype, pname);
# Line 298 | Line 273 | printrends()                   /* print ends of prism with rounding */
273   }
274  
275  
276 < printsides(round)               /* print prism sides */
277 < int  round;
276 > void
277 > printsides(int round)           /* print prism sides */
278   {
279 <        register int  i;
279 >        int  i;
280  
281          for (i = 0; i < nverts-1; i++)
282                  if (round)
283                          rside(i, i+1);
284                  else
285                          side(i, i+1);
286 <        if (!iscomplete)
286 >        if (!iscomplete) {
287                  if (round)
288                          rside(nverts-1, 0);
289                  else
290                          side(nverts-1, 0);
291 +        }
292   }
293  
294  
295 < side(n0, n1)                    /* print single side */
296 < register int  n0, n1;
295 > int
296 > main(int argc, char **argv)
297   {
298 <        printf("\n%s polygon %s.%d\n", pmtype, pname, n0+1);
299 <        printf("0\n0\n12\n");
300 <        printf("\t%18.12g\t%18.12g\t%18.12g\n", vert[n0][0],
301 <                        vert[n0][1], 0.0);
326 <        printf("\t%18.12g\t%18.12g\t%18.12g\n", vert[n0][0]+lvect[0],
327 <                        vert[n0][1]+lvect[1], lvect[2]);
328 <        printf("\t%18.12g\t%18.12g\t%18.12g\n", vert[n1][0]+lvect[0],
329 <                        vert[n1][1]+lvect[1], lvect[2]);
330 <        printf("\t%18.12g\t%18.12g\t%18.12g\n", vert[n1][0],
331 <                        vert[n1][1], 0.0);
332 < }
298 >        int  an;
299 >        
300 >        if (argc < 4)
301 >                goto userr;
302  
303 +        pmtype = argv[1];
304 +        pname = argv[2];
305  
306 < rside(n0, n1)                   /* print side with rounded edge */
307 < register int  n0, n1;
308 < {
309 <        double  s, c, t[3];
306 >        if (!strcmp(argv[3], "-")) {
307 >                readverts(NULL);
308 >                an = 4;
309 >        } else if (isdigit(argv[3][0])) {
310 >                nverts = atoi(argv[3]);
311 >                if (argc-3 < 2*nverts)
312 >                        goto userr;
313 >                if (nverts > MAXVERT) {
314 >                        fprintf(stderr, "%s: too many vertices\n", argv[0]);
315 >                        return(1);
316 >                }
317 >                for (an = 0; an < nverts; an++) {
318 >                        vert[an][0] = atof(argv[2*an+4]);
319 >                        vert[an][1] = atof(argv[2*an+5]);
320 >                }
321 >                an = 2*nverts+4;
322 >        } else {
323 >                readverts(argv[3]);
324 >                an = 4;
325 >        }
326 >        if (nverts < 3) {
327 >                fprintf(stderr, "%s: not enough vertices\n", argv[0]);
328 >                return(1);
329 >        }
330  
331 <                                        /* compute tanget offset vector */
332 <        s = lvdir*(lvect[1]*u[n1][0] - lvect[0]*u[n1][1])/llen;
333 <        if (s < -FTINY || s > FTINY) {
334 <                c = sqrt(1. - s*s);
335 <                t[0] = (c - 1.)*u[n1][1];
336 <                t[1] = (1. - c)*u[n1][0];
337 <                t[2] = s;
338 <        } else
339 <                t[0] = t[1] = t[2] = 0.;
340 <                                        /* output side */
341 <        printf("\n%s polygon %s.%d\n", pmtype, pname, n0+1);
342 <        printf("0\n0\n12\n");
343 <        printf("\t%18.12g\t%18.12g\t%18.12g\n",
344 <                        vert[n0][0] + crad*(t[0] - a[n0]*u[n1][0]),
345 <                        vert[n0][1] + crad*(t[1] - a[n0]*u[n1][1]),
346 <                        crad*(t[2] + 1.));
347 <        printf("\t%18.12g\t%18.12g\t%18.12g\n",
348 <                        vert[n0][0] + lvect[0] + crad*(t[0] - a[n0]*u[n1][0]),
349 <                        vert[n0][1] + lvect[1] + crad*(t[1] - a[n0]*u[n1][1]),
350 <                        lvect[2] + crad*(t[2] - 1.));
351 <        printf("\t%18.12g\t%18.12g\t%18.12g\n",
352 <                        vert[n1][0] + lvect[0] + crad*(t[0] + a[n1]*u[n1][0]),
353 <                        vert[n1][1] + lvect[1] + crad*(t[1] + a[n1]*u[n1][1]),
354 <                        lvect[2] + crad*(t[2] - 1.));
355 <        printf("\t%18.12g\t%18.12g\t%18.12g\n",
356 <                        vert[n1][0] + crad*(t[0] + a[n1]*u[n1][0]),
357 <                        vert[n1][1] + crad*(t[1] + a[n1]*u[n1][1]),
358 <                        crad*(t[2] + 1.));
359 <                                        /* output joining edge */
360 <        if (lvdir*a[n1] < 0.)
361 <                return;
362 <        printf("\n%s cylinder %s.e%d\n", pmtype, pname, n0+1);
363 <        printf("0\n0\n7\n");
373 <        printf("\t%18.12g\t%18.12g\t%18.12g\n",
374 <                vert[n1][0] + crad*(a[n1]*u[n1][0] - u[n1][1]),
375 <                vert[n1][1] + crad*(a[n1]*u[n1][1] + u[n1][0]),
376 <                crad);
377 <        printf("\t%18.12g\t%18.12g\t%18.12g\n",
378 <                vert[n1][0] + lvect[0] + crad*(a[n1]*u[n1][0] - u[n1][1]),
379 <                vert[n1][1] + lvect[1] + crad*(a[n1]*u[n1][1] + u[n1][0]),
380 <                lvect[2] - crad);
381 <        printf("\t%18.12g\n", lvdir*crad);
382 < }
383 <
384 <
385 < printhead(ac, av)               /* print command header */
386 < register int  ac;
387 < register char  **av;
388 < {
389 <        putchar('#');
390 <        while (ac--) {
391 <                putchar(' ');
392 <                fputs(*av++, stdout);
331 >        for ( ; an < argc; an++) {
332 >                if (argv[an][0] != '-')
333 >                        goto userr;
334 >                switch (argv[an][1]) {
335 >                case 'l':                               /* length vector */
336 >                        lvect[0] = atof(argv[++an]);
337 >                        lvect[1] = atof(argv[++an]);
338 >                        lvect[2] = atof(argv[++an]);
339 >                        if (lvect[2] < -FTINY)
340 >                                lvdir = -1;
341 >                        else if (lvect[2] > FTINY)
342 >                                lvdir = 1;
343 >                        else {
344 >                                fprintf(stderr,
345 >                                        "%s: illegal extrusion vector\n",
346 >                                                argv[0]);
347 >                                return(1);
348 >                        }
349 >                        llen = sqrt(lvect[0]*lvect[0] + lvect[1]*lvect[1] +
350 >                                        lvect[2]*lvect[2]);
351 >                        break;
352 >                case 'r':                               /* radius */
353 >                        crad = atof(argv[++an]);
354 >                        break;
355 >                case 'e':                               /* ends */
356 >                        do_ends = !do_ends;
357 >                        break;
358 >                case 'c':                               /* complete */
359 >                        iscomplete = !iscomplete;
360 >                        break;
361 >                default:
362 >                        goto userr;
363 >                }
364          }
365 <        putchar('\n');
365 >        if (crad > FTINY) {
366 >                if (crad > lvdir*lvect[2]) {
367 >                        fprintf(stderr, "%s: rounding greater than height\n",
368 >                                        argv[0]);
369 >                        return(1);
370 >                }
371 >                crad *= lvdir;          /* simplifies formulas */
372 >                compute_rounding();
373 >                fputs("# ", stdout);
374 >                printargs(argc, argv, stdout);
375 >                if (do_ends)
376 >                        printrends();
377 >                printsides(1);
378 >        } else {
379 >                fputs("# ", stdout);
380 >                printargs(argc, argv, stdout);
381 >                if (do_ends)
382 >                        printends();
383 >                printsides(0);
384 >        }
385 >        return(0);
386 > userr:
387 >        fprintf(stderr, "Usage: %s material name ", argv[0]);
388 >        fprintf(stderr, "{ - | vfile | N v1 v2 .. vN } ");
389 >        fprintf(stderr, "[-l lvect][-r radius][-c][-e]\n");
390 >        return(1);
391   }
392 +

Diff Legend

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