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.8 by greg, Sat Feb 22 02:07:23 2003 UTC vs.
Revision 2.13 by greg, Sat Jul 25 19:18:01 2020 UTC

# Line 9 | Line 9 | static const char      RCSid[] = "$Id$";
9   *              orientation.
10   */
11  
12 < #include  <stdio.h>
13 <
14 < #include <stdlib.h>
15 <
12 > #include  "rtio.h"
13 > #include  <stdlib.h>
14   #include  <math.h>
17 –
15   #include  <ctype.h>
16  
17   #define  MAXVERT        1024            /* maximum # vertices */
# Line 38 | 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;
46 < char  **argv;
41 > static void
42 > readverts(char *fname)          /* read vertices from a file */
43   {
48 –        int  an;
49 –        
50 –        if (argc < 4)
51 –                goto userr;
52 –
53 –        pmtype = argv[1];
54 –        pname = argv[2];
55 –
56 –        if (!strcmp(argv[3], "-")) {
57 –                readverts(NULL);
58 –                an = 4;
59 –        } else if (isdigit(argv[3][0])) {
60 –                nverts = atoi(argv[3]);
61 –                if (argc-3 < 2*nverts)
62 –                        goto userr;
63 –                for (an = 0; an < nverts; an++) {
64 –                        vert[an][0] = atof(argv[2*an+4]);
65 –                        vert[an][1] = atof(argv[2*an+5]);
66 –                }
67 –                an = 2*nverts+4;
68 –        } else {
69 –                readverts(argv[3]);
70 –                an = 4;
71 –        }
72 –        if (nverts < 3) {
73 –                fprintf(stderr, "%s: not enough vertices\n", argv[0]);
74 –                exit(1);
75 –        }
76 –
77 –        for ( ; an < argc; an++) {
78 –                if (argv[an][0] != '-')
79 –                        goto userr;
80 –                switch (argv[an][1]) {
81 –                case 'l':                               /* length vector */
82 –                        lvect[0] = atof(argv[++an]);
83 –                        lvect[1] = atof(argv[++an]);
84 –                        lvect[2] = atof(argv[++an]);
85 –                        if (lvect[2] < -FTINY)
86 –                                lvdir = -1;
87 –                        else if (lvect[2] > FTINY)
88 –                                lvdir = 1;
89 –                        else {
90 –                                fprintf(stderr,
91 –                                        "%s: illegal extrusion vector\n",
92 –                                                argv[0]);
93 –                                exit(1);
94 –                        }
95 –                        llen = sqrt(lvect[0]*lvect[0] + lvect[1]*lvect[1] +
96 –                                        lvect[2]*lvect[2]);
97 –                        break;
98 –                case 'r':                               /* radius */
99 –                        crad = atof(argv[++an]);
100 –                        break;
101 –                case 'e':                               /* ends */
102 –                        do_ends = !do_ends;
103 –                        break;
104 –                case 'c':                               /* complete */
105 –                        iscomplete = !iscomplete;
106 –                        break;
107 –                default:
108 –                        goto userr;
109 –                }
110 –        }
111 –        if (crad > FTINY) {
112 –                if (crad > lvdir*lvect[2]) {
113 –                        fprintf(stderr, "%s: rounding greater than height\n",
114 –                                        argv[0]);
115 –                        exit(1);
116 –                }
117 –                crad *= lvdir;          /* simplifies formulas */
118 –                compute_rounding();
119 –                printhead(argc, argv);
120 –                if (do_ends)
121 –                        printrends();
122 –                printsides(1);
123 –        } else {
124 –                printhead(argc, argv);
125 –                if (do_ends)
126 –                        printends();
127 –                printsides(0);
128 –        }
129 –        exit(0);
130 – userr:
131 –        fprintf(stderr, "Usage: %s material name ", argv[0]);
132 –        fprintf(stderr, "{ - | vfile | N v1 v2 .. vN } ");
133 –        fprintf(stderr, "[-l lvect][-r radius][-c][-e]\n");
134 –        exit(1);
135 – }
136 –
137 –
138 – readverts(fname)                /* read vertices from a file */
139 – char  *fname;
140 – {
44          FILE  *fp;
45  
46          if (fname == NULL)
# Line 152 | 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 196 | 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 214 | 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 293 | 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);
321 <        printf("\t%18.12g\t%18.12g\t%18.12g\n", vert[n0][0]+lvect[0],
322 <                        vert[n0][1]+lvect[1], lvect[2]);
323 <        printf("\t%18.12g\t%18.12g\t%18.12g\n", vert[n1][0]+lvect[0],
324 <                        vert[n1][1]+lvect[1], lvect[2]);
325 <        printf("\t%18.12g\t%18.12g\t%18.12g\n", vert[n1][0],
326 <                        vert[n1][1], 0.0);
327 < }
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");
368 <        printf("\t%18.12g\t%18.12g\t%18.12g\n",
369 <                vert[n1][0] + crad*(a[n1]*u[n1][0] - u[n1][1]),
370 <                vert[n1][1] + crad*(a[n1]*u[n1][1] + u[n1][0]),
371 <                crad);
372 <        printf("\t%18.12g\t%18.12g\t%18.12g\n",
373 <                vert[n1][0] + lvect[0] + crad*(a[n1]*u[n1][0] - u[n1][1]),
374 <                vert[n1][1] + lvect[1] + crad*(a[n1]*u[n1][1] + u[n1][0]),
375 <                lvect[2] - crad);
376 <        printf("\t%18.12g\n", lvdir*crad);
377 < }
378 <
379 <
380 < printhead(ac, av)               /* print command header */
381 < register int  ac;
382 < register char  **av;
383 < {
384 <        putchar('#');
385 <        while (ac--) {
386 <                putchar(' ');
387 <                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