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.11 by schorsch, Mon Jul 21 22:30:18 2003 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 13 | Line 10 | static char SCCSid[] = "$SunId$ LBL";
10   */
11  
12   #include  <stdio.h>
13 <
13 > #include  <string.h>
14 > #include <stdlib.h>
15   #include  <math.h>
18 –
16   #include  <ctype.h>
17  
18   #define  MAXVERT        1024            /* maximum # vertices */
19  
20   #define  FTINY          1e-6
21  
25 – #ifdef  DCL_ATOF
26 – extern double  atof();
27 – #endif
28 –
22   char  *pmtype;          /* material type */
23   char  *pname;           /* name */
24  
# Line 43 | 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)
50 < int  argc;
51 < char  **argv;
52 < {
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 <
42 > static void
43   readverts(fname)                /* read vertices from a file */
44   char  *fname;
45   {
# Line 157 | 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 201 | 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 219 | 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 298 | 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 308 | 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 */
320 < register int  n0, n1;
321 < {
322 <        printf("\n%s polygon %s.%d\n", pmtype, pname, n0+1);
323 <        printf("0\n0\n12\n");
324 <        printf("\t%18.12g\t%18.12g\t%18.12g\n", vert[n0][0],
325 <                        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 < }
333 <
334 <
335 < rside(n0, n1)                   /* print side with rounded edge */
336 < register int  n0, n1;
337 < {
338 <        double  s, c, t[3];
339 <
340 <                                        /* compute tanget offset vector */
341 <        s = lvdir*(lvect[1]*u[n1][0] - lvect[0]*u[n1][1])/llen;
342 <        if (s < -FTINY || s > FTINY) {
343 <                c = sqrt(1. - s*s);
344 <                t[0] = (c - 1.)*u[n1][1];
345 <                t[1] = (1. - c)*u[n1][0];
346 <                t[2] = s;
347 <        } else
348 <                t[0] = t[1] = t[2] = 0.;
349 <                                        /* output side */
350 <        printf("\n%s polygon %s.%d\n", pmtype, pname, n0+1);
351 <        printf("0\n0\n12\n");
352 <        printf("\t%18.12g\t%18.12g\t%18.12g\n",
353 <                        vert[n0][0] + crad*(t[0] - a[n0]*u[n1][0]),
354 <                        vert[n0][1] + crad*(t[1] - a[n0]*u[n1][1]),
355 <                        crad*(t[2] + 1.));
356 <        printf("\t%18.12g\t%18.12g\t%18.12g\n",
357 <                        vert[n0][0] + lvect[0] + crad*(t[0] - a[n0]*u[n1][0]),
358 <                        vert[n0][1] + lvect[1] + crad*(t[1] - a[n0]*u[n1][1]),
359 <                        lvect[2] + crad*(t[2] - 1.));
360 <        printf("\t%18.12g\t%18.12g\t%18.12g\n",
361 <                        vert[n1][0] + lvect[0] + crad*(t[0] + a[n1]*u[n1][0]),
362 <                        vert[n1][1] + lvect[1] + crad*(t[1] + a[n1]*u[n1][1]),
363 <                        lvect[2] + crad*(t[2] - 1.));
364 <        printf("\t%18.12g\t%18.12g\t%18.12g\n",
365 <                        vert[n1][0] + crad*(t[0] + a[n1]*u[n1][0]),
366 <                        vert[n1][1] + crad*(t[1] + a[n1]*u[n1][1]),
367 <                        crad*(t[2] + 1.));
368 <                                        /* output joining edge */
369 <        if (lvdir*a[n1] < 0.)
370 <                return;
371 <        printf("\n%s cylinder %s.e%d\n", pmtype, pname, n0+1);
372 <        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 <
291 > static void
292   printhead(ac, av)               /* print command header */
293   register int  ac;
294   register char  **av;
# Line 393 | 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