ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/cv/mgf2rad.c
Revision: 2.22
Committed: Thu Jun 6 11:49:53 1996 UTC (27 years, 9 months ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.21: +3 -1 lines
Log Message:
bug fix in r_ies() associated with IES file pathnames

File Contents

# Content
1 /* Copyright (c) 1996 Regents of the University of California */
2
3 #ifndef lint
4 static char SCCSid[] = "$SunId$ LBL";
5 #endif
6
7 /*
8 * Convert MGF (Materials and Geometry Format) to Radiance
9 */
10
11 #include <stdio.h>
12 #include <math.h>
13 #include <string.h>
14 #include "mgflib/parser.h"
15 #include "color.h"
16 #include "tmesh.h"
17
18 #define putv(v) printf("%18.12g %18.12g %18.12g\n",(v)[0],(v)[1],(v)[2])
19
20 #define invert (xf_context != NULL && xf_context->rev)
21
22 double glowdist = FHUGE; /* glow test distance */
23
24 double emult = 1.; /* emitter multiplier */
25
26 FILE *matfp = stdout; /* material output file */
27
28 int r_comment(), r_cone(), r_cyl(), r_face(), r_ies(), r_ring(), r_sph();
29 char *material(), *object(), *addarg();
30
31
32 main(argc, argv) /* convert files to stdout */
33 int argc;
34 char *argv[];
35 {
36 int i;
37 /* print out parser version */
38 printf("## Translated from MGF Version %d.%d\n", MG_VMAJOR, MG_VMINOR);
39 /* initialize dispatch table */
40 mg_ehand[MG_E_COMMENT] = r_comment; /* we pass comments */
41 mg_ehand[MG_E_COLOR] = c_hcolor; /* they get color */
42 mg_ehand[MG_E_CONE] = r_cone; /* we do cones */
43 mg_ehand[MG_E_CMIX] = c_hcolor; /* they mix colors */
44 mg_ehand[MG_E_CSPEC] = c_hcolor; /* they get spectra */
45 mg_ehand[MG_E_CXY] = c_hcolor; /* they get chromaticities */
46 mg_ehand[MG_E_CCT] = c_hcolor; /* they get color temp's */
47 mg_ehand[MG_E_CYL] = r_cyl; /* we do cylinders */
48 mg_ehand[MG_E_ED] = c_hmaterial; /* they get emission */
49 mg_ehand[MG_E_FACE] = r_face; /* we do faces */
50 mg_ehand[MG_E_IES] = r_ies; /* we do IES files */
51 mg_ehand[MG_E_IR] = c_hmaterial; /* they get refractive index */
52 mg_ehand[MG_E_MATERIAL] = c_hmaterial; /* they get materials */
53 mg_ehand[MG_E_NORMAL] = c_hvertex; /* they get normals */
54 mg_ehand[MG_E_OBJECT] = obj_handler; /* they track object names */
55 mg_ehand[MG_E_POINT] = c_hvertex; /* they get points */
56 mg_ehand[MG_E_RD] = c_hmaterial; /* they get diffuse refl. */
57 mg_ehand[MG_E_RING] = r_ring; /* we do rings */
58 mg_ehand[MG_E_RS] = c_hmaterial; /* they get specular refl. */
59 mg_ehand[MG_E_SIDES] = c_hmaterial; /* they get # sides */
60 mg_ehand[MG_E_SPH] = r_sph; /* we do spheres */
61 mg_ehand[MG_E_TD] = c_hmaterial; /* they get diffuse trans. */
62 mg_ehand[MG_E_TS] = c_hmaterial; /* they get specular trans. */
63 mg_ehand[MG_E_VERTEX] = c_hvertex; /* they get vertices */
64 mg_ehand[MG_E_XF] = xf_handler; /* they track transforms */
65 mg_init(); /* initialize the parser */
66 /* get our options & print header */
67 printf("## %s", argv[0]);
68 for (i = 1; i < argc && argv[i][0] == '-'; i++) {
69 printf(" %s", argv[i]);
70 switch (argv[i][1]) {
71 case 'g': /* glow distance (meters) */
72 if (argv[i][2] || badarg(argc-i-1, argv+i+1, "f"))
73 goto userr;
74 glowdist = atof(argv[++i]);
75 printf(" %s", argv[i]);
76 break;
77 case 'e': /* emitter multiplier */
78 if (argv[i][2] || badarg(argc-i-1, argv+i+1, "f"))
79 goto userr;
80 emult = atof(argv[++i]);
81 printf(" %s", argv[i]);
82 break;
83 case 'm': /* materials file */
84 matfp = fopen(argv[++i], "a");
85 if (matfp == NULL) {
86 fprintf(stderr, "%s: cannot append\n", argv[i]);
87 exit(1);
88 }
89 printf(" %s", argv[i]);
90 break;
91 default:
92 goto userr;
93 }
94 }
95 putchar('\n');
96 if (i == argc) { /* convert stdin */
97 if (mg_load(NULL) != MG_OK)
98 exit(1);
99 if (mg_nunknown)
100 printf("## %s: %u unknown entities\n",
101 argv[0], mg_nunknown);
102 } else /* convert each file */
103 for ( ; i < argc; i++) {
104 printf("## %s %s ##############################\n",
105 argv[0], argv[i]);
106 if (mg_load(argv[i]) != MG_OK)
107 exit(1);
108 if (mg_nunknown) {
109 printf("## %s %s: %u unknown entities\n",
110 argv[0], argv[i], mg_nunknown);
111 mg_nunknown = 0;
112 }
113 }
114 exit(0);
115 userr:
116 fprintf(stderr, "Usage: %s [-g dist][-e mult][-m matf] [file.mgf] ..\n",
117 argv[0]);
118 exit(1);
119 }
120
121
122 int
123 r_comment(ac, av) /* repeat a comment verbatim */
124 register int ac;
125 register char **av;
126 {
127 putchar('#'); /* use Radiance comment character */
128 while (--ac) { /* pass through verbatim */
129 putchar(' ');
130 fputs(*++av, stdout);
131 }
132 putchar('\n');
133 return(MG_OK);
134 }
135
136
137 int
138 r_cone(ac, av) /* put out a cone */
139 int ac;
140 char **av;
141 {
142 static int ncones;
143 char *mat;
144 double r1, r2;
145 C_VERTEX *cv1, *cv2;
146 FVECT p1, p2;
147 int inv;
148 /* check argument count and type */
149 if (ac != 5)
150 return(MG_EARGC);
151 if (!isflt(av[2]) || !isflt(av[4]))
152 return(MG_ETYPE);
153 /* get the endpoint vertices */
154 if ((cv1 = c_getvert(av[1])) == NULL ||
155 (cv2 = c_getvert(av[3])) == NULL)
156 return(MG_EUNDEF);
157 xf_xfmpoint(p1, cv1->p); /* transform endpoints */
158 xf_xfmpoint(p2, cv2->p);
159 r1 = xf_scale(atof(av[2])); /* scale radii */
160 r2 = xf_scale(atof(av[4]));
161 inv = r1 < 0.; /* check for inverted cone */
162 if (r1 == 0.) { /* check for illegal radii */
163 if (r2 == 0.)
164 return(MG_EILL);
165 inv = r2 < 0.;
166 } else if (r2 != 0. && inv ^ r2 < 0.)
167 return(MG_EILL);
168 if (inv) {
169 r1 = -r1;
170 r2 = -r2;
171 }
172 if ((mat = material()) == NULL) /* get material */
173 return(MG_EBADMAT);
174 /* spit the sucker out */
175 printf("\n%s %s %sc%d\n", mat, inv ? "cup" : "cone",
176 object(), ++ncones);
177 printf("0\n0\n8\n");
178 putv(p1);
179 putv(p2);
180 printf("%18.12g %18.12g\n", r1, r2);
181 return(MG_OK);
182 }
183
184
185 int
186 r_cyl(ac, av) /* put out a cylinder */
187 int ac;
188 char **av;
189 {
190 static int ncyls;
191 char *mat;
192 double rad;
193 C_VERTEX *cv1, *cv2;
194 FVECT p1, p2;
195 int inv;
196 /* check argument count and type */
197 if (ac != 4)
198 return(MG_EARGC);
199 if (!isflt(av[2]))
200 return(MG_ETYPE);
201 /* get the endpoint vertices */
202 if ((cv1 = c_getvert(av[1])) == NULL ||
203 (cv2 = c_getvert(av[3])) == NULL)
204 return(MG_EUNDEF);
205 xf_xfmpoint(p1, cv1->p); /* transform endpoints */
206 xf_xfmpoint(p2, cv2->p);
207 rad = xf_scale(atof(av[2])); /* scale radius */
208 if ((inv = rad < 0.)) /* check for inverted cylinder */
209 rad = -rad;
210 if ((mat = material()) == NULL) /* get material */
211 return(MG_EBADMAT);
212 /* spit out the primitive */
213 printf("\n%s %s %scy%d\n", mat, inv ? "tube" : "cylinder",
214 object(), ++ncyls);
215 printf("0\n0\n7\n");
216 putv(p1);
217 putv(p2);
218 printf("%18.12g\n", rad);
219 return(MG_OK);
220 }
221
222
223 int
224 r_sph(ac, av) /* put out a sphere */
225 int ac;
226 char **av;
227 {
228 static int nsphs;
229 char *mat;
230 double rad;
231 C_VERTEX *cv;
232 FVECT cent;
233 int inv;
234 /* check argument count and type */
235 if (ac != 3)
236 return(MG_EARGC);
237 if (!isflt(av[2]))
238 return(MG_ETYPE);
239 if ((cv = c_getvert(av[1])) == NULL) /* get center vertex */
240 return(MG_EUNDEF);
241 xf_xfmpoint(cent, cv->p); /* transform center */
242 rad = xf_scale(atof(av[2])); /* scale radius */
243 if ((inv = rad < 0.)) /* check for inversion */
244 rad = -rad;
245 if ((mat = material()) == NULL) /* get material */
246 return(MG_EBADMAT);
247 /* spit out primitive */
248 printf("\n%s %s %ss%d\n", mat, inv ? "bubble" : "sphere",
249 object(), ++nsphs);
250 printf("0\n0\n4 %18.12g %18.12g %18.12g %18.12g\n",
251 cent[0], cent[1], cent[2], rad);
252 return(MG_OK);
253 }
254
255
256 int
257 r_ring(ac, av) /* put out a ring */
258 int ac;
259 char **av;
260 {
261 static int nrings;
262 char *mat;
263 double r1, r2;
264 C_VERTEX *cv;
265 FVECT cent, norm;
266 /* check argument count and type */
267 if (ac != 4)
268 return(MG_EARGC);
269 if (!isflt(av[2]) || !isflt(av[3]))
270 return(MG_ETYPE);
271 if ((cv = c_getvert(av[1])) == NULL) /* get center vertex */
272 return(MG_EUNDEF);
273 if (is0vect(cv->n)) /* make sure we have normal */
274 return(MG_EILL);
275 xf_xfmpoint(cent, cv->p); /* transform center */
276 xf_rotvect(norm, cv->n); /* rotate normal */
277 r1 = xf_scale(atof(av[2])); /* scale radii */
278 r2 = xf_scale(atof(av[3]));
279 if (r1 < 0. | r2 <= r1)
280 return(MG_EILL);
281 if ((mat = material()) == NULL) /* get material */
282 return(MG_EBADMAT);
283 /* spit out primitive */
284 printf("\n%s ring %sr%d\n", mat, object(), ++nrings);
285 printf("0\n0\n8\n");
286 putv(cent);
287 putv(norm);
288 printf("%18.12g %18.12g\n", r1, r2);
289 return(MG_OK);
290 }
291
292
293 int
294 r_face(ac, av) /* convert a face */
295 int ac;
296 char **av;
297 {
298 static int nfaces;
299 char *mat;
300 register int i;
301 register C_VERTEX *cv;
302 FVECT v;
303 int rv;
304 /* check argument count and type */
305 if (ac < 4)
306 return(MG_EARGC);
307 if ((mat = material()) == NULL) /* get material */
308 return(MG_EBADMAT);
309 if (ac <= 5) { /* check for smoothing */
310 for (i = 1; i < ac; i++) {
311 if ((cv = c_getvert(av[i])) == NULL)
312 return(MG_EUNDEF);
313 if (is0vect(cv->n))
314 break;
315 }
316 if (i == ac) { /* break into triangles */
317 do_tri(mat, av[1], av[2], av[3]);
318 if (ac == 5)
319 do_tri(mat, av[3], av[4], av[1]);
320 return(MG_OK);
321 }
322 }
323 /* spit out unsmoothed primitive */
324 printf("\n%s polygon %sf%d\n", mat, object(), ++nfaces);
325 printf("0\n0\n%d\n", 3*(ac-1));
326 for (i = 1; i < ac; i++) { /* get, transform, print each vertex */
327 if ((cv = c_getvert(av[invert ? ac-i : i])) == NULL)
328 return(MG_EUNDEF);
329 xf_xfmpoint(v, cv->p);
330 putv(v);
331 }
332 return(MG_OK);
333 }
334
335
336 int
337 r_ies(ac, av) /* convert an IES luminaire file */
338 int ac;
339 char **av;
340 {
341 int xa0 = 2;
342 char combuf[128];
343 char fname[48];
344 char *oname;
345 register char *op;
346 register int i;
347 /* check argument count */
348 if (ac < 2)
349 return(MG_EARGC);
350 /* construct output file name */
351 if ((op = strrchr(av[1], '/')) != NULL)
352 op++;
353 else
354 op = av[1];
355 (void)strcpy(fname, op);
356 if ((op = strrchr(fname, '.')) == NULL)
357 op = fname + strlen(fname);
358 (void)strcpy(op, ".rad");
359 /* see if we need to run ies2rad */
360 if (access(fname, 0) == -1) {
361 (void)strcpy(combuf, "ies2rad");/* build ies2rad command */
362 op = combuf + 7; /* get -m option (first) */
363 if (ac-xa0 >= 2 && !strcmp(av[xa0], "-m")) {
364 if (!isflt(av[xa0+1]))
365 return(MG_ETYPE);
366 op = addarg(addarg(op, "-m"), av[xa0+1]);
367 xa0 += 2;
368 }
369 *op++ = ' '; /* build IES filename */
370 i = 0;
371 if (mg_file != NULL &&
372 (oname = strrchr(mg_file->fname,'/')) != NULL) {
373 i = oname - mg_file->fname + 1;
374 (void)strcpy(op, mg_file->fname);
375 }
376 (void)strcpy(op+i, av[1]);
377 if (access(op, 0) == -1) /* check for file existence */
378 return(MG_ENOFILE);
379 system(combuf); /* run ies2rad */
380 if (access(fname, 0) == -1) /* check success */
381 return(MG_EINCL);
382 }
383 printf("\n!xform"); /* put out xform command */
384 oname = object();
385 if (*oname) {
386 printf(" -n ");
387 for (op = oname; op[1]; op++) /* remove trailing separator */
388 putchar(*op);
389 }
390 for (i = xa0; i < ac; i++)
391 printf(" %s", av[i]);
392 if (ac > xa0 && xf_argc > 0)
393 printf(" -i 1");
394 for (i = 0; i < xf_argc; i++)
395 printf(" %s", xf_argv[i]);
396 printf(" %s\n", fname);
397 return(MG_OK);
398 }
399
400
401 do_tri(mat, vn1, vn2, vn3) /* put out smoothed triangle */
402 char *mat, *vn1, *vn2, *vn3;
403 {
404 static int ntris;
405 BARYCCM bvecs;
406 FLOAT bcoor[3][3];
407 C_VERTEX *cv1, *cv2, *cv3;
408 FVECT v1, v2, v3;
409 FVECT n1, n2, n3;
410 register int i;
411 /* the following is repeat code, so assume it's OK */
412 cv2 = c_getvert(vn2);
413 if (invert) {
414 cv3 = c_getvert(vn1);
415 cv1 = c_getvert(vn3);
416 } else {
417 cv1 = c_getvert(vn1);
418 cv3 = c_getvert(vn3);
419 }
420 xf_xfmpoint(v1, cv1->p);
421 xf_xfmpoint(v2, cv2->p);
422 xf_xfmpoint(v3, cv3->p);
423 /* compute barycentric coords. */
424 if (comp_baryc(&bvecs, v1, v2, v3) < 0)
425 return; /* degenerate triangle! */
426 printf("\n%s texfunc T-nor\n", mat); /* put out texture */
427 printf("4 dx dy dz %s\n0\n", TCALNAME);
428 xf_rotvect(n1, cv1->n);
429 xf_rotvect(n2, cv2->n);
430 xf_rotvect(n3, cv3->n);
431 for (i = 0; i < 3; i++) {
432 bcoor[i][0] = n1[i];
433 bcoor[i][1] = n2[i];
434 bcoor[i][2] = n3[i];
435 }
436 put_baryc(&bvecs, bcoor, 3);
437 /* put out triangle */
438 printf("\nT-nor polygon %st%d\n", object(), ++ntris);
439 printf("0\n0\n9\n");
440 putv(v1);
441 putv(v2);
442 putv(v3);
443 }
444
445
446 char *
447 material() /* get (and print) current material */
448 {
449 char *mname = "mat";
450 COLOR radrgb, c2;
451 double d;
452 register int i;
453
454 if (c_cmname != NULL)
455 mname = c_cmname;
456 if (!c_cmaterial->clock)
457 return(mname); /* already current */
458 /* else update output */
459 c_cmaterial->clock = 0;
460 if (c_cmaterial->ed > .1) { /* emitter */
461 cvtcolor(radrgb, &c_cmaterial->ed_c,
462 emult*c_cmaterial->ed/(PI*WHTEFFICACY));
463 if (glowdist < FHUGE) { /* do a glow */
464 fprintf(matfp, "\nvoid glow %s\n0\n0\n", mname);
465 fprintf(matfp, "4 %f %f %f %f\n", colval(radrgb,RED),
466 colval(radrgb,GRN),
467 colval(radrgb,BLU), glowdist);
468 } else {
469 fprintf(matfp, "\nvoid light %s\n0\n0\n", mname);
470 fprintf(matfp, "3 %f %f %f\n", colval(radrgb,RED),
471 colval(radrgb,GRN),
472 colval(radrgb,BLU));
473 }
474 return(mname);
475 }
476 d = c_cmaterial->rd + c_cmaterial->td +
477 c_cmaterial->rs + c_cmaterial->ts;
478 if (d < 0. | d > 1.)
479 return(NULL);
480 /* check for glass/dielectric */
481 if (c_cmaterial->nr > 1.1 &&
482 c_cmaterial->ts > .25 && c_cmaterial->rs <= .125 &&
483 c_cmaterial->td <= .01 && c_cmaterial->rd <= .01 &&
484 c_cmaterial->rs_a <= .01 && c_cmaterial->ts_a <= .01) {
485 cvtcolor(radrgb, &c_cmaterial->ts_c,
486 c_cmaterial->ts + c_cmaterial->rs);
487 if (c_cmaterial->sided) { /* dielectric */
488 colval(radrgb,RED) = pow(colval(radrgb,RED),
489 1./C_1SIDEDTHICK);
490 colval(radrgb,GRN) = pow(colval(radrgb,GRN),
491 1./C_1SIDEDTHICK);
492 colval(radrgb,BLU) = pow(colval(radrgb,BLU),
493 1./C_1SIDEDTHICK);
494 fprintf(matfp, "\nvoid dielectric %s\n0\n0\n", mname);
495 fprintf(matfp, "5 %g %g %g %f 0\n", colval(radrgb,RED),
496 colval(radrgb,GRN), colval(radrgb,BLU),
497 c_cmaterial->nr);
498 return(mname);
499 }
500 /* glass */
501 fprintf(matfp, "\nvoid glass %s\n0\n0\n", mname);
502 fprintf(matfp, "4 %f %f %f %f\n", colval(radrgb,RED),
503 colval(radrgb,GRN), colval(radrgb,BLU),
504 c_cmaterial->nr);
505 return(mname);
506 }
507 /* check for trans */
508 if (c_cmaterial->td > .01 || c_cmaterial->ts > .01) {
509 double ts, a5, a6;
510
511 if (c_cmaterial->sided) {
512 ts = sqrt(c_cmaterial->ts); /* approximate */
513 a5 = .5;
514 } else {
515 ts = c_cmaterial->ts;
516 a5 = 1.;
517 }
518 /* average colors */
519 d = c_cmaterial->rd + c_cmaterial->td + ts;
520 cvtcolor(radrgb, &c_cmaterial->rd_c, c_cmaterial->rd/d);
521 cvtcolor(c2, &c_cmaterial->td_c, c_cmaterial->td/d);
522 addcolor(radrgb, c2);
523 cvtcolor(c2, &c_cmaterial->ts_c, ts/d);
524 addcolor(radrgb, c2);
525 if (c_cmaterial->rs + ts > .0001)
526 a5 = (c_cmaterial->rs*c_cmaterial->rs_a +
527 ts*a5*c_cmaterial->ts_a) /
528 (c_cmaterial->rs + ts);
529 a6 = (c_cmaterial->td + ts) /
530 (c_cmaterial->rd + c_cmaterial->td + ts);
531 if (a6 < .999)
532 d = c_cmaterial->rd/(1. - c_cmaterial->rs)/(1. - a6);
533 else
534 d = c_cmaterial->td + ts;
535 scalecolor(radrgb, d);
536 fprintf(matfp, "\nvoid trans %s\n0\n0\n", mname);
537 fprintf(matfp, "7 %f %f %f\n", colval(radrgb,RED),
538 colval(radrgb,GRN), colval(radrgb,BLU));
539 fprintf(matfp, "\t%f %f %f %f\n", c_cmaterial->rs, a5, a6,
540 ts/(ts + c_cmaterial->td));
541 return(mname);
542 }
543 /* check for plastic */
544 if (c_cmaterial->rs < .1) {
545 cvtcolor(radrgb, &c_cmaterial->rd_c,
546 c_cmaterial->rd/(1.-c_cmaterial->rs));
547 fprintf(matfp, "\nvoid plastic %s\n0\n0\n", mname);
548 fprintf(matfp, "5 %f %f %f %f %f\n", colval(radrgb,RED),
549 colval(radrgb,GRN), colval(radrgb,BLU),
550 c_cmaterial->rs, c_cmaterial->rs_a);
551 return(mname);
552 }
553 /* else it's metal */
554 /* average colors */
555 cvtcolor(radrgb, &c_cmaterial->rd_c, c_cmaterial->rd);
556 cvtcolor(c2, &c_cmaterial->rs_c, c_cmaterial->rs);
557 addcolor(radrgb, c2);
558 fprintf(matfp, "\nvoid metal %s\n0\n0\n", mname);
559 fprintf(matfp, "5 %f %f %f %f %f\n", colval(radrgb,RED),
560 colval(radrgb,GRN), colval(radrgb,BLU),
561 c_cmaterial->rs/(c_cmaterial->rd + c_cmaterial->rs),
562 c_cmaterial->rs_a);
563 return(mname);
564 }
565
566
567 cvtcolor(radrgb, ciec, intensity) /* convert a CIE XYZ color to RGB */
568 COLOR radrgb;
569 register C_COLOR *ciec;
570 double intensity;
571 {
572 static COLOR ciexyz;
573
574 c_ccvt(ciec, C_CSXY); /* get xy representation */
575 ciexyz[1] = intensity;
576 ciexyz[0] = ciec->cx/ciec->cy*ciexyz[1];
577 ciexyz[2] = ciexyz[1]*(1./ciec->cy - 1.) - ciexyz[0];
578 cie_rgb(radrgb, ciexyz);
579 }
580
581
582 char *
583 object() /* return current object name */
584 {
585 static char objbuf[64];
586 register int i;
587 register char *cp;
588 int len;
589 /* tracked by obj_handler */
590 i = obj_nnames - sizeof(objbuf)/16;
591 if (i < 0)
592 i = 0;
593 for (cp = objbuf; i < obj_nnames &&
594 cp + (len=strlen(obj_name[i])) < objbuf+sizeof(objbuf)-1;
595 i++, *cp++ = '.') {
596 strcpy(cp, obj_name[i]);
597 cp += len;
598 }
599 *cp = '\0';
600 return(objbuf);
601 }
602
603
604 char *
605 addarg(op, arg) /* add argument and advance pointer */
606 register char *op, *arg;
607 {
608 *op = ' ';
609 while (*++op = *arg++)
610 ;
611 return(op);
612 }