ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/util/wrapBSDF.c
Revision: 2.3
Committed: Fri Feb 13 20:49:59 2015 UTC (7 years, 9 months ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.2: +58 -48 lines
Log Message:
Added XML templates and fixed bugs for first running version

File Contents

# Content
1 #ifndef lint
2 static const char RCSid[] = "$Id: wrapBSDF.c,v 2.2 2015/02/11 19:38:18 greg Exp $";
3 #endif
4 /*
5 * Wrap BSDF data in valid WINDOW XML file
6 *
7 * G. Ward February 2015
8 */
9
10 #include <ctype.h>
11 #include "rtio.h"
12 #include "rtprocess.h"
13 #include "ezxml.h"
14 #include "bsdf.h"
15 #include "bsdf_m.h"
16 /* XML template file names */
17 const char def_template[] = "minimalBSDFt.xml";
18 const char win6_template[] = "WINDOW6BSDFt.xml";
19
20 const char stdin_name[] = "<stdin>";
21
22 /* input files (can be stdin_name) */
23 const char *xml_input = NULL;
24 /* unit for materials & geometry */
25 const char *attr_unit = "meter";
26 const char legal_units[] = "meter|foot|inch|centimeter|millimeter";
27 /* system materials & geometry */
28 const char *mgf_geometry = NULL;
29
30 /* angle basis */
31 enum { ABdefault=-1, ABklemsFull=0, ABklemsHalf, ABklemsQuarter,
32 ABtensorTree3, ABtensorTree4, ABend };
33
34 int angle_basis = ABdefault;
35
36 /* field IDs and nicknames */
37 struct s_fieldID {
38 char nickName[4];
39 short has_unit;
40 short win_need;
41 const char *fullName;
42 } XMLfieldID[] = {
43 {"m", 0, 1, "Manufacturer"},
44 {"n", 0, 1, "Name"},
45 {"c", 0, 0, "ThermalConductivity"},
46 {"ef", 0, 0, "EmissivityFront"},
47 {"eb", 0, 0, "EmissivityBack"},
48 {"tir", 0, 0, "TIR"},
49 {"eo", 0, 0, "EffectiveOpennessFraction"},
50 {"t", 1, 1, "Thickness"},
51 {"h", 1, 0, "Height"},
52 {"w", 1, 0, "Width"},
53 {"\0", 0, 0, NULL} /* terminator */
54 };
55 /* field assignments */
56 #define MAXASSIGN 12
57 const char *field_assignment[MAXASSIGN];
58 int nfield_assign = 0;
59 #define FASEP ';'
60
61 /* data file(s) & spectra */
62 enum { DTtransForward, DTtransBackward, DTreflForward, DTreflBackward };
63
64 enum { DSsolar=-1, DSnir=-2, DSxbar31=-3, DSvisible=-4, DSzbar31=-5 };
65
66 #define MAXFILES 20
67
68 struct s_dfile {
69 const char *fname; /* input data file name */
70 short type; /* BSDF data type */
71 short spectrum; /* BSDF sensor spectrum */
72 } data_file[MAXFILES];
73
74 int ndataf = 0; /* number of data files */
75
76 const char *spectr_file[MAXFILES]; /* custom spectral curve input */
77
78 const char top_level_name[] = "WindowElement";
79
80 static char basis_definition[][256] = {
81
82 "\t\t<IncidentDataStructure>Columns</IncidentDataStructure>\n"
83 "\t\t<AngleBasis>\n"
84 "\t\t\t<AngleBasisName>LBNL/Klems Full</AngleBasisName>\n"
85 "\t\t</AngleBasis>\n",
86
87 "\t\t<IncidentDataStructure>Columns</IncidentDataStructure>\n"
88 "\t\t<AngleBasis>\n"
89 "\t\t\t<AngleBasisName>LBNL/Klems Half</AngleBasisName>\n"
90 "\t\t</AngleBasis>\n",
91
92 "\t\t<IncidentDataStructure>Columns</IncidentDataStructure>\n"
93 "\t\t<AngleBasis>\n"
94 "\t\t\t<AngleBasisName>LBNL/Klems Quarter</AngleBasisName>\n"
95 "\t\t</AngleBasis>\n",
96
97 "\t\t<IncidentDataStructure>TensorTree3</IncidentDataStructure>\n",
98
99 "\t\t<IncidentDataStructure>TensorTree4</IncidentDataStructure>\n",
100 };
101
102 /* Copy data from file descriptor to stdout and close */
103 static int
104 copy_and_close(int fd)
105 {
106 int ok = 1;
107 char buf[8192];
108 int n;
109
110 if (fd < 0)
111 return 0;
112 while ((n = read(fd, buf, sizeof(buf))) > 0)
113 if (write(fileno(stdout), buf, n) != n) {
114 ok = 0;
115 break;
116 }
117 ok &= (n == 0);
118 close(fd);
119 return ok;
120 }
121
122 /* Allocate and assign string from file or stream */
123 static char *
124 input2str(const char *inpspec)
125 {
126 FILE *fp = NULL;
127 char *str;
128 int len, pos, n;
129
130 if (inpspec == NULL || !*inpspec)
131 return "";
132 if (inpspec == stdin_name) { /* read from stdin */
133 fp = stdin;
134 } else if (inpspec[0] == '!') { /* read from command */
135 fp = popen(inpspec+1, "r");
136 if (fp == NULL) {
137 fprintf(stderr, "Cannot start process '%s'\n",
138 inpspec);
139 return "";
140 }
141 } else { /* else load file */
142 int fd = open(inpspec, O_RDONLY);
143 if (fd < 0) {
144 fprintf(stderr, "%s: cannot open\n", inpspec);
145 return "";
146 }
147 len = lseek(fd, 0L, SEEK_END);
148 if (len > 0) {
149 lseek(fd, 0L, SEEK_SET);
150 str = (char *)malloc(len+1);
151 if (str == NULL) {
152 close(fd);
153 goto memerr;
154 }
155 if (read(fd, str, len) != len) {
156 fprintf(stderr, "%s: read error\n", inpspec);
157 free(str);
158 close(fd);
159 return "";
160 }
161 str[len] = '\0';
162 close(fd);
163 return str;
164 }
165 fp = fdopen(fd, "r"); /* not a regular file */
166 }
167 /* reading from stream */
168 str = (char *)malloc((len=8192)+1);
169 if (str == NULL)
170 goto memerr;
171 pos = 0;
172 while ((n = read(fileno(fp), str+pos, len-pos)) > 0)
173 if ((pos += n) >= len) { /* need more space? */
174 str = (char *)realloc(str, (len += len>>2) + 1);
175 if (str == NULL)
176 goto memerr;
177 }
178 if (n < 0) {
179 fprintf(stderr, "%s: read error\n", inpspec);
180 free(str);
181 str = "";
182 } else { /* tidy up result */
183 str[pos] = '\0';
184 str = (char *)realloc(str, (len=pos)+1);
185 if (str == NULL)
186 goto memerr;
187 }
188 if (inpspec[0] != '!')
189 fclose(fp);
190 else if (pclose(fp))
191 fprintf(stderr, "Error running command '%s'\n", inpspec);
192 return str;
193 memerr:
194 fprintf(stderr, "%s: error allocating memory\n", inpspec);
195 if (fp != NULL)
196 (inpspec[0] == '!') ? pclose(fp) : fclose(fp);
197 return "";
198 }
199
200 /* Make material assignments in field_assignment to XML fields */
201 static int
202 mat_assignments(const char *caller, const char *fn, ezxml_t wtl)
203 {
204 int i;
205
206 wtl = ezxml_child(wtl, "Material");
207 if (wtl == NULL) {
208 fprintf(stderr, "%s: missing <Material> tag\n", fn);
209 return 0;
210 }
211 for (i = 0; i < nfield_assign; i++) {
212 const char *fnext = field_assignment[i];
213 for ( ; ; ) {
214 ezxml_t fld;
215 char sbuf[512];
216 int j;
217
218 while (isspace(*fnext))
219 ++fnext;
220 if (!*fnext)
221 break;
222 for (j = 0; *fnext != '=' && !isspace(*fnext); ) {
223 if (!*fnext | (*fnext == FASEP) |
224 (j >= sizeof(sbuf)-1)) {
225 fprintf(stderr,
226 "%s: bad tag name in assignment '%s'\n",
227 caller, field_assignment[i]);
228 return 0;
229 }
230 sbuf[j++] = *fnext++;
231 }
232 sbuf[j] = '\0'; /* check known field */
233 for (j = 0; XMLfieldID[j].nickName[0]; j++)
234 if (!strcasecmp(sbuf, XMLfieldID[j].nickName) ||
235 !strcasecmp(sbuf, XMLfieldID[j].fullName)) {
236 strcpy(sbuf, XMLfieldID[j].fullName);
237 break;
238 }
239 /* check if tag exists */
240 fld = ezxml_child(wtl, sbuf);
241 if (fld == NULL) { /* otherwise, create one */
242 if (!XMLfieldID[j].nickName[0])
243 fprintf(stderr,
244 "%s: warning - adding tag <%s>\n",
245 fn, sbuf);
246 fld = ezxml_add_child_d(wtl, sbuf, strlen(wtl->txt));
247 }
248 if (XMLfieldID[j].has_unit)
249 ezxml_set_attr(fld, "unit", attr_unit);
250 XMLfieldID[j].win_need = 0;
251 while (isspace(*fnext))
252 ++fnext;
253 if (*fnext++ != '=') {
254 fprintf(stderr,
255 "%s: missing '=' in assignment '%s'\n",
256 caller, field_assignment[i]);
257 return 0;
258 }
259 for (j = 0; *fnext && *fnext != FASEP; ) {
260 if (j >= sizeof(sbuf)-1) {
261 fprintf(stderr,
262 "%s: field too long in '%s'\n",
263 caller, field_assignment[i]);
264 return 0;
265 }
266 sbuf[j++] = *fnext++;
267 }
268 sbuf[j] = '\0';
269 ezxml_set_txt_d(fld, sbuf);
270 fnext += (*fnext == FASEP);
271 }
272 }
273 /* check required WINDOW settings */
274 if (xml_input == win6_template)
275 for (i = 0; XMLfieldID[i].nickName[0]; i++)
276 if (XMLfieldID[i].win_need &&
277 !ezxml_txt(ezxml_child(wtl,XMLfieldID[i].fullName))[0]) {
278 fprintf(stderr,
279 "%s: missing required '%s' assignment for WINDOW <%s>\n",
280 caller, XMLfieldID[i].nickName,
281 XMLfieldID[i].fullName);
282 return 0;
283 }
284 return 1; /* no errors */
285 }
286
287 /* Complete angle basis specification */
288 static int
289 finish_angle_basis(ezxml_t ab)
290 {
291 const char *bn = ezxml_txt(ezxml_child(ab, "AngleBasisName"));
292 int i, n = nabases;
293 char buf[32];
294
295 if (!*bn) {
296 fputs("Internal error - missing <AngleBasisName>!\n", stderr);
297 return 0;
298 }
299 while (n-- > 0)
300 if (!strcasecmp(bn, abase_list[n].name))
301 break;
302 if (n < 0) {
303 fprintf(stderr, "Internal error - unknown angle basis '%s'", bn);
304 return 0;
305 }
306 for (i = 0; abase_list[n].lat[i].nphis; i++) {
307 ezxml_t tb, abb = ezxml_add_child(ab, "AngleBasisBlock",
308 strlen(ab->txt));
309 sprintf(buf, "%g", i ?
310 .5*(abase_list[n].lat[i].tmin + abase_list[n].lat[i+1].tmin) :
311 .0);
312 ezxml_set_txt_d(ezxml_add_child(abb,"Theta",strlen(abb->txt)), buf);
313 sprintf(buf, "%d", abase_list[n].lat[i].nphis);
314 ezxml_set_txt_d(ezxml_add_child(abb,"nPhis",strlen(abb->txt)), buf);
315 tb = ezxml_add_child(abb, "ThetaBounds", strlen(abb->txt));
316 sprintf(buf, "%g", abase_list[n].lat[i].tmin);
317 ezxml_set_txt(ezxml_add_child(tb,"LowerTheta",strlen(tb->txt)), buf);
318 sprintf(buf, "%g", abase_list[n].lat[i+1].tmin);
319 ezxml_set_txt(ezxml_add_child(tb,"UpperTheta",strlen(tb->txt)), buf);
320 }
321 return 1;
322 }
323
324 /* Determine our angle basis from current tags */
325 static int
326 determine_angle_basis(const char *fn, ezxml_t wtl)
327 {
328 const char *ids;
329 int i;
330
331 wtl = ezxml_child(wtl, "DataDefinition");
332 if (wtl == NULL)
333 return -1;
334 ids = ezxml_txt(ezxml_child(wtl, "IncidentDataStructure"));
335 if (ids == NULL)
336 return -1;
337 for (i = 0; i < ABend; i++) {
338 ezxml_t parsed = ezxml_parse_str(basis_definition[i],
339 strlen(basis_definition[i]));
340 int match = 0;
341 if (!strcmp(ids, ezxml_txt(ezxml_child(parsed,
342 "IncidentDataStructure")))) {
343 const char *abn0 = ezxml_txt(
344 ezxml_child(ezxml_child(wtl,
345 "AngleBasis"), "AngleBasisName"));
346 const char *abn1 = ezxml_txt(
347 ezxml_child(ezxml_child(parsed,
348 "AngleBasis"), "AngleBasisName"));
349 match = !strcmp(abn0, abn1);
350 }
351 ezxml_free(parsed);
352 if (match)
353 return i;
354 }
355 return -1;
356 }
357
358 /* Write out BSDF data block with surrounding tags */
359 static int
360 writeBSDFblock(const char *caller, struct s_dfile *df)
361 {
362 char *cp;
363
364 puts("\t<WavelengthData>");
365 puts("\t\t<LayerNumber>System</LayerNumber>");
366 switch (df->spectrum) {
367 case DSvisible:
368 puts("\t\t<Wavelength unit=\"Integral\">Visible</Wavelength>");
369 puts("\t\tSourceSpectrum>CIE Illuminant D65 1nm.ssp</SourceSpectrum>");
370 puts("\t\t<DetectorSpectrum>ASTM E308 1931 Y.dsp</DetectorSpectrum>");
371 break;
372 case DSxbar31:
373 puts("\t\t<Wavelength unit=\"Integral\">CIE-X</Wavelength>");
374 puts("\t\tSourceSpectrum>CIE Illuminant D65 1nm.ssp</SourceSpectrum>");
375 puts("\t\t<DetectorSpectrum>ASTM E308 1931 X.dsp</DetectorSpectrum>");
376 break;
377 case DSzbar31:
378 puts("\t\t<Wavelength unit=\"Integral\">CIE-Z</Wavelength>");
379 puts("\t\tSourceSpectrum>CIE Illuminant D65 1nm.ssp</SourceSpectrum>");
380 puts("\t\t<DetectorSpectrum>ASTM E308 1931 Z.dsp</DetectorSpectrum>");
381 break;
382 case DSsolar:
383 puts("\t\t<Wavelength unit=\"Integral\">Solar</Wavelength>");
384 puts("\t\tSourceSpectrum>CIE Illuminant D65 1nm.ssp</SourceSpectrum>");
385 puts("\t\t<DetectorSpectrum>None</DetectorSpectrum>");
386 break;
387 case DSnir:
388 puts("\t\t<Wavelength unit=\"Integral\">NIR</Wavelength>");
389 puts("\t\tSourceSpectrum>PLACE_HOLDER</SourceSpectrum>");
390 puts("\t\t<DetectorSpectrum>PLACE_HOLDER</DetectorSpectrum>");
391 break;
392 default:
393 cp = strrchr(spectr_file[df->spectrum], '.');
394 if (cp != NULL)
395 *cp = '\0';
396 printf("\t\t<Wavelength unit=\"Integral\">%s</Wavelength>\n",
397 spectr_file[df->spectrum]);
398 if (cp != NULL)
399 *cp = '.';
400 puts("\t\tSourceSpectrum>CIE Illuminant D65 1nm.ssp</SourceSpectrum>");
401 printf("\t\t<DetectorSpectrum>%s</DetectorSpectrum>\n",
402 spectr_file[df->spectrum]);
403 break;
404 }
405 puts("\t\t<WavelengthDataBlock>");
406 fputs("\t\t\t<WavelengthDataDirection>", stdout);
407 switch (df->type) {
408 case DTtransForward:
409 fputs("Transmission Front", stdout);
410 break;
411 case DTtransBackward:
412 fputs("Transmission Back", stdout);
413 break;
414 case DTreflForward:
415 fputs("Reflection Front", stdout);
416 break;
417 case DTreflBackward:
418 fputs("Reflection Back", stdout);
419 break;
420 default:
421 fprintf(stderr, "%s: internal - bad BSDF type (%d)\n", caller, df->type);
422 return 0;
423 }
424 puts("</WavelengthDataDirection>");
425 switch (angle_basis) {
426 case ABklemsFull:
427 puts("\t\t\t<ColumnAngleBasis>LBNL/Klems Full</ColumnAngleBasis>");
428 break;
429 case ABklemsHalf:
430 puts("\t\t\t<ColumnAngleBasis>LBNL/Klems Half</ColumnAngleBasis>");
431 break;
432 case ABklemsQuarter:
433 puts("\t\t\t<ColumnAngleBasis>LBNL/Klems Quarter</ColumnAngleBasis>");
434 break;
435 case ABtensorTree3:
436 case ABtensorTree4:
437 puts("\t\t\t<AngleBasis>LBNL/Shirley-Chiu</AngleBasis>");
438 break;
439 default:
440 fprintf(stderr, "%s: bad angle basis (%d)\n", caller, angle_basis);
441 return 0;
442 }
443 puts("\t\t\t<ScatteringDataType>BTDF</ScatteringDataType>");
444 puts("\t\t\t<ScatteringData>");
445 fflush(stdout);
446 if (df->fname == stdin_name) {
447 copy_and_close(fileno(stdin));
448 } else if (df->fname[0] != '!') {
449 if (!copy_and_close(open(df->fname, O_RDONLY))) {
450 fprintf(stderr, "%s: error reading from '%s'\n",
451 caller, df->fname);
452 return 0;
453 }
454 } else if (system(df->fname+1)) {
455 fprintf(stderr, "%s: error running '%s'\n", caller, df->fname);
456 return 0;
457 }
458 puts("\t\t\t</ScatteringData>");
459 puts("\t\t</WavelengthDataBlock>");
460 puts("\t</WavelengthData>");
461 return 1;
462 }
463
464 /* Write out XML, interpolating BSDF data block(s) */
465 static int
466 writeBSDF(const char *caller, ezxml_t fl)
467 {
468 char *xml = ezxml_toxml(fl); /* store XML in string */
469 int ei, i;
470 /* locate trailer */
471 for (ei = strlen(xml)-strlen("</Layer></Optical></WindowElement>");
472 ei >= 0; ei--)
473 if (!strncmp(xml+ei, "</Layer>", 8))
474 break;
475 if (ei < 0) {
476 fprintf(stderr, "%s: internal - cannot find trailer\n",
477 caller);
478 free(xml);
479 return 0;
480 }
481 fflush(stdout); /* write previous XML info. */
482 if (write(fileno(stdout), xml, ei) != ei) {
483 free(xml);
484 return 0;
485 }
486 for (i = 0; i < ndataf; i++) /* interpolate new data */
487 if (!writeBSDFblock(caller, &data_file[i])) {
488 free(xml);
489 return 0;
490 }
491 fputs(xml+ei, stdout); /* write trailer */
492 free(xml); /* free string */
493 return (fflush(stdout) == 0);
494 }
495
496 /* Insert BSDF data into XML wrapper */
497 static int
498 wrapBSDF(const char *caller)
499 {
500 const char *xml_path = xml_input;
501 ezxml_t fl, wtl;
502 /* load previous XML/template */
503 if (xml_input == stdin_name) {
504 fl = ezxml_parse_fp(stdin);
505 } else if (xml_input[0] == '!') {
506 FILE *pfp = popen(xml_input+1, "r");
507 if (pfp == NULL) {
508 fprintf(stderr, "%s: cannot start process '%s'\n",
509 caller, xml_input);
510 return 0;
511 }
512 fl = ezxml_parse_fp(pfp);
513 if (pclose(pfp)) {
514 fprintf(stderr, "%s: error running '%s'\n",
515 caller, xml_input);
516 return 0;
517 }
518 } else {
519 xml_path = getpath((char *)xml_input, getrlibpath(), R_OK);
520 if (xml_path == NULL) {
521 fprintf(stderr, "%s: cannot find XML file named '%s'\n",
522 caller, xml_input==NULL ? "NULL" : xml_input);
523 return 0;
524 }
525 fl = ezxml_parse_file(xml_path);
526 }
527 if (fl == NULL) {
528 fprintf(stderr, "%s: cannot load XML '%s'\n", caller, xml_path);
529 return 0;
530 }
531 if (ezxml_error(fl)[0]) {
532 fprintf(stderr, "%s: error in XML '%s': %s\n", caller, xml_path,
533 ezxml_error(fl));
534 goto failure;
535 }
536 if (strcmp(ezxml_name(fl), top_level_name)) {
537 fprintf(stderr, "%s: top level in XML '%s' not '%s'\n",
538 caller, xml_path, top_level_name);
539 goto failure;
540 }
541 wtl = ezxml_child(fl, "FileType");
542 if (wtl != NULL && strcmp(ezxml_txt(wtl), "BSDF")) {
543 fprintf(stderr, "%s: wrong FileType in XML '%s' (must be 'BSDF')",
544 caller, xml_path);
545 goto failure;
546 }
547 wtl = ezxml_child(ezxml_child(fl, "Optical"), "Layer");
548 if (wtl == NULL) {
549 fprintf(stderr, "%s: no optical layers in XML '%s'",
550 caller, xml_path);
551 goto failure;
552 }
553 /* make material assignments */
554 if (!mat_assignments(caller, xml_path, wtl))
555 goto failure;
556 if (mgf_geometry != NULL) { /* add geometry if specified */
557 ezxml_t geom = ezxml_child(wtl, "Geometry");
558 if (geom == NULL)
559 geom = ezxml_add_child(wtl, "Geometry", strlen(wtl->txt));
560 ezxml_set_attr(geom, "format", "MGF");
561 geom = ezxml_child(geom, "MGFblock");
562 if (geom == NULL) {
563 geom = ezxml_child(wtl, "Geometry");
564 geom = ezxml_add_child(geom, "MGFblock", 0);
565 }
566 ezxml_set_attr(geom, "unit", attr_unit);
567 ezxml_set_txt(geom, input2str(mgf_geometry));
568 if (geom->txt[0])
569 ezxml_set_flag(geom, EZXML_TXTM);
570 }
571 /* check basis */
572 if (angle_basis != ABdefault) {
573 ezxml_t ab, dd = ezxml_child(wtl, "DataDefinition");
574 if (dd == NULL) {
575 dd = ezxml_add_child(wtl, "DataDefinition", strlen(wtl->txt));
576 } else if (dd->child != NULL) {
577 fprintf(stderr,
578 "%s: warning - replacing existing <DataDefinition> in '%s'\n",
579 caller, xml_path);
580 do
581 ezxml_remove(dd->child);
582 while (dd->child != NULL);
583 }
584 ezxml_insert(ezxml_parse_str(basis_definition[angle_basis],
585 strlen(basis_definition[angle_basis])),
586 dd, 0);
587 if ((ab = ezxml_child(dd, "AngleBasis")) != NULL &&
588 !finish_angle_basis(ab))
589 goto failure;
590 } else if ((angle_basis = determine_angle_basis(xml_path, wtl)) < 0) {
591 fprintf(stderr, "%s: need -a option to set angle basis\n",
592 caller);
593 goto failure;
594 }
595 /* write & add BSDF data blocks */
596 if (!writeBSDF(caller, fl))
597 goto failure;
598 ezxml_free(fl); /* all done */
599 return 1;
600 failure:
601 ezxml_free(fl);
602 return 0;
603 }
604
605 /* Report usage and exit */
606 static void
607 UsageExit(const char *pname)
608 {
609 fputs("Usage: ", stderr);
610 fputs(pname, stderr);
611 fputs(" [-W][-a {kf|kh|kq|t3|t4}][-u unit][-g geom][-f 'x=string;y=string']", stderr);
612 fputs(" [-s spectr][-tb inp][-tf inp][-rb inp][-rf inp]", stderr);
613 fputs(" [input.xml]\n", stderr);
614 exit(1);
615 }
616
617 /* Load XML file and use to wrap BSDF data (or modify fields) */
618 int
619 main(int argc, char *argv[])
620 {
621 int cur_spectrum = DSvisible;
622 int ncust_spec = 0;
623 int used_stdin = 0;
624 int units_set = 0;
625 int i;
626 /* get/check arguments */
627 for (i = 1; i < argc && argv[i][0] == '-'; i++) {
628 switch (argv[i][1]) {
629 case 'W': /* customize for WINDOW 6 output */
630 xml_input = win6_template;
631 continue;
632 case 'f': /* field assignment(s) */
633 if (++i >= argc)
634 UsageExit(argv[0]);
635 if (nfield_assign >= MAXASSIGN) {
636 fprintf(stderr, "%s: too many -f options",
637 argv[0]);
638 return 1;
639 }
640 field_assignment[nfield_assign++] = argv[i];
641 continue;
642 case 'u': /* unit */
643 if (++i >= argc)
644 UsageExit(argv[0]);
645 if (units_set++) {
646 fprintf(stderr, "%s: only one -u option allowed\n",
647 argv[0]);
648 return 1;
649 }
650 if (strstr(legal_units, argv[i]) == NULL) {
651 fprintf(stderr, "%s: -u unit must be one of (%s)\n",
652 argv[0], legal_units);
653 return 1;
654 }
655 attr_unit = argv[i];
656 continue;
657 case 'a': /* angle basis */
658 if (++i >= argc)
659 UsageExit(argv[0]);
660 if (angle_basis != ABdefault) {
661 fprintf(stderr, "%s: only one -a option allowed\n",
662 argv[0]);
663 return 1;
664 }
665 if (!strcasecmp(argv[i], "kf"))
666 angle_basis = ABklemsFull;
667 else if (!strcasecmp(argv[i], "kh"))
668 angle_basis = ABklemsHalf;
669 else if (!strcasecmp(argv[i], "kq"))
670 angle_basis = ABklemsQuarter;
671 else if (!strcasecmp(argv[i], "t3"))
672 angle_basis = ABtensorTree3;
673 else if (!strcasecmp(argv[i], "t4"))
674 angle_basis = ABtensorTree4;
675 else
676 UsageExit(argv[0]);
677 continue;
678 case 't': /* transmission */
679 if (i >= argc-1)
680 UsageExit(argv[0]);
681 if (ndataf >= MAXFILES) {
682 fprintf(stderr, "%s: too many data files\n",
683 argv[0]);
684 return 1;
685 }
686 if (!strcmp(argv[i], "-tf"))
687 data_file[ndataf].type = DTtransForward;
688 else if (!strcmp(argv[i], "-tb"))
689 data_file[ndataf].type = DTtransBackward;
690 else
691 UsageExit(argv[0]);
692 if (!strcmp(argv[++i], "-")) {
693 if (used_stdin++) UsageExit(argv[i]);
694 argv[i] = (char *)stdin_name;
695 }
696 data_file[ndataf].fname = argv[i];
697 data_file[ndataf].spectrum = cur_spectrum;
698 ndataf++;
699 continue;
700 case 'r': /* reflection */
701 if (i >= argc-1)
702 UsageExit(argv[0]);
703 if (ndataf >= MAXFILES) {
704 fprintf(stderr, "%s: too many data files\n",
705 argv[0]);
706 return 1;
707 }
708 if (!strcmp(argv[i], "-rf"))
709 data_file[ndataf].type = DTreflForward;
710 else if (!strcmp(argv[i], "-rb"))
711 data_file[ndataf].type = DTreflBackward;
712 else
713 UsageExit(argv[0]);
714 if (!strcmp(argv[++i], "-")) {
715 if (used_stdin++) UsageExit(argv[i]);
716 argv[i] = (char *)stdin_name;
717 }
718 data_file[ndataf].fname = argv[i];
719 data_file[ndataf++].spectrum = cur_spectrum;
720 continue;
721 case 's': /* spectrum name or input file */
722 if (++i >= argc)
723 UsageExit(argv[0]);
724 if (!strcasecmp(argv[i], "Solar"))
725 cur_spectrum = DSsolar;
726 else if (!strcasecmp(argv[i], "Visible") ||
727 !strcasecmp(argv[i], "CIE-Y"))
728 cur_spectrum = DSvisible;
729 else if (!strcasecmp(argv[i], "CIE-X"))
730 cur_spectrum = DSxbar31;
731 else if (!strcasecmp(argv[i], "CIE-Z"))
732 cur_spectrum = DSzbar31;
733 else if (!strcasecmp(argv[i], "NIR"))
734 cur_spectrum = DSnir;
735 else {
736 if (!strcmp(argv[i], "-")) {
737 fprintf(stderr,
738 "%s: cannot read spectra from stdin",
739 argv[0]);
740 return 1;
741 }
742 cur_spectrum = ncust_spec;
743 spectr_file[ncust_spec++] = argv[i];
744 }
745 continue;
746 case 'g': /* MGF geometry file */
747 if (i >= argc-1)
748 UsageExit(argv[0]);
749 if (mgf_geometry != NULL) {
750 fprintf(stderr, "%s: only one -g option allowed\n",
751 argv[0]);
752 return 1;
753 }
754 if (!strcmp(argv[++i], "-")) {
755 if (used_stdin++) UsageExit(argv[i]);
756 argv[i] = (char *)stdin_name;
757 }
758 mgf_geometry = argv[i];
759 continue;
760 case '\0': /* input XML from stdin */
761 break;
762 default:
763 UsageExit(argv[0]);
764 break;
765 }
766 break;
767 }
768 doneOptions: /* get XML input */
769 if (i >= argc) {
770 if (xml_input == NULL)
771 xml_input = def_template;
772 } else if ((i < argc-1) | (xml_input != NULL)) {
773 fprintf(stderr, "%s: only one XML input allowed\n", argv[0]);
774 UsageExit(argv[0]);
775 } else if (!strcmp(argv[i], "-")) {
776 if (used_stdin++) UsageExit(argv[0]);
777 xml_input = stdin_name;
778 } else {
779 xml_input = argv[i];
780 }
781 if ((xml_input == win6_template) & (angle_basis == ABdefault))
782 angle_basis = ABklemsFull;
783 /* wrap it! */
784 return !wrapBSDF(argv[0]);
785 }