1 |
– |
/* Copyright (c) 1990 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 |
|
* Convert Architrion file to Radiance |
6 |
|
* |
7 |
|
* Greg Ward |
8 |
|
*/ |
9 |
|
|
10 |
+ |
#include <stdlib.h> |
11 |
|
#include <stdio.h> |
12 |
+ |
#include <string.h> |
13 |
|
|
14 |
+ |
#include "rtio.h" |
15 |
|
#include "trans.h" |
16 |
|
|
17 |
|
#define DEFMAPFILE "/usr/local/lib/ray/lib/arch.map" |
94 |
|
|
95 |
|
char *progname; /* argv[0] */ |
96 |
|
|
97 |
+ |
void arch2rad(FILE *inp, FILE *out); |
98 |
+ |
void arch2names(FILE *inp); |
99 |
|
|
100 |
< |
main(argc, argv) /* translate Architrion file */ |
101 |
< |
int argc; |
102 |
< |
char *argv[]; |
100 |
> |
int hasmatch(BLOCK *bp, RULEHD *mp); |
101 |
> |
|
102 |
> |
void getfhead(FILE *fp); |
103 |
> |
void puthead(FILE *fp); |
104 |
> |
|
105 |
> |
int getblock(BLOCK *bp, FILE *fp); |
106 |
> |
void putblock(BLOCK *bp, FILE *fp); |
107 |
> |
void doneblock(BLOCK *bp); |
108 |
> |
|
109 |
> |
int getopening(OPNG *op, FILE *fp); |
110 |
> |
void add2quals(BLOCK *bp); |
111 |
> |
int matchrule(BLOCK *bp, RULEHD *rp); |
112 |
> |
|
113 |
> |
void putopenmod(char *sm, char *ml[], int nm, FILE *fp); |
114 |
> |
void putface(char *m, char *bn, char *fn, PRISM *p, |
115 |
> |
int a, int b, int c, int d, FILE *fp); |
116 |
> |
void putfaces(char *m, BLOCK *bp, int ff, FILE *fp); |
117 |
> |
void putpoint(PRISM *p, int n, FILE *fp); |
118 |
> |
void putopening(OPNG *op, FILE *fp); |
119 |
> |
|
120 |
> |
int checkface(PRISM *p, int a, int b, int c, int d); |
121 |
> |
|
122 |
> |
void lcross(long vr[3], long v1[3], long v2[3]); |
123 |
> |
|
124 |
> |
|
125 |
> |
int |
126 |
> |
main( /* translate Architrion file */ |
127 |
> |
int argc, |
128 |
> |
char *argv[] |
129 |
> |
) |
130 |
|
{ |
131 |
|
int donames = 0; /* -n flag, produce namelist */ |
132 |
|
int i; |
168 |
|
} |
169 |
|
|
170 |
|
|
171 |
< |
arch2rad(inp, out) /* translate Architrion file to Radiance */ |
172 |
< |
FILE *inp, *out; |
171 |
> |
void |
172 |
> |
arch2rad( /* translate Architrion file to Radiance */ |
173 |
> |
FILE *inp, |
174 |
> |
FILE *out |
175 |
> |
) |
176 |
|
{ |
177 |
|
int nbs, nos; |
178 |
|
BLOCK blk; |
196 |
|
} |
197 |
|
|
198 |
|
|
199 |
< |
arch2names(inp) /* get name list from an Architrion file */ |
200 |
< |
FILE *inp; |
199 |
> |
void |
200 |
> |
arch2names( /* get name list from an Architrion file */ |
201 |
> |
FILE *inp |
202 |
> |
) |
203 |
|
{ |
204 |
|
BLOCK blk; |
205 |
|
|
211 |
|
} |
212 |
|
|
213 |
|
|
214 |
< |
hasmatch(bp, mp) /* check for any match in rule list */ |
215 |
< |
BLOCK *bp; |
216 |
< |
RULEHD *mp; |
214 |
> |
int |
215 |
> |
hasmatch( /* check for any match in rule list */ |
216 |
> |
BLOCK *bp, |
217 |
> |
RULEHD *mp |
218 |
> |
) |
219 |
|
{ |
220 |
|
if (mp == NULL) |
221 |
|
return(0); |
225 |
|
} |
226 |
|
|
227 |
|
|
228 |
< |
getfhead(fp) /* get file header */ |
229 |
< |
FILE *fp; |
228 |
> |
void |
229 |
> |
getfhead( /* get file header */ |
230 |
> |
FILE *fp |
231 |
> |
) |
232 |
|
{ |
233 |
|
char buf[MAXSTR]; |
234 |
|
int i, n; |
235 |
+ |
register int c; |
236 |
|
/* get file name */ |
237 |
|
if (fgets(buf, MAXSTR, fp) == NULL) |
238 |
|
goto readerr; |
239 |
< |
if ((n = strlen(buf)) < 1) |
201 |
< |
goto readerr; |
202 |
< |
buf[n-1] = '\0'; |
239 |
> |
buf[strlen(buf)-1] = '\0'; |
240 |
|
fhead.filename = savestr(buf); |
241 |
|
/* get layers */ |
242 |
|
fhead.layer[0] = "Worksheet"; |
243 |
|
for (i = 1; i <= 8; i++) { |
244 |
< |
if (fscanf(fp, "Layer No.%d", &n) != 1 || n != i) |
244 |
> |
if (fscanf(fp, "L%*[^0-8]%d", &n) != 1 || n != i) |
245 |
|
goto readerr; |
246 |
< |
while ((n = getc(fp)) != EOF && (n == ' ' || n == '\t')) |
246 |
> |
while ((c = getc(fp)) != EOF && (c == ' ' || c == '\t')) |
247 |
|
; |
248 |
< |
if (n == EOF) |
248 |
> |
if (c == EOF) |
249 |
|
goto readerr; |
250 |
< |
ungetc(n, fp); |
250 |
> |
ungetc(c, fp); |
251 |
|
if (fgets(buf, MAXSTR, fp) == NULL) |
252 |
|
goto readerr; |
253 |
|
buf[strlen(buf)-1] = '\0'; |
282 |
|
} |
283 |
|
|
284 |
|
|
285 |
< |
puthead(fp) /* put out header information */ |
286 |
< |
FILE *fp; |
285 |
> |
void |
286 |
> |
puthead( /* put out header information */ |
287 |
> |
FILE *fp |
288 |
> |
) |
289 |
|
{ |
290 |
|
register int i; |
291 |
|
|
300 |
|
} |
301 |
|
|
302 |
|
|
303 |
< |
getblock(bp, fp) /* get an Architrion block */ |
304 |
< |
register BLOCK *bp; |
305 |
< |
FILE *fp; |
303 |
> |
int |
304 |
> |
getblock( /* get an Architrion block */ |
305 |
> |
register BLOCK *bp, |
306 |
> |
FILE *fp |
307 |
> |
) |
308 |
|
{ |
309 |
|
char word[32]; |
310 |
|
int i; |
343 |
|
} |
344 |
|
|
345 |
|
|
346 |
< |
getopening(op, fp) /* read in opening from fp */ |
347 |
< |
register OPNG *op; |
348 |
< |
FILE *fp; |
346 |
> |
int |
347 |
> |
getopening( /* read in opening from fp */ |
348 |
> |
register OPNG *op, |
349 |
> |
FILE *fp |
350 |
> |
) |
351 |
|
{ |
352 |
|
register int c; |
353 |
|
char word[32]; |
384 |
|
} |
385 |
|
|
386 |
|
|
387 |
< |
doneblock(bp) /* free data associated with bp */ |
388 |
< |
register BLOCK *bp; |
387 |
> |
void |
388 |
> |
doneblock( /* free data associated with bp */ |
389 |
> |
register BLOCK *bp |
390 |
> |
) |
391 |
|
{ |
392 |
|
register int i; |
393 |
|
|
394 |
|
if (bp->nopenings > 0) { |
395 |
|
for (i = 0; i < bp->nopenings; i++) |
396 |
|
doneid(&bp->opening[i].frame); |
397 |
< |
free((char *)bp->opening); |
397 |
> |
free((void *)bp->opening); |
398 |
|
} |
399 |
|
doneid(&bp->refid); |
400 |
|
} |
401 |
|
|
402 |
|
|
403 |
< |
add2quals(bp) /* add to qualifier lists */ |
404 |
< |
register BLOCK *bp; |
403 |
> |
void |
404 |
> |
add2quals( /* add to qualifier lists */ |
405 |
> |
register BLOCK *bp |
406 |
> |
) |
407 |
|
{ |
408 |
|
ID tmpid; |
409 |
|
|
422 |
|
} |
423 |
|
|
424 |
|
|
425 |
< |
putblock(bp, fp) /* put out a block */ |
426 |
< |
BLOCK *bp; |
427 |
< |
FILE *fp; |
425 |
> |
void |
426 |
> |
putblock( /* put out a block */ |
427 |
> |
BLOCK *bp, |
428 |
> |
FILE *fp |
429 |
> |
) |
430 |
|
{ |
431 |
|
RULEHD *rp; |
432 |
|
char *mod[NFACES], *sillmod; |
461 |
|
} |
462 |
|
|
463 |
|
|
464 |
< |
putopenmod(sm, ml, nm, fp) /* put out opening modifier */ |
465 |
< |
char *sm, *ml[]; |
466 |
< |
int nm; |
467 |
< |
FILE *fp; |
464 |
> |
void |
465 |
> |
putopenmod( /* put out opening modifier */ |
466 |
> |
char *sm, |
467 |
> |
char *ml[], |
468 |
> |
int nm, |
469 |
> |
FILE *fp |
470 |
> |
) |
471 |
|
{ |
472 |
|
int rept, nrepts; |
473 |
|
register int i, j; |
479 |
|
/* check for repeats */ |
480 |
|
rept = 0; nrepts = 0; |
481 |
|
for (i = 0; i < nm; i++) { |
482 |
< |
if (ml[i] == sm) { |
482 |
> |
if (ml[i] == sm || !strcmp(ml[i], VOIDID)) { |
483 |
|
rept |= 1<<i; |
484 |
|
nrepts++; |
485 |
+ |
continue; |
486 |
|
} |
487 |
|
for (j = 0; j < i; j++) |
488 |
< |
if (ml[j] == ml[i]) { |
488 |
> |
if (!(rept & 1<<j) && ml[j] == ml[i]) { |
489 |
|
rept |= 1<<j; |
490 |
|
nrepts++; |
491 |
|
} |
492 |
|
} |
493 |
|
/* print antimatter and modlist */ |
494 |
< |
fprintf(fp, "\nvoid antimatter %s\n", openmod); |
494 |
> |
fprintf(fp, "\n%s antimatter %s\n", VOIDID, openmod); |
495 |
|
fprintf(fp, "%d %s", 1+nm-nrepts, sm); |
496 |
|
for (i = 0; i < nm; i++) |
497 |
|
if (!(rept & 1<<i)) |
500 |
|
} |
501 |
|
|
502 |
|
|
503 |
< |
putopening(op, fp) /* put out an opening */ |
504 |
< |
OPNG *op; |
505 |
< |
FILE *fp; |
503 |
> |
void |
504 |
> |
putopening( /* put out an opening */ |
505 |
> |
OPNG *op, |
506 |
> |
FILE *fp |
507 |
> |
) |
508 |
|
{ |
509 |
|
static int nopens = 0; |
510 |
|
char buf[32]; |
519 |
|
newp.h[i] = p->h[i]; |
520 |
|
} |
521 |
|
/* spread reference and opposite */ |
522 |
< |
if (p->x[1] > p->x[0]) { |
522 |
> |
if (p->x[2] > p->x[0]) { |
523 |
|
newp.x[0] -= 2; |
524 |
< |
newp.x[1] += 2; |
524 |
> |
newp.x[1] -= 2; |
525 |
|
newp.x[2] += 2; |
526 |
< |
newp.x[3] -= 2; |
527 |
< |
} else if (p->x[0] > p->x[1]) { |
526 |
> |
newp.x[3] += 2; |
527 |
> |
} else if (p->x[0] > p->x[2]) { |
528 |
|
newp.x[0] += 2; |
529 |
< |
newp.x[1] -= 2; |
529 |
> |
newp.x[1] += 2; |
530 |
|
newp.x[2] -= 2; |
531 |
< |
newp.x[3] += 2; |
531 |
> |
newp.x[3] -= 2; |
532 |
|
} |
533 |
< |
if (p->y[1] > p->y[0]) { |
533 |
> |
if (p->y[2] > p->y[0]) { |
534 |
|
newp.y[0] -= 2; |
535 |
< |
newp.y[1] += 2; |
535 |
> |
newp.y[1] -= 2; |
536 |
|
newp.y[2] += 2; |
537 |
< |
newp.y[3] -= 2; |
538 |
< |
} else if (p->y[0] > p->y[1]) { |
537 |
> |
newp.y[3] += 2; |
538 |
> |
} else if (p->y[0] > p->y[2]) { |
539 |
|
newp.y[0] += 2; |
540 |
< |
newp.y[1] -= 2; |
540 |
> |
newp.y[1] += 2; |
541 |
|
newp.y[2] -= 2; |
542 |
< |
newp.y[3] += 2; |
542 |
> |
newp.y[3] -= 2; |
543 |
|
} |
544 |
|
/* put out faces */ |
545 |
|
sprintf(buf, "op%d", ++nopens); |
546 |
< |
putface(openmod, buf, "ref", &newp, 3, 7, 4, 0, fp); |
547 |
< |
putface(openmod, buf, "opp", &newp, 5, 6, 2, 1, fp); |
548 |
< |
putface(openmod, buf, "end1", &newp, 2, 6, 7, 3, fp); |
549 |
< |
putface(openmod, buf, "end2", &newp, 4, 5, 1, 0, fp); |
546 |
> |
putface(openmod, buf, "ref", &newp, 4, 5, 1, 0, fp); |
547 |
> |
putface(openmod, buf, "opp", &newp, 2, 6, 7, 3, fp); |
548 |
> |
putface(openmod, buf, "end1", &newp, 5, 6, 2, 1, fp); |
549 |
> |
putface(openmod, buf, "end2", &newp, 3, 7, 4, 0, fp); |
550 |
|
putface(openmod, buf, "bot", &newp, 1, 2, 3, 0, fp); |
551 |
|
putface(openmod, buf, "top", &newp, 7, 6, 5, 4, fp); |
552 |
|
} |
553 |
|
|
554 |
|
|
555 |
|
int |
556 |
< |
matchrule(bp, rp) /* see if block matches this rule */ |
557 |
< |
register BLOCK *bp; |
558 |
< |
register RULEHD *rp; |
556 |
> |
matchrule( /* see if block matches this rule */ |
557 |
> |
register BLOCK *bp, |
558 |
> |
register RULEHD *rp |
559 |
> |
) |
560 |
|
{ |
561 |
|
register int i; |
562 |
|
ID tmpid; |
563 |
|
|
564 |
|
if (rp->qflg & FL(Q_LAY)) { /* check layer */ |
565 |
< |
tmpid.name = NULL; |
565 |
> |
tmpid.name = fhead.layer[bp->layer]; |
566 |
|
tmpid.number = bp->layer; |
567 |
|
if (!matchid(&tmpid, &idm(rp)[Q_LAY])) |
568 |
|
return(0); |
587 |
|
} |
588 |
|
|
589 |
|
|
590 |
< |
putfaces(m, bp, ff, fp) /* put out faces */ |
591 |
< |
char *m; |
592 |
< |
BLOCK *bp; |
593 |
< |
register int ff; |
594 |
< |
FILE *fp; |
590 |
> |
void |
591 |
> |
putfaces( /* put out faces */ |
592 |
> |
char *m, |
593 |
> |
BLOCK *bp, |
594 |
> |
register int ff, |
595 |
> |
FILE *fp |
596 |
> |
) |
597 |
|
{ |
598 |
|
char *blkname(), *bn; |
599 |
|
|
601 |
|
return; |
602 |
|
bn = blkname(bp); |
603 |
|
if (ff & 1<<F_REF) |
604 |
< |
putface(m, bn, "ref", &bp->p, 3, 7, 4, 0, fp); |
604 |
> |
putface(m, bn, "ref", &bp->p, 4, 5, 1, 0, fp); |
605 |
|
if (ff & 1<<F_OPP) |
606 |
< |
putface(m, bn, "opp", &bp->p, 5, 6, 2, 1, fp); |
606 |
> |
putface(m, bn, "opp", &bp->p, 2, 6, 7, 3, fp); |
607 |
|
if (ff & 1<<F_END) { |
608 |
< |
putface(m, bn, "end1", &bp->p, 2, 6, 7, 3, fp); |
609 |
< |
putface(m, bn, "end2", &bp->p, 4, 5, 1, 0, fp); |
608 |
> |
putface(m, bn, "end1", &bp->p, 5, 6, 2, 1, fp); |
609 |
> |
putface(m, bn, "end2", &bp->p, 3, 7, 4, 0, fp); |
610 |
|
} |
611 |
|
if (ff & 1<<F_BOT) |
612 |
|
putface(m, bn, "bot", &bp->p, 1, 2, 3, 0, fp); |
616 |
|
|
617 |
|
|
618 |
|
char * |
619 |
< |
blkname(bp) /* think up a good name for this block */ |
620 |
< |
register BLOCK *bp; |
619 |
> |
blkname( /* think up a good name for this block */ |
620 |
> |
register BLOCK *bp |
621 |
> |
) |
622 |
|
{ |
623 |
|
static char nambuf[32]; |
624 |
|
static int blkcnt = 0; |
625 |
|
register char *nam; |
626 |
< |
register int i; |
626 |
> |
register int i, j; |
627 |
|
|
628 |
+ |
sprintf(nambuf, "l%d.", bp->layer); |
629 |
+ |
i = strlen(nambuf); |
630 |
|
nam = bp->refid.name; |
570 |
– |
if (nam == NULL) |
571 |
– |
nam = fhead.layer[bp->layer]; |
631 |
|
if (nam == NULL) { |
632 |
< |
sprintf(nambuf, "l%d.", bp->layer); |
633 |
< |
i = strlen(nambuf); |
634 |
< |
} else { |
635 |
< |
for (i = 0; i < 12 && nam[i]; i++) { |
636 |
< |
if (nam[i] == ' ' || nam[i] == '\t') |
637 |
< |
nambuf[i] = '_'; |
632 |
> |
nam = fhead.layer[bp->layer]; |
633 |
> |
if (nam != NULL) |
634 |
> |
i = 0; |
635 |
> |
} |
636 |
> |
if (nam != NULL) { |
637 |
> |
for (j = 0; j < 12 && nam[j]; j++) { |
638 |
> |
if (nam[j] == ' ' || nam[j] == '\t') |
639 |
> |
nambuf[i++] = '_'; |
640 |
|
else |
641 |
< |
nambuf[i] = nam[i]; |
641 |
> |
nambuf[i++] = nam[j]; |
642 |
|
} |
643 |
|
nambuf[i++] = '.'; |
644 |
|
} |
651 |
|
} |
652 |
|
|
653 |
|
|
654 |
< |
putface(m, bn, fn, p, a, b, c, d, fp) /* put out a face */ |
655 |
< |
char *m; |
656 |
< |
char *bn, *fn; |
657 |
< |
PRISM *p; |
658 |
< |
int a, b, c, d; |
659 |
< |
FILE *fp; |
654 |
> |
void |
655 |
> |
putface( /* put out a face */ |
656 |
> |
char *m, |
657 |
> |
char *bn, |
658 |
> |
char *fn, |
659 |
> |
PRISM *p, |
660 |
> |
int a, |
661 |
> |
int b, |
662 |
> |
int c, |
663 |
> |
int d, |
664 |
> |
FILE *fp |
665 |
> |
) |
666 |
|
{ |
667 |
|
int cf; |
668 |
|
|
696 |
|
#define ldot(v1,v2) (v1[0]*v2[0]+v1[1]*v2[1]+v1[2]*v2[2]) |
697 |
|
|
698 |
|
|
699 |
< |
long |
700 |
< |
lcross(vr, v1, v2) /* compute cross product */ |
701 |
< |
register long vr[3], v1[3], v2[3]; |
699 |
> |
void |
700 |
> |
lcross( /* compute cross product */ |
701 |
> |
register long vr[3], |
702 |
> |
register long v1[3], |
703 |
> |
register long v2[3] |
704 |
> |
) |
705 |
|
{ |
706 |
|
vr[0] = v1[1]*v2[2] - v1[2]*v2[1]; |
707 |
|
vr[1] = v1[2]*v2[0] - v1[0]*v2[2]; |
712 |
|
#define labs(a) ((a)>0 ? (a) : -(a)) |
713 |
|
|
714 |
|
|
715 |
< |
checkface(p, a, b, c, d) /* check a face for validity */ |
716 |
< |
register PRISM *p; |
717 |
< |
int a, b, c, d; |
715 |
> |
int |
716 |
> |
checkface( /* check a face for validity */ |
717 |
> |
register PRISM *p, |
718 |
> |
int a, |
719 |
> |
int b, |
720 |
> |
int c, |
721 |
> |
int d |
722 |
> |
) |
723 |
|
{ |
724 |
|
int rval = 0; |
725 |
|
long lt; |
767 |
|
} |
768 |
|
|
769 |
|
|
770 |
< |
putpoint(p, n, fp) /* put out a point */ |
771 |
< |
register PRISM *p; |
772 |
< |
int n; |
773 |
< |
FILE *fp; |
770 |
> |
void |
771 |
> |
putpoint( /* put out a point */ |
772 |
> |
register PRISM *p, |
773 |
> |
int n, |
774 |
> |
FILE *fp |
775 |
> |
) |
776 |
|
{ |
777 |
|
register int i = n&3; |
778 |
|
|
781 |
|
} |
782 |
|
|
783 |
|
|
784 |
< |
eputs(s) |
785 |
< |
char *s; |
784 |
> |
void |
785 |
> |
eputs( |
786 |
> |
char *s |
787 |
> |
) |
788 |
|
{ |
789 |
|
fputs(s, stderr); |
790 |
|
} |
791 |
|
|
792 |
|
|
793 |
< |
quit(code) |
794 |
< |
int code; |
793 |
> |
void |
794 |
> |
quit( |
795 |
> |
int code |
796 |
> |
) |
797 |
|
{ |
798 |
|
exit(code); |
799 |
|
} |
800 |
+ |
|