ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/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.13 by greg, Sat Jul 25 19:18:01 2020 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  <stdlib.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  
38 < extern double  compute_rounding();
38 > static double  compute_rounding(void);
39  
40  
41 < main(argc, argv)
42 < int  argc;
51 < char  **argv;
41 > static void
42 > readverts(char *fname)          /* read vertices from a file */
43   {
53 –        int  an;
54 –        
55 –        if (argc < 4)
56 –                goto userr;
57 –
58 –        pmtype = argv[1];
59 –        pname = argv[2];
60 –
61 –        if (!strcmp(argv[3], "-")) {
62 –                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]);
79 –                exit(1);
80 –        }
81 –
82 –        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]);
102 –                        break;
103 –                case 'r':                               /* radius */
104 –                        crad = atof(argv[++an]);
105 –                        break;
106 –                case 'e':                               /* ends */
107 –                        do_ends = !do_ends;
108 –                        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]);
120 –                        exit(1);
121 –                }
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);
133 –        }
134 –        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);
140 – }
141 –
142 –
143 – readverts(fname)                /* read vertices from a file */
144 – char  *fname;
145 – {
44          FILE  *fp;
45  
46          if (fname == NULL)
# Line 157 | Line 55 | char  *fname;
55   }
56  
57  
58 < double
59 < compute_rounding()              /* compute vectors for rounding operations */
58 > static void
59 > side(int n0, int n1)                    /* print single side */
60   {
61 <        register int  i;
62 <        register double *v0, *v1;
61 >        printf("\n%s polygon %s.%d\n", pmtype, pname, n0+1);
62 >        printf("0\n0\n12\n");
63 >        printf("\t%18.12g\t%18.12g\t%18.12g\n", vert[n0][0],
64 >                        vert[n0][1], 0.0);
65 >        printf("\t%18.12g\t%18.12g\t%18.12g\n", vert[n0][0]+lvect[0],
66 >                        vert[n0][1]+lvect[1], lvect[2]);
67 >        printf("\t%18.12g\t%18.12g\t%18.12g\n", vert[n1][0]+lvect[0],
68 >                        vert[n1][1]+lvect[1], lvect[2]);
69 >        printf("\t%18.12g\t%18.12g\t%18.12g\n", vert[n1][0],
70 >                        vert[n1][1], 0.0);
71 > }
72 >
73 >
74 > static void
75 > rside(int n0, int n1)                   /* print side with rounded edge */
76 > {
77 >        double  s, c, t[3];
78 >
79 >                                        /* compute tanget offset vector */
80 >        s = lvdir*(lvect[1]*u[n1][0] - lvect[0]*u[n1][1])/llen;
81 >        if (s < -FTINY || s > FTINY) {
82 >                c = sqrt(1. - s*s);
83 >                t[0] = (c - 1.)*u[n1][1];
84 >                t[1] = (1. - c)*u[n1][0];
85 >                t[2] = s;
86 >        } else
87 >                t[0] = t[1] = t[2] = 0.;
88 >                                        /* output side */
89 >        printf("\n%s polygon %s.%d\n", pmtype, pname, n0+1);
90 >        printf("0\n0\n12\n");
91 >        printf("\t%18.12g\t%18.12g\t%18.12g\n",
92 >                        vert[n0][0] + crad*(t[0] - a[n0]*u[n1][0]),
93 >                        vert[n0][1] + crad*(t[1] - a[n0]*u[n1][1]),
94 >                        crad*(t[2] + 1.));
95 >        printf("\t%18.12g\t%18.12g\t%18.12g\n",
96 >                        vert[n0][0] + lvect[0] + crad*(t[0] - a[n0]*u[n1][0]),
97 >                        vert[n0][1] + lvect[1] + crad*(t[1] - a[n0]*u[n1][1]),
98 >                        lvect[2] + crad*(t[2] - 1.));
99 >        printf("\t%18.12g\t%18.12g\t%18.12g\n",
100 >                        vert[n1][0] + lvect[0] + crad*(t[0] + a[n1]*u[n1][0]),
101 >                        vert[n1][1] + lvect[1] + crad*(t[1] + a[n1]*u[n1][1]),
102 >                        lvect[2] + crad*(t[2] - 1.));
103 >        printf("\t%18.12g\t%18.12g\t%18.12g\n",
104 >                        vert[n1][0] + crad*(t[0] + a[n1]*u[n1][0]),
105 >                        vert[n1][1] + crad*(t[1] + a[n1]*u[n1][1]),
106 >                        crad*(t[2] + 1.));
107 >                                        /* output joining edge */
108 >        if (lvdir*a[n1] < 0.)
109 >                return;
110 >        printf("\n%s cylinder %s.e%d\n", pmtype, pname, n0+1);
111 >        printf("0\n0\n7\n");
112 >        printf("\t%18.12g\t%18.12g\t%18.12g\n",
113 >                vert[n1][0] + crad*(a[n1]*u[n1][0] - u[n1][1]),
114 >                vert[n1][1] + crad*(a[n1]*u[n1][1] + u[n1][0]),
115 >                crad);
116 >        printf("\t%18.12g\t%18.12g\t%18.12g\n",
117 >                vert[n1][0] + lvect[0] + crad*(a[n1]*u[n1][0] - u[n1][1]),
118 >                vert[n1][1] + lvect[1] + crad*(a[n1]*u[n1][1] + u[n1][0]),
119 >                lvect[2] - crad);
120 >        printf("\t%18.12g\n", lvdir*crad);
121 > }
122 >
123 >
124 > static double
125 > compute_rounding(void)          /* compute vectors for rounding operations */
126 > {
127 >        int  i;
128 >        double  *v0, *v1;
129          double  l, asum;
130  
131          v0 = vert[nverts-1];
# Line 201 | Line 165 | compute_rounding()             /* compute vectors for rounding op
165   }
166  
167  
168 < printends()                     /* print ends of prism */
168 > static void
169 > printends(void)                 /* print ends of prism */
170   {
171 <        register int  i;
171 >        int  i;
172                                                  /* bottom face */
173          printf("\n%s polygon %s.b\n", pmtype, pname);
174          printf("0\n0\n%d\n", nverts*3);
# Line 219 | Line 184 | printends()                    /* print ends of prism */
184   }
185  
186  
187 < printrends()                    /* print ends of prism with rounding */
187 > static void
188 > printrends(void)                /* print ends of prism with rounding */
189   {
190 <        register int  i;
190 >        int  i;
191          double  c0[3], c1[3], cl[3];
192                                                  /* bottom face */
193          printf("\n%s polygon %s.b\n", pmtype, pname);
# Line 298 | Line 264 | printrends()                   /* print ends of prism with rounding */
264   }
265  
266  
267 < printsides(round)               /* print prism sides */
268 < int  round;
267 > static void
268 > printsides(int round)           /* print prism sides */
269   {
270 <        register int  i;
270 >        int  i;
271  
272          for (i = 0; i < nverts-1; i++)
273                  if (round)
274                          rside(i, i+1);
275                  else
276                          side(i, i+1);
277 <        if (!iscomplete)
277 >        if (!iscomplete) {
278                  if (round)
279                          rside(nverts-1, 0);
280                  else
281                          side(nverts-1, 0);
282 +        }
283   }
284  
285  
286 < side(n0, n1)                    /* print single side */
287 < register int  n0, n1;
286 > int
287 > main(int argc, char **argv)
288   {
289 <        printf("\n%s polygon %s.%d\n", pmtype, pname, n0+1);
290 <        printf("0\n0\n12\n");
291 <        printf("\t%18.12g\t%18.12g\t%18.12g\n", vert[n0][0],
292 <                        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 < }
289 >        int  an;
290 >        
291 >        if (argc < 4)
292 >                goto userr;
293  
294 +        pmtype = argv[1];
295 +        pname = argv[2];
296  
297 < rside(n0, n1)                   /* print side with rounded edge */
298 < register int  n0, n1;
299 < {
300 <        double  s, c, t[3];
297 >        if (!strcmp(argv[3], "-")) {
298 >                readverts(NULL);
299 >                an = 4;
300 >        } else if (isdigit(argv[3][0])) {
301 >                nverts = atoi(argv[3]);
302 >                if (argc-3 < 2*nverts)
303 >                        goto userr;
304 >                for (an = 0; an < nverts; an++) {
305 >                        vert[an][0] = atof(argv[2*an+4]);
306 >                        vert[an][1] = atof(argv[2*an+5]);
307 >                }
308 >                an = 2*nverts+4;
309 >        } else {
310 >                readverts(argv[3]);
311 >                an = 4;
312 >        }
313 >        if (nverts < 3) {
314 >                fprintf(stderr, "%s: not enough vertices\n", argv[0]);
315 >                exit(1);
316 >        }
317  
318 <                                        /* compute tanget offset vector */
319 <        s = lvdir*(lvect[1]*u[n1][0] - lvect[0]*u[n1][1])/llen;
320 <        if (s < -FTINY || s > FTINY) {
321 <                c = sqrt(1. - s*s);
322 <                t[0] = (c - 1.)*u[n1][1];
323 <                t[1] = (1. - c)*u[n1][0];
324 <                t[2] = s;
325 <        } else
326 <                t[0] = t[1] = t[2] = 0.;
327 <                                        /* output side */
328 <        printf("\n%s polygon %s.%d\n", pmtype, pname, n0+1);
329 <        printf("0\n0\n12\n");
330 <        printf("\t%18.12g\t%18.12g\t%18.12g\n",
331 <                        vert[n0][0] + crad*(t[0] - a[n0]*u[n1][0]),
332 <                        vert[n0][1] + crad*(t[1] - a[n0]*u[n1][1]),
333 <                        crad*(t[2] + 1.));
334 <        printf("\t%18.12g\t%18.12g\t%18.12g\n",
335 <                        vert[n0][0] + lvect[0] + crad*(t[0] - a[n0]*u[n1][0]),
336 <                        vert[n0][1] + lvect[1] + crad*(t[1] - a[n0]*u[n1][1]),
337 <                        lvect[2] + crad*(t[2] - 1.));
338 <        printf("\t%18.12g\t%18.12g\t%18.12g\n",
339 <                        vert[n1][0] + lvect[0] + crad*(t[0] + a[n1]*u[n1][0]),
340 <                        vert[n1][1] + lvect[1] + crad*(t[1] + a[n1]*u[n1][1]),
341 <                        lvect[2] + crad*(t[2] - 1.));
342 <        printf("\t%18.12g\t%18.12g\t%18.12g\n",
343 <                        vert[n1][0] + crad*(t[0] + a[n1]*u[n1][0]),
344 <                        vert[n1][1] + crad*(t[1] + a[n1]*u[n1][1]),
345 <                        crad*(t[2] + 1.));
346 <                                        /* output joining edge */
347 <        if (lvdir*a[n1] < 0.)
348 <                return;
349 <        printf("\n%s cylinder %s.e%d\n", pmtype, pname, n0+1);
350 <        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);
318 >        for ( ; an < argc; an++) {
319 >                if (argv[an][0] != '-')
320 >                        goto userr;
321 >                switch (argv[an][1]) {
322 >                case 'l':                               /* length vector */
323 >                        lvect[0] = atof(argv[++an]);
324 >                        lvect[1] = atof(argv[++an]);
325 >                        lvect[2] = atof(argv[++an]);
326 >                        if (lvect[2] < -FTINY)
327 >                                lvdir = -1;
328 >                        else if (lvect[2] > FTINY)
329 >                                lvdir = 1;
330 >                        else {
331 >                                fprintf(stderr,
332 >                                        "%s: illegal extrusion vector\n",
333 >                                                argv[0]);
334 >                                exit(1);
335 >                        }
336 >                        llen = sqrt(lvect[0]*lvect[0] + lvect[1]*lvect[1] +
337 >                                        lvect[2]*lvect[2]);
338 >                        break;
339 >                case 'r':                               /* radius */
340 >                        crad = atof(argv[++an]);
341 >                        break;
342 >                case 'e':                               /* ends */
343 >                        do_ends = !do_ends;
344 >                        break;
345 >                case 'c':                               /* complete */
346 >                        iscomplete = !iscomplete;
347 >                        break;
348 >                default:
349 >                        goto userr;
350 >                }
351          }
352 <        putchar('\n');
352 >        if (crad > FTINY) {
353 >                if (crad > lvdir*lvect[2]) {
354 >                        fprintf(stderr, "%s: rounding greater than height\n",
355 >                                        argv[0]);
356 >                        exit(1);
357 >                }
358 >                crad *= lvdir;          /* simplifies formulas */
359 >                compute_rounding();
360 >                fputs("# ", stdout);
361 >                printargs(argc, argv, stdout);
362 >                if (do_ends)
363 >                        printrends();
364 >                printsides(1);
365 >        } else {
366 >                fputs("# ", stdout);
367 >                printargs(argc, argv, stdout);
368 >                if (do_ends)
369 >                        printends();
370 >                printsides(0);
371 >        }
372 >        return(0);
373 > userr:
374 >        fprintf(stderr, "Usage: %s material name ", argv[0]);
375 >        fprintf(stderr, "{ - | vfile | N v1 v2 .. vN } ");
376 >        fprintf(stderr, "[-l lvect][-r radius][-c][-e]\n");
377 >        return(1);
378   }
379 +

Diff Legend

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