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.9 by schorsch, Sun Jun 8 12:03:09 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 41 | Line 39 | double  crad = 0.0;            /* radius for corners (sign from
39   extern double  compute_rounding();
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 311 | Line 287 | int  round;
287   }
288  
289  
290 < 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 <
290 > static void
291   printhead(ac, av)               /* print command header */
292   register int  ac;
293   register char  **av;
# Line 388 | Line 299 | register char  **av;
299          }
300          putchar('\n');
301   }
302 +
303 +
304 + main(argc, argv)
305 + int  argc;
306 + char  **argv;
307 + {
308 +        int  an;
309 +        
310 +        if (argc < 4)
311 +                goto userr;
312 +
313 +        pmtype = argv[1];
314 +        pname = argv[2];
315 +
316 +        if (!strcmp(argv[3], "-")) {
317 +                readverts(NULL);
318 +                an = 4;
319 +        } else if (isdigit(argv[3][0])) {
320 +                nverts = atoi(argv[3]);
321 +                if (argc-3 < 2*nverts)
322 +                        goto userr;
323 +                for (an = 0; an < nverts; an++) {
324 +                        vert[an][0] = atof(argv[2*an+4]);
325 +                        vert[an][1] = atof(argv[2*an+5]);
326 +                }
327 +                an = 2*nverts+4;
328 +        } else {
329 +                readverts(argv[3]);
330 +                an = 4;
331 +        }
332 +        if (nverts < 3) {
333 +                fprintf(stderr, "%s: not enough vertices\n", argv[0]);
334 +                exit(1);
335 +        }
336 +
337 +        for ( ; an < argc; an++) {
338 +                if (argv[an][0] != '-')
339 +                        goto userr;
340 +                switch (argv[an][1]) {
341 +                case 'l':                               /* length vector */
342 +                        lvect[0] = atof(argv[++an]);
343 +                        lvect[1] = atof(argv[++an]);
344 +                        lvect[2] = atof(argv[++an]);
345 +                        if (lvect[2] < -FTINY)
346 +                                lvdir = -1;
347 +                        else if (lvect[2] > FTINY)
348 +                                lvdir = 1;
349 +                        else {
350 +                                fprintf(stderr,
351 +                                        "%s: illegal extrusion vector\n",
352 +                                                argv[0]);
353 +                                exit(1);
354 +                        }
355 +                        llen = sqrt(lvect[0]*lvect[0] + lvect[1]*lvect[1] +
356 +                                        lvect[2]*lvect[2]);
357 +                        break;
358 +                case 'r':                               /* radius */
359 +                        crad = atof(argv[++an]);
360 +                        break;
361 +                case 'e':                               /* ends */
362 +                        do_ends = !do_ends;
363 +                        break;
364 +                case 'c':                               /* complete */
365 +                        iscomplete = !iscomplete;
366 +                        break;
367 +                default:
368 +                        goto userr;
369 +                }
370 +        }
371 +        if (crad > FTINY) {
372 +                if (crad > lvdir*lvect[2]) {
373 +                        fprintf(stderr, "%s: rounding greater than height\n",
374 +                                        argv[0]);
375 +                        exit(1);
376 +                }
377 +                crad *= lvdir;          /* simplifies formulas */
378 +                compute_rounding();
379 +                printhead(argc, argv);
380 +                if (do_ends)
381 +                        printrends();
382 +                printsides(1);
383 +        } else {
384 +                printhead(argc, argv);
385 +                if (do_ends)
386 +                        printends();
387 +                printsides(0);
388 +        }
389 +        exit(0);
390 + userr:
391 +        fprintf(stderr, "Usage: %s material name ", argv[0]);
392 +        fprintf(stderr, "{ - | vfile | N v1 v2 .. vN } ");
393 +        fprintf(stderr, "[-l lvect][-r radius][-c][-e]\n");
394 +        exit(1);
395 + }
396 +

Diff Legend

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