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.11 by schorsch, Mon Jul 21 22:30:18 2003 UTC

# Line 10 | Line 10 | static const char      RCSid[] = "$Id$";
10   */
11  
12   #include  <stdio.h>
13 <
13 > #include  <string.h>
14   #include <stdlib.h>
15 –
15   #include  <math.h>
17 –
16   #include  <ctype.h>
17  
18   #define  MAXVERT        1024            /* maximum # vertices */
# Line 38 | Line 36 | int  do_ends = 1;              /* include end caps */
36   int  iscomplete = 0;            /* polygon is already completed */
37   double  crad = 0.0;             /* radius for corners (sign from lvdir) */
38  
39 < extern double  compute_rounding();
39 > static double  compute_rounding(void);
40  
41  
42 < main(argc, argv)
45 < int  argc;
46 < char  **argv;
47 < {
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 <
42 > static void
43   readverts(fname)                /* read vertices from a file */
44   char  *fname;
45   {
# Line 152 | Line 57 | char  *fname;
57   }
58  
59  
60 < double
60 > static void
61 > side(n0, n1)                    /* print single side */
62 > register int  n0, n1;
63 > {
64 >        printf("\n%s polygon %s.%d\n", pmtype, pname, n0+1);
65 >        printf("0\n0\n12\n");
66 >        printf("\t%18.12g\t%18.12g\t%18.12g\n", vert[n0][0],
67 >                        vert[n0][1], 0.0);
68 >        printf("\t%18.12g\t%18.12g\t%18.12g\n", vert[n0][0]+lvect[0],
69 >                        vert[n0][1]+lvect[1], lvect[2]);
70 >        printf("\t%18.12g\t%18.12g\t%18.12g\n", vert[n1][0]+lvect[0],
71 >                        vert[n1][1]+lvect[1], lvect[2]);
72 >        printf("\t%18.12g\t%18.12g\t%18.12g\n", vert[n1][0],
73 >                        vert[n1][1], 0.0);
74 > }
75 >
76 >
77 > static void
78 > rside(n0, n1)                   /* print side with rounded edge */
79 > register int  n0, n1;
80 > {
81 >        double  s, c, t[3];
82 >
83 >                                        /* compute tanget offset vector */
84 >        s = lvdir*(lvect[1]*u[n1][0] - lvect[0]*u[n1][1])/llen;
85 >        if (s < -FTINY || s > FTINY) {
86 >                c = sqrt(1. - s*s);
87 >                t[0] = (c - 1.)*u[n1][1];
88 >                t[1] = (1. - c)*u[n1][0];
89 >                t[2] = s;
90 >        } else
91 >                t[0] = t[1] = t[2] = 0.;
92 >                                        /* output side */
93 >        printf("\n%s polygon %s.%d\n", pmtype, pname, n0+1);
94 >        printf("0\n0\n12\n");
95 >        printf("\t%18.12g\t%18.12g\t%18.12g\n",
96 >                        vert[n0][0] + crad*(t[0] - a[n0]*u[n1][0]),
97 >                        vert[n0][1] + crad*(t[1] - a[n0]*u[n1][1]),
98 >                        crad*(t[2] + 1.));
99 >        printf("\t%18.12g\t%18.12g\t%18.12g\n",
100 >                        vert[n0][0] + lvect[0] + crad*(t[0] - a[n0]*u[n1][0]),
101 >                        vert[n0][1] + lvect[1] + crad*(t[1] - a[n0]*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] + lvect[0] + crad*(t[0] + a[n1]*u[n1][0]),
105 >                        vert[n1][1] + lvect[1] + crad*(t[1] + a[n1]*u[n1][1]),
106 >                        lvect[2] + crad*(t[2] - 1.));
107 >        printf("\t%18.12g\t%18.12g\t%18.12g\n",
108 >                        vert[n1][0] + crad*(t[0] + a[n1]*u[n1][0]),
109 >                        vert[n1][1] + crad*(t[1] + a[n1]*u[n1][1]),
110 >                        crad*(t[2] + 1.));
111 >                                        /* output joining edge */
112 >        if (lvdir*a[n1] < 0.)
113 >                return;
114 >        printf("\n%s cylinder %s.e%d\n", pmtype, pname, n0+1);
115 >        printf("0\n0\n7\n");
116 >        printf("\t%18.12g\t%18.12g\t%18.12g\n",
117 >                vert[n1][0] + crad*(a[n1]*u[n1][0] - u[n1][1]),
118 >                vert[n1][1] + crad*(a[n1]*u[n1][1] + u[n1][0]),
119 >                crad);
120 >        printf("\t%18.12g\t%18.12g\t%18.12g\n",
121 >                vert[n1][0] + lvect[0] + crad*(a[n1]*u[n1][0] - u[n1][1]),
122 >                vert[n1][1] + lvect[1] + crad*(a[n1]*u[n1][1] + u[n1][0]),
123 >                lvect[2] - crad);
124 >        printf("\t%18.12g\n", lvdir*crad);
125 > }
126 >
127 >
128 > static double
129   compute_rounding()              /* compute vectors for rounding operations */
130   {
131          register int  i;
# Line 196 | Line 169 | compute_rounding()             /* compute vectors for rounding op
169   }
170  
171  
172 + static void
173   printends()                     /* print ends of prism */
174   {
175          register int  i;
# Line 214 | Line 188 | printends()                    /* print ends of prism */
188   }
189  
190  
191 + static void
192   printrends()                    /* print ends of prism with rounding */
193   {
194          register int  i;
# Line 293 | Line 268 | printrends()                   /* print ends of prism with rounding */
268   }
269  
270  
271 + static void
272   printsides(round)               /* print prism sides */
273   int  round;
274   {
# Line 303 | Line 279 | int  round;
279                          rside(i, i+1);
280                  else
281                          side(i, i+1);
282 <        if (!iscomplete)
282 >        if (!iscomplete) {
283                  if (round)
284                          rside(nverts-1, 0);
285                  else
286                          side(nverts-1, 0);
287 +        }
288   }
289  
290  
291 < side(n0, n1)                    /* print single side */
315 < register int  n0, n1;
316 < {
317 <        printf("\n%s polygon %s.%d\n", pmtype, pname, n0+1);
318 <        printf("0\n0\n12\n");
319 <        printf("\t%18.12g\t%18.12g\t%18.12g\n", vert[n0][0],
320 <                        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 < }
328 <
329 <
330 < rside(n0, n1)                   /* print side with rounded edge */
331 < register int  n0, n1;
332 < {
333 <        double  s, c, t[3];
334 <
335 <                                        /* compute tanget offset vector */
336 <        s = lvdir*(lvect[1]*u[n1][0] - lvect[0]*u[n1][1])/llen;
337 <        if (s < -FTINY || s > FTINY) {
338 <                c = sqrt(1. - s*s);
339 <                t[0] = (c - 1.)*u[n1][1];
340 <                t[1] = (1. - c)*u[n1][0];
341 <                t[2] = s;
342 <        } else
343 <                t[0] = t[1] = t[2] = 0.;
344 <                                        /* output side */
345 <        printf("\n%s polygon %s.%d\n", pmtype, pname, n0+1);
346 <        printf("0\n0\n12\n");
347 <        printf("\t%18.12g\t%18.12g\t%18.12g\n",
348 <                        vert[n0][0] + crad*(t[0] - a[n0]*u[n1][0]),
349 <                        vert[n0][1] + crad*(t[1] - a[n0]*u[n1][1]),
350 <                        crad*(t[2] + 1.));
351 <        printf("\t%18.12g\t%18.12g\t%18.12g\n",
352 <                        vert[n0][0] + lvect[0] + crad*(t[0] - a[n0]*u[n1][0]),
353 <                        vert[n0][1] + lvect[1] + crad*(t[1] - a[n0]*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] + lvect[0] + crad*(t[0] + a[n1]*u[n1][0]),
357 <                        vert[n1][1] + lvect[1] + crad*(t[1] + a[n1]*u[n1][1]),
358 <                        lvect[2] + crad*(t[2] - 1.));
359 <        printf("\t%18.12g\t%18.12g\t%18.12g\n",
360 <                        vert[n1][0] + crad*(t[0] + a[n1]*u[n1][0]),
361 <                        vert[n1][1] + crad*(t[1] + a[n1]*u[n1][1]),
362 <                        crad*(t[2] + 1.));
363 <                                        /* output joining edge */
364 <        if (lvdir*a[n1] < 0.)
365 <                return;
366 <        printf("\n%s cylinder %s.e%d\n", pmtype, pname, n0+1);
367 <        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 <
291 > static void
292   printhead(ac, av)               /* print command header */
293   register int  ac;
294   register char  **av;
# Line 388 | Line 300 | register char  **av;
300          }
301          putchar('\n');
302   }
303 +
304 +
305 + main(argc, argv)
306 + int  argc;
307 + char  **argv;
308 + {
309 +        int  an;
310 +        
311 +        if (argc < 4)
312 +                goto userr;
313 +
314 +        pmtype = argv[1];
315 +        pname = argv[2];
316 +
317 +        if (!strcmp(argv[3], "-")) {
318 +                readverts(NULL);
319 +                an = 4;
320 +        } else if (isdigit(argv[3][0])) {
321 +                nverts = atoi(argv[3]);
322 +                if (argc-3 < 2*nverts)
323 +                        goto userr;
324 +                for (an = 0; an < nverts; an++) {
325 +                        vert[an][0] = atof(argv[2*an+4]);
326 +                        vert[an][1] = atof(argv[2*an+5]);
327 +                }
328 +                an = 2*nverts+4;
329 +        } else {
330 +                readverts(argv[3]);
331 +                an = 4;
332 +        }
333 +        if (nverts < 3) {
334 +                fprintf(stderr, "%s: not enough vertices\n", argv[0]);
335 +                exit(1);
336 +        }
337 +
338 +        for ( ; an < argc; an++) {
339 +                if (argv[an][0] != '-')
340 +                        goto userr;
341 +                switch (argv[an][1]) {
342 +                case 'l':                               /* length vector */
343 +                        lvect[0] = atof(argv[++an]);
344 +                        lvect[1] = atof(argv[++an]);
345 +                        lvect[2] = atof(argv[++an]);
346 +                        if (lvect[2] < -FTINY)
347 +                                lvdir = -1;
348 +                        else if (lvect[2] > FTINY)
349 +                                lvdir = 1;
350 +                        else {
351 +                                fprintf(stderr,
352 +                                        "%s: illegal extrusion vector\n",
353 +                                                argv[0]);
354 +                                exit(1);
355 +                        }
356 +                        llen = sqrt(lvect[0]*lvect[0] + lvect[1]*lvect[1] +
357 +                                        lvect[2]*lvect[2]);
358 +                        break;
359 +                case 'r':                               /* radius */
360 +                        crad = atof(argv[++an]);
361 +                        break;
362 +                case 'e':                               /* ends */
363 +                        do_ends = !do_ends;
364 +                        break;
365 +                case 'c':                               /* complete */
366 +                        iscomplete = !iscomplete;
367 +                        break;
368 +                default:
369 +                        goto userr;
370 +                }
371 +        }
372 +        if (crad > FTINY) {
373 +                if (crad > lvdir*lvect[2]) {
374 +                        fprintf(stderr, "%s: rounding greater than height\n",
375 +                                        argv[0]);
376 +                        exit(1);
377 +                }
378 +                crad *= lvdir;          /* simplifies formulas */
379 +                compute_rounding();
380 +                printhead(argc, argv);
381 +                if (do_ends)
382 +                        printrends();
383 +                printsides(1);
384 +        } else {
385 +                printhead(argc, argv);
386 +                if (do_ends)
387 +                        printends();
388 +                printsides(0);
389 +        }
390 +        exit(0);
391 + userr:
392 +        fprintf(stderr, "Usage: %s material name ", argv[0]);
393 +        fprintf(stderr, "{ - | vfile | N v1 v2 .. vN } ");
394 +        fprintf(stderr, "[-l lvect][-r radius][-c][-e]\n");
395 +        exit(1);
396 + }
397 +

Diff Legend

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