ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/cv/ies2rad.c
(Generate patch)

Comparing ray/src/cv/ies2rad.c (file contents):
Revision 1.5 by greg, Thu Oct 24 12:17:35 1991 UTC vs.
Revision 2.19 by schorsch, Mon Jun 30 14:59:11 2003 UTC

# Line 1 | Line 1
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 IES luminaire data to Radiance description
6   *
7   *      07Apr90         Greg Ward
8 + *
9 + *  Fixed correction factor for flat sources 29Oct2001 GW
10   */
11  
12   #include <stdio.h>
13 + #include <math.h>
14 + #include <sys/types.h>
15   #include <ctype.h>
16   #include "color.h"
17 + #include "paths.h"
18  
19   #define PI              3.14159265358979323846
20                                          /* floating comparisons */
21   #define FTINY           1e-6
22   #define FEQ(a,b)        ((a)<=(b)+FTINY&&(a)>=(b)-FTINY)
23 +                                        /* keywords */
24 + #define MAGICID         "IESNA"
25 + #define LMAGICID        5
26 + #define FIRSTREV        86
27 + #define LASTREV         95
28 +
29 + #define D86             0               /* keywords defined in LM-63-1986 */
30 +
31 + #define K_TST           0
32 + #define K_MAN           1
33 + #define K_LMC           2
34 + #define K_LMN           3
35 + #define K_LPC           4
36 + #define K_LMP           5
37 + #define K_BAL           6
38 + #define K_MTC           7
39 + #define K_OTH           8
40 + #define K_SCH           9
41 + #define K_MOR           10
42 + #define K_BLK           11
43 + #define K_EBK           12
44 +
45 + #define D91             ((1L<<13)-1)    /* keywords defined in LM-63-1991 */
46 +
47 + #define K_LMG           13
48 +
49 + #define D95             ((1L<<14)-1)    /* keywords defined in LM-63-1995 */
50 +
51 + char    k_kwd[][20] = {"TEST", "MANUFAC", "LUMCAT", "LUMINAIRE", "LAMPCAT",
52 +                        "LAMP", "BALLAST", "MAINTCAT", "OTHER", "SEARCH",
53 +                        "MORE", "BLOCK", "ENDBLOCK", "LUMINOUSGEOMETRY"};
54 +
55 + long k_defined[] = {D86, D86, D86, D86, D86, D91, D91, D91, D91, D95};
56 +
57 + int     filerev = FIRSTREV;
58 +
59 + #define keymatch(i,s)   (k_defined[filerev-FIRSTREV]&1L<<(i) &&\
60 +                                k_match(k_kwd[i],s))
61 +
62 + #define checklamp(s)    (!(k_defined[filerev-FIRSTREV]&(1<<K_LMP|1<<K_LPC)) ||\
63 +                                keymatch(K_LMP,s) || keymatch(K_LPC,s))
64 +
65                                          /* tilt specs */
66   #define TLTSTR          "TILT="
67   #define TLTSTRLEN       5
# Line 35 | Line 79 | static char SCCSid[] = "$SunId$ LBL";
79                                          /* string lengths */
80   #define MAXLINE         132
81   #define MAXWORD         76
38 – #define MAXPATH         128
82                                          /* file types */
83   #define T_RAD           ".rad"
84   #define T_DST           ".dat"
85 < #define T_TLT           "+.dat"
85 > #define T_TLT           "%.dat"
86 > #define T_OCT           ".oct"
87                                          /* shape types */
88   #define RECT            1
89   #define DISK            2
# Line 49 | Line 93 | static char SCCSid[] = "$SunId$ LBL";
93  
94   #define F_M             .3048           /* feet to meters */
95  
96 < #define abspath(p)      ((p)[0] == '/' || (p)[0] == '.')
96 > #define abspath(p)      (ISDIRSEP((p)[0]) || (p)[0] == '.')
97  
98   static char     default_name[] = "default";
99  
# Line 64 | Line 108 | float  defcolor[3] = {1.,1.,1.};       /* default lamp color
108   float   *lampcolor = defcolor;          /* pointer to current lamp color */
109   double  multiplier = 1.0;               /* multiplier for all light sources */
110   char    units[64] = "meters";           /* output units */
111 < double  minaspect = 0.0;                /* minimum allowed aspect ratio */
112 < int     maxemitters = 1;                /* maximum emitters per hemisphere */
111 > int     out2stdout = 0;                 /* put out to stdout r.t. file */
112 > int     instantiate = 0;                /* instantiate geometry */
113   double  illumrad = 0.0;                 /* radius for illum sphere */
114  
115   typedef struct {
116 +        int     isillum;                        /* do as illum */
117          int     type;                           /* RECT, DISK, SPHERE */
118 +        double  mult;                           /* candela multiplier */
119          double  w, l, h;                        /* width, length, height */
120          double  area;                           /* max. projected area */
121 < } SHAPE;                                /* a source shape */
121 > } SRCINFO;                              /* a source shape (units=meters) */
122  
123   int     gargc;                          /* global argc (minus filenames) */
124   char    **gargv;                        /* global argv */
125  
126   extern char     *strcpy(), *strcat(), *stradd(), *tailtrunc(), *filetrunc(),
127 <                *filename(), *libname(), *fullname(), *malloc();
82 < extern double   atof();
127 >                *filename(), *libname(), *fullnam(), *getword(), *atos();
128   extern float    *matchlamp();
129 + extern time_t   fdate();
130  
131 + #define scnint(fp,ip)   cvtint(ip,getword(fp))
132 + #define scnflt(fp,rp)   cvtflt(rp,getword(fp))
133 + #define isint           isflt                   /* IES allows real as integer */
134  
135 +
136   main(argc, argv)
137   int     argc;
138   char    *argv[];
# Line 154 | Line 204 | char   *argv[];
204                  case 'f':               /* lamp data file */
205                          lampdat = argv[++i];
206                          break;
207 <                case 'o':               /* output file name */
207 >                case 'o':               /* output file root name */
208                          outfile = argv[++i];
209                          break;
210 <                case 's':               /* square emitters */
211 <                        minaspect = .6;
162 <                        if (argv[i][2] == '/') {
163 <                                maxemitters = atoi(argv[i]+3);
164 <                                if (maxemitters < 1)
165 <                                        goto badopt;
166 <                        }
210 >                case 's':               /* output to stdout */
211 >                        out2stdout = !out2stdout;
212                          break;
213                  case 'i':               /* illum */
214                          illumrad = atof(argv[++i]);
170 –                        if (illumrad < MINDIM)
171 –                                illumrad = MINDIM;
215                          break;
216 +                case 'g':               /* instatiate geometry? */
217 +                        instantiate = !instantiate;
218 +                        break;
219                  case 't':               /* override lamp type */
220                          lamptype = argv[++i];
221                          break;
# Line 199 | Line 245 | char   *argv[];
245                          exit(ies2rad(NULL, outfile) == 0 ? 0 : 1);
246                  else if (i == argc-1)
247                          exit(ies2rad(argv[i], outfile) == 0 ? 0 : 1);
248 <                else {
249 <                        fprintf(stderr, "%s: single input file required\n",
204 <                                        argv[0]);
205 <                        exit(1);
206 <                }
248 >                else
249 >                        goto needsingle;
250          } else if (i >= argc) {
251                  fprintf(stderr, "%s: missing output file specification\n",
252                                  argv[0]);
253                  exit(1);
254          }
255 +        if (out2stdout && i != argc-1)
256 +                goto needsingle;
257          status = 0;
258          for ( ; i < argc; i++) {
259                  tailtrunc(strcpy(outname,filename(argv[i])));
# Line 216 | Line 261 | char   *argv[];
261                          status = 1;
262          }
263          exit(status);
264 + needsingle:
265 +        fprintf(stderr, "%s: single input file required\n", argv[0]);
266 +        exit(1);
267   }
268  
269  
# Line 277 | Line 325 | int    sep;
325  
326  
327   char *
328 < fullname(path, fname, suffix)           /* return full path name */
328 > fullnam(path, fname, suffix)            /* return full path name */
329   char    *path, *fname, *suffix;
330   {
331          if (prefdir != NULL && abspath(prefdir))
# Line 285 | Line 333 | char   *path, *fname, *suffix;
333          else if (abspath(fname))
334                  strcpy(stradd(path, fname, 0), suffix);
335          else
336 <                libname(stradd(path, libdir, '/'), fname, suffix);
336 >                libname(stradd(path, libdir, DIRSEP), fname, suffix);
337  
338          return(path);
339   }
# Line 298 | Line 346 | char   *path, *fname, *suffix;
346          if (abspath(fname))
347                  strcpy(stradd(path, fname, 0), suffix);
348          else
349 <                strcpy(stradd(stradd(path, prefdir, '/'), fname, 0), suffix);
349 >                strcpy(stradd(stradd(path, prefdir, DIRSEP), fname, 0), suffix);
350  
351          return(path);
352   }
# Line 311 | Line 359 | register char  *path;
359          register char   *cp;
360  
361          for (cp = path; *path; path++)
362 <                if (*path == '/')
362 >                if (ISDIRSEP(*path))
363                          cp = path+1;
364          return(cp);
365   }
# Line 324 | Line 372 | char   *path;
372          register char   *p1, *p2;
373  
374          for (p1 = p2 = path; *p2; p2++)
375 <                if (*p2 == '/')
375 >                if (ISDIRSEP(*p2))
376                          p1 = p2;
377 +        if (p1 == path && ISDIRSEP(*p1))
378 +                p1++;
379          *p1 = '\0';
380          return(path);
381   }
# Line 362 | Line 412 | char   *s;
412   }
413  
414  
415 + k_match(kwd, hdl)                       /* header line matches keyword? */
416 + register char   *kwd, *hdl;
417 + {
418 +        if (!*hdl++ == '[')
419 +                return(0);
420 +        while (islower(*hdl) ? toupper(*hdl) == *kwd++ : *hdl == *kwd++)
421 +                if (!*hdl++)
422 +                        return(0);
423 +        return(!*kwd & *hdl == ']');
424 + }
425 +
426 +
427 + char *
428 + keyargs(hdl)                            /* return keyword arguments */
429 + register char   *hdl;
430 + {
431 +        while (*hdl && *hdl++ != ']')
432 +                ;
433 +        while (isspace(*hdl))
434 +                hdl++;
435 +        return(hdl);
436 + }
437 +
438 +
439   putheader(out)                          /* print header */
440   FILE    *out;
441   {
# Line 381 | Line 455 | FILE   *out;
455   ies2rad(inpname, outname)               /* convert IES file */
456   char    *inpname, *outname;
457   {
458 +        SRCINFO srcinfo;
459          char    buf[MAXLINE], tltid[MAXWORD];
460 +        char    geomfile[128];
461          FILE    *inpfp, *outfp;
462 +        int     lineno = 0;
463  
464 +        geomfile[0] = '\0';
465 +        srcinfo.isillum = 0;
466          if (inpname == NULL) {
467                  inpname = "<stdin>";
468                  inpfp = stdin;
# Line 391 | Line 470 | char   *inpname, *outname;
470                  perror(inpname);
471                  return(-1);
472          }
473 <        if ((outfp = fopen(fullname(buf,outname,T_RAD), "w")) == NULL) {
473 >        if (out2stdout)
474 >                outfp = stdout;
475 >        else if ((outfp = fopen(fullnam(buf,outname,T_RAD), "w")) == NULL) {
476                  perror(buf);
477                  fclose(inpfp);
478                  return(-1);
# Line 404 | Line 485 | char   *inpname, *outname;
485                  blanktrunc(buf);
486                  if (!buf[0])
487                          continue;
488 +                if (!lineno++ && !strncmp(buf, MAGICID, LMAGICID)) {
489 +                        filerev = atoi(buf+LMAGICID);
490 +                        if (filerev < FIRSTREV)
491 +                                filerev = FIRSTREV;
492 +                        else if (filerev > LASTREV)
493 +                                filerev = LASTREV;
494 +                }
495                  fputs("#<", outfp);
496                  fputs(buf, outfp);
497                  putc('\n', outfp);
498 <                if (lampcolor == NULL)
499 <                        lampcolor = matchlamp(buf);
498 >                if (lampcolor == NULL && checklamp(buf))
499 >                        lampcolor = matchlamp( buf[0] == '[' ?
500 >                                                keyargs(buf) : buf );
501 >                if (keymatch(K_LMG, buf)) {             /* geometry file */
502 >                        strcpy(geomfile, inpname);
503 >                        strcpy(filename(geomfile), keyargs(buf));
504 >                        srcinfo.isillum = 1;
505 >                }
506          }
507          if (lampcolor == NULL) {
508                  fprintf(stderr, "%s: warning - no lamp type\n", inpname);
509 +                fputs("# Unknown lamp type (used default)\n", outfp);
510                  lampcolor = defcolor;
511 <        }
511 >        } else if (lamptype == NULL)
512 >                fprintf(outfp,"# CIE(x,y) = (%f,%f)\n# Depreciation = %.1f%%\n",
513 >                                lampcolor[3], lampcolor[4], 100.*lampcolor[5]);
514          if (feof(inpfp)) {
515                  fprintf(stderr, "%s: not in IES format\n", inpname);
516                  goto readerr;
517          }
518 <        sscanf(buf+TLTSTRLEN, "%s", tltid);
518 >        atos(tltid, MAXWORD, buf+TLTSTRLEN);
519          if (inpfp == stdin)
520                  buf[0] = '\0';
521          else
# Line 427 | Line 524 | char   *inpname, *outname;
524                  fprintf(stderr, "%s: bad tilt data\n", inpname);
525                  goto readerr;
526          }
527 <        if (dosource(inpfp, outfp, tltid, outname) != 0) {
527 >        if (dosource(&srcinfo, inpfp, outfp, tltid, outname) != 0) {
528                  fprintf(stderr, "%s: bad luminaire data\n", inpname);
529                  goto readerr;
530          }
434 –        fclose(outfp);
531          fclose(inpfp);
532 +                                        /* cvgeometry closes outfp */
533 +        if (cvgeometry(geomfile, &srcinfo, outname, outfp) != 0) {
534 +                fprintf(stderr, "%s: bad geometry file\n", geomfile);
535 +                return(-1);
536 +        }
537          return(0);
538   readerr:
438 –        fclose(outfp);
539          fclose(inpfp);
540 <        unlink(fullname(buf,outname,T_RAD));
540 >        fclose(outfp);
541 >        unlink(fullnam(buf,outname,T_RAD));
542          return(-1);
543   }
544  
# Line 448 | Line 549 | char   *dir, *tltspec, *dfltname, *tltid;
549   {
550          int     nangles, tlt_type;
551          double  minmax[2];
552 <        char    buf[MAXPATH], tltname[MAXWORD];
552 >        char    buf[PATH_MAX], tltname[MAXWORD];
553          FILE    *datin, *datout;
554  
555          if (!strcmp(tltspec, TLTNONE)) {
# Line 458 | Line 559 | char   *dir, *tltspec, *dfltname, *tltid;
559                  datin = in;
560                  strcpy(tltname, dfltname);
561          } else {
562 <                if (tltspec[0] == '/')
562 >                if (ISDIRSEP(tltspec[0]))
563                          strcpy(buf, tltspec);
564                  else
565 <                        strcpy(stradd(buf, dir, '/'), tltspec);
565 >                        strcpy(stradd(buf, dir, DIRSEP), tltspec);
566                  if ((datin = fopen(buf, "r")) == NULL) {
567                          perror(buf);
568                          return(-1);
# Line 469 | Line 570 | char   *dir, *tltspec, *dfltname, *tltid;
570                  tailtrunc(strcpy(tltname,filename(tltspec)));
571          }
572          if (datin != NULL) {
573 <                if ((datout = fopen(fullname(buf,tltname,T_TLT),"w")) == NULL) {
573 >                if ((datout = fopen(fullnam(buf,tltname,T_TLT),"w")) == NULL) {
574                          perror(buf);
575                          if (datin != in)
576                                  fclose(datin);
577                          return(-1);
578                  }
579 <                if (fscanf(datin, "%d %d", &tlt_type, &nangles) != 2
579 >                if (!scnint(datin,&tlt_type) || !scnint(datin,&nangles)
580                          || cvdata(datin,datout,1,&nangles,1.,minmax) != 0) {
581                          fprintf(stderr, "%s: data format error\n", tltspec);
582                          fclose(datout);
583                          if (datin != in)
584                                  fclose(datin);
585 <                        unlink(fullname(buf,tltname,T_TLT));
585 >                        unlink(fullnam(buf,tltname,T_TLT));
586                          return(-1);
587                  }
588                  fclose(datout);
# Line 515 | Line 616 | char   *dir, *tltspec, *dfltname, *tltid;
616   }
617  
618  
619 < dosource(in, out, mod, name)            /* create source and distribution */
619 > dosource(sinf, in, out, mod, name)      /* create source and distribution */
620 > SRCINFO *sinf;
621   FILE    *in, *out;
622   char    *mod, *name;
623   {
624 <        SHAPE   srcshape;
523 <        char    buf[MAXPATH], id[MAXWORD];
624 >        char    buf[PATH_MAX], id[MAXWORD];
625          FILE    *datout;
626          double  mult, bfactor, pfactor, width, length, height, wattage;
627          double  bounds[2][2];
628          int     nangles[2], pmtype, unitype;
629          double  d1;
630 +        int     doupper, dolower, dosides;
631  
632 <        if (fscanf(in, "%*d %*f %lf %d %d %d %d %lf %lf %lf %lf %lf %lf",
633 <                        &mult, &nangles[0], &nangles[1], &pmtype, &unitype,
634 <                        &width, &length, &height, &bfactor, &pfactor,
635 <                        &wattage) != 11) {
632 >        if (!isint(getword(in)) || !isflt(getword(in)) || !scnflt(in,&mult)
633 >                        || !scnint(in,&nangles[0]) || !scnint(in,&nangles[1])
634 >                        || !scnint(in,&pmtype) || !scnint(in,&unitype)
635 >                        || !scnflt(in,&width) || !scnflt(in,&length)
636 >                        || !scnflt(in,&height) || !scnflt(in,&bfactor)
637 >                        || !scnflt(in,&pfactor) || !scnflt(in,&wattage)) {
638                  fprintf(stderr, "dosource: bad lamp specification\n");
639                  return(-1);
640          }
641 +        sinf->mult = multiplier*mult*bfactor*pfactor;
642          if (nangles[0] < 2 || nangles[1] < 1) {
643                  fprintf(stderr, "dosource: too few measured angles\n");
644                  return(-1);
# Line 543 | Line 648 | char   *mod, *name;
648                  length *= F_M;
649                  height *= F_M;
650          }
651 <        if (makeshape(&srcshape, width, length, height) != 0) {
651 >        if (makeshape(sinf, width, length, height) != 0) {
652                  fprintf(stderr, "dosource: illegal source dimensions");
653                  return(-1);
654          }
655 <        if ((datout = fopen(fullname(buf,name,T_DST), "w")) == NULL) {
655 >        if ((datout = fopen(fullnam(buf,name,T_DST), "w")) == NULL) {
656                  perror(buf);
657                  return(-1);
658          }
659          if (cvdata(in, datout, 2, nangles, 1./WHTEFFICACY, bounds) != 0) {
660                  fprintf(stderr, "dosource: bad distribution data\n");
661                  fclose(datout);
662 <                unlink(fullname(buf,name,T_DST));
662 >                unlink(fullnam(buf,name,T_DST));
663                  return(-1);
664          }
665          fclose(datout);
# Line 567 | Line 672 | char   *mod, *name;
672          else if (pmtype == PM_B)
673                  fprintf(out, "5 ");
674          else if (FEQ(bounds[1][0],90.) && FEQ(bounds[1][1],270.))
675 <                fprintf(out, "8 ");
675 >                fprintf(out, "7 ");
676          else
677 <                fprintf(out, "6 ");
677 >                fprintf(out, "5 ");
678 >        dolower = (bounds[0][0] < 90.);
679 >        doupper = (bounds[0][1] > 90.);
680 >        dosides = (doupper & dolower && sinf->h > MINDIM);
681          fprintf(out, "%s %s source.cal ",
682 <                        srcshape.type==SPHERE ? "corr" : "flatcorr",
682 >                        sinf->type==SPHERE ? "corr" :
683 >                        !dosides ? "flatcorr" :
684 >                        sinf->type==DISK ? "cylcorr" : "boxcorr",
685                          libname(buf,name,T_DST));
686          if (pmtype == PM_B) {
687                  if (FEQ(bounds[1][0],0.))
# Line 579 | Line 689 | char   *mod, *name;
689                  else
690                          fprintf(out, "srcB_horiz ");
691                  fprintf(out, "srcB_vert ");
692 <        } else {
692 >        } else /* pmtype == PM_A */ {
693                  if (nangles[1] >= 2) {
694                          d1 = bounds[1][1] - bounds[1][0];
695                          if (d1 <= 90.+FTINY)
696                                  fprintf(out, "src_phi4 ");
697 <                        else if (d1 <= 180.+FTINY)
698 <                                fprintf(out, "src_phi2 ");
699 <                        else
697 >                        else if (d1 <= 180.+FTINY) {
698 >                                if (FEQ(bounds[1][0],90.))
699 >                                        fprintf(out, "src_phi2+90 ");
700 >                                else
701 >                                        fprintf(out, "src_phi2 ");
702 >                        } else
703                                  fprintf(out, "src_phi ");
704 <                        fprintf(out, "src_theta -my ");
704 >                        fprintf(out, "src_theta ");
705                          if (FEQ(bounds[1][0],90.) && FEQ(bounds[1][1],270.))
706                                  fprintf(out, "-rz -90 ");
707                  } else
708                          fprintf(out, "src_theta ");
709          }
710 <        fprintf(out, "\n0\n1 %g\n", multiplier*mult*bfactor*pfactor);
711 <        if (putsource(&srcshape, out, id, filename(name),
712 <                        bounds[0][0]<90., bounds[0][1]>90.) != 0)
710 >        if (!dosides || sinf->type == SPHERE)
711 >                fprintf(out, "\n0\n1 %g\n", sinf->mult/sinf->area);
712 >        else if (sinf->type == DISK)
713 >                fprintf(out, "\n0\n3 %g %g %g\n", sinf->mult,
714 >                                sinf->w, sinf->h);
715 >        else
716 >                fprintf(out, "\n0\n4 %g %g %g %g\n", sinf->mult,
717 >                                sinf->l, sinf->w, sinf->h);
718 >        if (putsource(sinf, out, id, filename(name),
719 >                        dolower, doupper, dosides) != 0)
720                  return(-1);
721          return(0);
722   }
723  
724  
725 < putsource(shp, fp, mod, name, dolower, doupper)         /* put out source */
726 < SHAPE   *shp;
725 > putsource(shp, fp, mod, name, dolower, doupper, dosides) /* put out source */
726 > SRCINFO *shp;
727   FILE    *fp;
728   char    *mod, *name;
729   int     dolower, doupper;
730   {
731 <        char    buf[MAXWORD];
731 >        char    lname[MAXWORD];
732          
733 <        fprintf(fp, "\n%s %s %s_light\n", mod,
734 <                        illumrad>=MINDIM/2. ? "illum" : "light",
735 <                        name);
733 >        strcat(strcpy(lname, name), "_light");
734 >        fprintf(fp, "\n%s %s %s\n", mod,
735 >                        shp->isillum ? "illum" : "light", lname);
736          fprintf(fp, "0\n0\n3 %g %g %g\n",
737 <                        lampcolor[0]/shp->area,
618 <                        lampcolor[1]/shp->area,
619 <                        lampcolor[2]/shp->area);
620 <        if (doupper && dolower && shp->type != SPHERE && shp->h > MINDIM) {
621 <                fprintf(fp, "\n%s glow %s_glow\n", mod, name);
622 <                fprintf(fp, "0\n0\n4 %g %g %g 0\n",
623 <                                lampcolor[0]/shp->area,
624 <                                lampcolor[1]/shp->area,
625 <                                lampcolor[2]/shp->area);
626 <        }
737 >                        lampcolor[0], lampcolor[1], lampcolor[2]);
738          switch (shp->type) {
739          case RECT:
629 –                strcat(strcpy(buf, name), "_light");
740                  if (dolower)
741 <                        putrectsrc(shp, fp, buf, name, 0);
741 >                        putrectsrc(shp, fp, lname, name, 0);
742                  if (doupper)
743 <                        putrectsrc(shp, fp, buf, name, 1);
744 <                if (doupper && dolower && shp->h > MINDIM) {
745 <                        strcat(strcpy(buf, name), "_glow");
636 <                        putsides(shp, fp, buf, name);
637 <                }
743 >                        putrectsrc(shp, fp, lname, name, 1);
744 >                if (dosides)
745 >                        putsides(shp, fp, lname, name);
746                  break;
747          case DISK:
640 –                strcat(strcpy(buf, name), "_light");
748                  if (dolower)
749 <                        putdisksrc(shp, fp, buf, name, 0);
749 >                        putdisksrc(shp, fp, lname, name, 0);
750                  if (doupper)
751 <                        putdisksrc(shp, fp, buf, name, 1);
752 <                if (doupper && dolower && shp->h > MINDIM) {
753 <                        strcat(strcpy(buf, name), "_glow");
647 <                        putcyl(shp, fp, buf, name);
648 <                }
751 >                        putdisksrc(shp, fp, lname, name, 1);
752 >                if (dosides)
753 >                        putcyl(shp, fp, lname, name);
754                  break;
755          case SPHERE:
756 <                strcat(strcpy(buf, name), "_light");
652 <                putspheresrc(shp, fp, buf, name);
756 >                putspheresrc(shp, fp, lname, name);
757                  break;
758          }
759          return(0);
# Line 657 | Line 761 | int    dolower, doupper;
761  
762  
763   makeshape(shp, width, length, height)           /* make source shape */
764 < register SHAPE  *shp;
764 > register SRCINFO        *shp;
765   double  width, length, height;
766   {
767 <        if (illumrad >= MINDIM/2.) {
767 >        if (illumrad/meters2out >= MINDIM/2.) {
768 >                shp->isillum = 1;
769                  shp->type = SPHERE;
770 <                shp->w = shp->l = shp->h = 2.*illumrad;
770 >                shp->w = shp->l = shp->h = 2.*illumrad / meters2out;
771          } else if (width < MINDIM) {
772                  width = -width;
773                  if (width < MINDIM) {
# Line 705 | Line 810 | double width, length, height;
810  
811  
812   putrectsrc(shp, fp, mod, name, up)              /* rectangular source */
813 < SHAPE   *shp;
813 > SRCINFO *shp;
814   FILE    *fp;
815   char    *mod, *name;
816   int     up;
# Line 718 | Line 823 | int    up;
823  
824  
825   putsides(shp, fp, mod, name)                    /* put out sides of box */
826 < register SHAPE  *shp;
826 > register SRCINFO        *shp;
827   FILE    *fp;
828   char    *mod, *name;
829   {
# Line 730 | Line 835 | char   *mod, *name;
835          
836  
837   putrect(shp, fp, mod, name, suffix, a, b, c, d) /* put out a rectangle */
838 < SHAPE   *shp;
838 > SRCINFO *shp;
839   FILE    *fp;
840   char    *mod, *name, *suffix;
841   int     a, b, c, d;
# Line 744 | Line 849 | int    a, b, c, d;
849  
850  
851   putpoint(shp, fp, p)                            /* put out a point */
852 < register SHAPE  *shp;
852 > register SRCINFO        *shp;
853   FILE    *fp;
854   int     p;
855   {
# Line 758 | Line 863 | int    p;
863  
864  
865   putdisksrc(shp, fp, mod, name, up)              /* put out a disk source */
866 < register SHAPE  *shp;
866 > register SRCINFO        *shp;
867   FILE    *fp;
868   char    *mod, *name;
869   int     up;
# Line 780 | Line 885 | int    up;
885  
886  
887   putcyl(shp, fp, mod, name)                      /* put out a cylinder */
888 < register SHAPE  *shp;
888 > register SRCINFO        *shp;
889   FILE    *fp;
890   char    *mod, *name;
891   {
# Line 793 | Line 898 | char   *mod, *name;
898  
899  
900   putspheresrc(shp, fp, mod, name)                /* put out a sphere source */
901 < SHAPE   *shp;
901 > SRCINFO *shp;
902   FILE    *fp;
903   char    *mod, *name;
904   {
# Line 807 | Line 912 | FILE   *in, *out;
912   int     ndim, npts[];
913   double  mult, lim[][2];
914   {
915 <        register double *pt[4];
915 >        double  *pt[4];
916          register int    i, j;
917          double  val;
918          int     total;
# Line 823 | Line 928 | double mult, lim[][2];
928          for (i = 0; i < ndim; i++) {
929                  pt[i] = (double *)malloc(npts[i]*sizeof(double));
930                  for (j = 0; j < npts[i]; j++)
931 <                        fscanf(in, "%lf", &pt[i][j]);
931 >                        if (!scnflt(in, &pt[i][j]))
932 >                                return(-1);
933                  if (lim != NULL) {
934                          lim[i][0] = pt[i][0];
935                          lim[i][1] = pt[i][npts[i]-1];
# Line 849 | Line 955 | double mult, lim[][2];
955                                  putc('\n', out);
956                          }
957                  }
958 <                free((char *)pt[i]);
958 >                free((void *)pt[i]);
959          }
960          for (i = 0; i < total; i++) {
961                  if (i%4 == 0)
962                          putc('\n', out);
963 <                if (fscanf(in, "%lf", &val) != 1)
963 >                if (!scnflt(in, &val))
964                          return(-1);
965                  fprintf(out, "\t%g", val*mult);
966          }
967          putc('\n', out);
968 +        return(0);
969 + }
970 +
971 +
972 + char *
973 + getword(fp)                     /* scan a word from fp */
974 + register FILE   *fp;
975 + {
976 +        static char     wrd[MAXWORD];
977 +        register char   *cp;
978 +        register int    c;
979 +
980 +        while (isspace(c=getc(fp)))
981 +                ;
982 +        for (cp = wrd; c != EOF && cp < wrd+MAXWORD-1;
983 +                        *cp++ = c, c = getc(fp))
984 +                if (isspace(c) || c == ',') {
985 +                        while (isspace(c))
986 +                                c = getc(fp);
987 +                        if (c != EOF & c != ',')
988 +                                ungetc(c, fp);
989 +                        *cp = '\0';
990 +                        return(wrd);
991 +                }
992 +        *cp = '\0';
993 +        return(cp > wrd ? wrd : NULL);
994 + }
995 +
996 +
997 + cvtint(ip, wrd)                 /* convert a word to an integer */
998 + int     *ip;
999 + char    *wrd;
1000 + {
1001 +        if (wrd == NULL || !isint(wrd))
1002 +                return(0);
1003 +        *ip = atoi(wrd);
1004 +        return(1);
1005 + }
1006 +
1007 +
1008 + cvtflt(rp, wrd)                 /* convert a word to a double */
1009 + double  *rp;
1010 + char    *wrd;
1011 + {
1012 +        if (wrd == NULL || !isflt(wrd))
1013 +                return(0);
1014 +        *rp = atof(wrd);
1015 +        return(1);
1016 + }
1017 +
1018 +
1019 + cvgeometry(inpname, sinf, outname, outfp)
1020 + char    *inpname;
1021 + register SRCINFO        *sinf;
1022 + char    *outname;
1023 + FILE    *outfp;                 /* close output file upon return */
1024 + {
1025 +        char    buf[256];
1026 +        register char   *cp;
1027 +
1028 +        if (inpname == NULL || !inpname[0]) {   /* no geometry file */
1029 +                fclose(outfp);
1030 +                return(0);
1031 +        }
1032 +        putc('\n', outfp);
1033 +        strcpy(buf, "mgf2rad ");                /* build mgf2rad command */
1034 +        cp = buf+8;
1035 +        if (!FEQ(sinf->mult, 1.0)) {
1036 +                sprintf(cp, "-m %f ", sinf->mult);
1037 +                cp += strlen(cp);
1038 +        }
1039 +        sprintf(cp, "-g %f %s ",
1040 +                sqrt(sinf->w*sinf->w + sinf->h*sinf->h + sinf->l*sinf->l),
1041 +                        inpname);
1042 +        cp += strlen(cp);
1043 +        if (instantiate) {              /* instantiate octree */
1044 +                strcpy(cp, "| oconv - > ");
1045 +                cp += 12;
1046 +                fullnam(cp,outname,T_OCT);
1047 +                if (fdate(inpname) > fdate(outname) &&
1048 +                                system(buf)) {          /* create octree */
1049 +                        fclose(outfp);
1050 +                        return(-1);
1051 +                }
1052 +                fprintf(outfp, "void instance %s_inst\n", outname);
1053 +                if (!FEQ(meters2out, 1.0))
1054 +                        fprintf(outfp, "3 %s -s %f\n",
1055 +                                        libname(buf,outname,T_OCT),
1056 +                                        meters2out);
1057 +                else
1058 +                        fprintf(outfp, "1 %s\n", libname(buf,outname,T_OCT));
1059 +                fprintf(outfp, "0\n0\n");
1060 +                fclose(outfp);
1061 +        } else {                        /* else append to luminaire file */
1062 +                if (!FEQ(meters2out, 1.0)) {    /* apply scalefactor */
1063 +                        sprintf(cp, "| xform -s %f ", meters2out);
1064 +                        cp += strlen(cp);
1065 +                }
1066 +                if (!out2stdout) {
1067 +                        fclose(outfp);
1068 +                        strcpy(cp, ">> ");      /* append works for DOS? */
1069 +                        cp += 3;
1070 +                        fullnam(cp,outname,T_RAD);
1071 +                }
1072 +                if (system(buf))
1073 +                        return(-1);
1074 +        }
1075          return(0);
1076   }

Diff Legend

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