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

Comparing ray/src/cv/mgf2rad.c (file contents):
Revision 2.14 by greg, Thu Apr 13 14:43:33 1995 UTC vs.
Revision 2.25 by greg, Sat Feb 22 02:07:23 2003 UTC

# Line 1 | Line 1
1 /* Copyright (c) 1994 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 MGF (Materials and Geometry Format) to Radiance
6   */
7  
8   #include <stdio.h>
9 + #include <stdlib.h>
10   #include <math.h>
11   #include <string.h>
12   #include "mgflib/parser.h"
# Line 23 | Line 21 | double glowdist = FHUGE;               /* glow test distance */
21  
22   double  emult = 1.;                     /* emitter multiplier */
23  
24 < FILE    *matfp = stdout;                /* material output file */
24 > FILE    *matfp;                         /* material output file */
25  
26   int     r_comment(), r_cone(), r_cyl(), r_face(), r_ies(), r_ring(), r_sph();
27   char    *material(), *object(), *addarg();
# Line 33 | Line 31 | main(argc, argv)               /* convert files to stdout */
31   int     argc;
32   char    *argv[];
33   {
34 <        int     i, rv;
34 >        int     i;
35 >
36 >        matfp = stdout;
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;
41 <        mg_ehand[MG_E_COLOR] = c_hcolor;
42 <        mg_ehand[MG_E_CONE] = r_cone;
43 <        mg_ehand[MG_E_CMIX] = c_hcolor;
44 <        mg_ehand[MG_E_CSPEC] = c_hcolor;
45 <        mg_ehand[MG_E_CXY] = c_hcolor;
46 <        mg_ehand[MG_E_CCT] = c_hcolor;
47 <        mg_ehand[MG_E_CYL] = r_cyl;
48 <        mg_ehand[MG_E_ED] = c_hmaterial;
49 <        mg_ehand[MG_E_FACE] = r_face;
50 <        mg_ehand[MG_E_IES] = r_ies;
51 <        mg_ehand[MG_E_IR] = c_hmaterial;
52 <        mg_ehand[MG_E_MATERIAL] = c_hmaterial;
53 <        mg_ehand[MG_E_NORMAL] = c_hvertex;
54 <        mg_ehand[MG_E_OBJECT] = obj_handler;
55 <        mg_ehand[MG_E_POINT] = c_hvertex;
56 <        mg_ehand[MG_E_RD] = c_hmaterial;
57 <        mg_ehand[MG_E_RING] = r_ring;
58 <        mg_ehand[MG_E_RS] = c_hmaterial;
59 <        mg_ehand[MG_E_SIDES] = c_hmaterial;
60 <        mg_ehand[MG_E_SPH] = r_sph;
61 <        mg_ehand[MG_E_TD] = c_hmaterial;
62 <        mg_ehand[MG_E_TS] = c_hmaterial;
63 <        mg_ehand[MG_E_VERTEX] = c_hvertex;
64 <        mg_ehand[MG_E_XF] = xf_handler;
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 options & print header */
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]);
# Line 92 | Line 94 | char   *argv[];
94          }
95          putchar('\n');
96          if (i == argc) {                /* convert stdin */
97 <                if ((rv = mg_load(NULL)) != MG_OK)
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 ((rv = mg_load(argv[i])) != MG_OK)
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:
# Line 115 | Line 125 | register int   ac;
125   register char   **av;
126   {
127          putchar('#');           /* use Radiance comment character */
128 <        while (--ac) {
128 >        while (--ac) {                  /* pass through verbatim */
129                  putchar(' ');
130                  fputs(*++av, stdout);
131          }
# Line 135 | Line 145 | char   **av;
145          C_VERTEX        *cv1, *cv2;
146          FVECT   p1, p2;
147          int     inv;
148 <
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);
157 >        xf_xfmpoint(p1, cv1->p);        /* transform endpoints */
158          xf_xfmpoint(p2, cv2->p);
159 <        r1 = xf_scale(atof(av[2]));
159 >        r1 = xf_scale(atof(av[2]));     /* scale radii */
160          r2 = xf_scale(atof(av[4]));
161 <        inv = r1 < 0.;
162 <        if (r1 == 0.) {
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.;
# Line 158 | Line 169 | char   **av;
169                  r1 = -r1;
170                  r2 = -r2;
171          }
172 <        if ((mat = material()) == NULL)
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");
# Line 181 | Line 193 | char   **av;
193          C_VERTEX        *cv1, *cv2;
194          FVECT   p1, p2;
195          int     inv;
196 <
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);
205 >        xf_xfmpoint(p1, cv1->p);        /* transform endpoints */
206          xf_xfmpoint(p2, cv2->p);
207 <        rad = xf_scale(atof(av[2]));
208 <        if ((inv = rad < 0.))
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)
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");
# Line 217 | Line 231 | char   **av;
231          C_VERTEX        *cv;
232          FVECT   cent;
233          int     inv;
234 <
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)
239 >        if ((cv = c_getvert(av[1])) == NULL)    /* get center vertex */
240                  return(MG_EUNDEF);
241 <        xf_xfmpoint(cent, cv->p);
242 <        rad = xf_scale(atof(av[2]));
243 <        if ((inv = rad < 0.))
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)
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",
# Line 248 | Line 263 | char   **av;
263          double  r1, r2;
264          C_VERTEX        *cv;
265          FVECT   cent, norm;
266 <
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)
271 >        if ((cv = c_getvert(av[1])) == NULL)    /* get center vertex */
272                  return(MG_EUNDEF);
273 <        if (is0vect(cv->n))
273 >        if (is0vect(cv->n))                     /* make sure we have normal */
274                  return(MG_EILL);
275 <        xf_xfmpoint(cent, cv->p);
276 <        xf_rotvect(norm, cv->n);
277 <        r1 = xf_scale(atof(av[2]));
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)
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);
# Line 280 | Line 296 | int    ac;
296   char    **av;
297   {
298          static int      nfaces;
299 +        int             myi = invert;
300          char    *mat;
301          register int    i;
302          register C_VERTEX       *cv;
303          FVECT   v;
304          int     rv;
305 <
305 >                                        /* check argument count and type */
306          if (ac < 4)
307                  return(MG_EARGC);
308 <        if ((mat = material()) == NULL)
308 >        if ((mat = material()) == NULL) /* get material */
309                  return(MG_EBADMAT);
310 <        if (ac <= 5) {                          /* check for surface normals */
310 >        if (ac <= 5) {                          /* check for smoothing */
311 >                C_VERTEX        *cva[5];
312                  for (i = 1; i < ac; i++) {
313 <                        if ((cv = c_getvert(av[i])) == NULL)
313 >                        if ((cva[i-1] = c_getvert(av[i])) == NULL)
314                                  return(MG_EUNDEF);
315 <                        if (is0vect(cv->n))
315 >                        if (is0vect(cva[i-1]->n))
316                                  break;
317                  }
318 <                if (i == ac) {                  /* break into triangles */
319 <                        do_tri(mat, av[1], av[2], av[3]);
318 >                if (i < ac)
319 >                        i = ISFLAT;
320 >                else
321 >                        i = flat_tri(cva[0]->p, cva[1]->p, cva[2]->p,
322 >                                        cva[0]->n, cva[1]->n, cva[2]->n);
323 >                if (i == DEGEN)
324 >                        return(MG_OK);          /* degenerate (error?) */
325 >                if (i == RVBENT) {
326 >                        myi = !myi;
327 >                        i = ISBENT;
328 >                } else if (i == RVFLAT) {
329 >                        myi = !myi;
330 >                        i = ISFLAT;
331 >                }
332 >                if (i == ISBENT) {              /* smoothed triangles */
333 >                        do_tri(mat, cva[0], cva[1], cva[2], myi);
334                          if (ac == 5)
335 <                                do_tri(mat, av[3], av[4], av[1]);
335 >                                do_tri(mat, cva[2], cva[3], cva[0], myi);
336                          return(MG_OK);
337                  }
338          }
339 +                                        /* spit out unsmoothed primitive */
340          printf("\n%s polygon %sf%d\n", mat, object(), ++nfaces);
341          printf("0\n0\n%d\n", 3*(ac-1));
342 <        for (i = 1; i < ac; i++) {
343 <                if ((cv = c_getvert(av[invert ? ac-i : i])) == NULL)
342 >        for (i = 1; i < ac; i++) {      /* get, transform, print each vertex */
343 >                if ((cv = c_getvert(av[myi ? ac-i : i])) == NULL)
344                          return(MG_EUNDEF);
345                  xf_xfmpoint(v, cv->p);
346                  putv(v);
# Line 316 | Line 349 | char   **av;
349   }
350  
351  
352 + int
353   r_ies(ac, av)                           /* convert an IES luminaire file */
354   int     ac;
355   char    **av;
356   {
357          int     xa0 = 2;
358 <        char    combuf[72];
358 >        char    combuf[128];
359          char    fname[48];
360          char    *oname;
361          register char   *op;
362          register int    i;
363 <
363 >                                        /* check argument count */
364          if (ac < 2)
365                  return(MG_EARGC);
366 <        (void)strcpy(combuf, "ies2rad");
367 <        op = combuf + 7;
368 <        if (ac-xa0 >= 2 && !strcmp(av[xa0], "-m")) {
369 <                if (!isflt(av[xa0+1]))
336 <                        return(MG_ETYPE);
337 <                op = addarg(addarg(op, "-m"), av[xa0+1]);
338 <                xa0 += 2;
339 <        }
340 <        if (access(av[1], 0) == -1)
341 <                return(MG_ENOFILE);
342 <        *op++ = ' ';                    /* IES filename goes last */
343 <        (void)strcpy(op, av[1]);
344 <        system(combuf);                 /* run ies2rad */
345 <                                        /* now let's find the output file */
346 <        if ((op = strrchr(av[1], '/')) == NULL)
366 >                                        /* construct output file name */
367 >        if ((op = strrchr(av[1], '/')) != NULL)
368 >                op++;
369 >        else
370                  op = av[1];
371          (void)strcpy(fname, op);
372          if ((op = strrchr(fname, '.')) == NULL)
373                  op = fname + strlen(fname);
374          (void)strcpy(op, ".rad");
375 <        if (access(fname, 0) == -1)
376 <                return(MG_EINCL);
377 <                                        /* put out xform command */
378 <        printf("\n!xform");
375 >                                        /* see if we need to run ies2rad */
376 >        if (access(fname, 0) == -1) {
377 >                (void)strcpy(combuf, "ies2rad");/* build ies2rad command */
378 >                op = combuf + 7;                /* get -m option (first) */
379 >                if (ac-xa0 >= 2 && !strcmp(av[xa0], "-m")) {
380 >                        if (!isflt(av[xa0+1]))
381 >                                return(MG_ETYPE);
382 >                        op = addarg(addarg(op, "-m"), av[xa0+1]);
383 >                        xa0 += 2;
384 >                }
385 >                *op++ = ' ';                    /* build IES filename */
386 >                i = 0;
387 >                if (mg_file != NULL &&
388 >                                (oname = strrchr(mg_file->fname,'/')) != NULL) {
389 >                        i = oname - mg_file->fname + 1;
390 >                        (void)strcpy(op, mg_file->fname);
391 >                }
392 >                (void)strcpy(op+i, av[1]);
393 >                if (access(op, 0) == -1)        /* check for file existence */
394 >                        return(MG_ENOFILE);
395 >                system(combuf);                 /* run ies2rad */
396 >                if (access(fname, 0) == -1)     /* check success */
397 >                        return(MG_EINCL);
398 >        }
399 >        printf("\n!xform");                     /* put out xform command */
400          oname = object();
401          if (*oname) {
402                  printf(" -n ");
# Line 370 | Line 414 | char   **av;
414   }
415  
416  
417 < do_tri(mat, vn1, vn2, vn3)              /* put out smoothed triangle */
418 < char    *mat, *vn1, *vn2, *vn3;
417 > do_tri(mat, cv1, cv2, cv3, iv)          /* put out smoothed triangle */
418 > char    *mat;
419 > C_VERTEX        *cv1, *cv2, *cv3;
420 > int     iv;
421   {
422          static int      ntris;
423          BARYCCM bvecs;
424          FLOAT   bcoor[3][3];
425 <        C_VERTEX        *cv1, *cv2, *cv3;
425 >        C_VERTEX        *cvt;
426          FVECT   v1, v2, v3;
427          FVECT   n1, n2, n3;
428          register int    i;
429 <                        /* the following is repeat code, so assume it's OK */
430 <        cv2 = c_getvert(vn2);
431 <        if (invert) {
432 <                cv3 = c_getvert(vn1);
433 <                cv1 = c_getvert(vn3);
388 <        } else {
389 <                cv1 = c_getvert(vn1);
390 <                cv3 = c_getvert(vn3);
429 >
430 >        if (iv) {                       /* swap vertex order if inverted */
431 >                cvt = cv1;
432 >                cv1 = cv3;
433 >                cv3 = cvt;
434          }
435          xf_xfmpoint(v1, cv1->p);
436          xf_xfmpoint(v2, cv2->p);
437          xf_xfmpoint(v3, cv3->p);
438 +                                        /* compute barycentric coords. */
439          if (comp_baryc(&bvecs, v1, v2, v3) < 0)
440                  return;                         /* degenerate triangle! */
441 <        printf("\n%s texfunc T-nor\n", mat);
441 >        printf("\n%s texfunc T-nor\n", mat);    /* put out texture */
442          printf("4 dx dy dz %s\n0\n", TCALNAME);
443          xf_rotvect(n1, cv1->n);
444          xf_rotvect(n2, cv2->n);
# Line 405 | Line 449 | char   *mat, *vn1, *vn2, *vn3;
449                  bcoor[i][2] = n3[i];
450          }
451          put_baryc(&bvecs, bcoor, 3);
452 +                                                /* put out triangle */
453          printf("\nT-nor polygon %st%d\n", object(), ++ntris);
454          printf("0\n0\n9\n");
455          putv(v1);
# Line 511 | Line 556 | material()                     /* get (and print) current material */
556                  return(mname);
557          }
558                                          /* check for plastic */
559 <        if (c_cmaterial->rs < .1 && (c_cmaterial->rs < .01 ||
515 <                                        c_isgrey(&c_cmaterial->rs_c))) {
559 >        if (c_cmaterial->rs < .1) {
560                  cvtcolor(radrgb, &c_cmaterial->rd_c,
561                                          c_cmaterial->rd/(1.-c_cmaterial->rs));
562                  fprintf(matfp, "\nvoid plastic %s\n0\n0\n", mname);
# Line 535 | Line 579 | material()                     /* get (and print) current material */
579   }
580  
581  
582 < cvtcolor(radrgb, ciec, intensity)       /* convert a CIE color to Radiance */
582 > cvtcolor(radrgb, ciec, intensity)       /* convert a CIE XYZ color to RGB */
583   COLOR   radrgb;
584   register C_COLOR        *ciec;
585   double  intensity;
# Line 557 | Line 601 | object()                       /* return current object name */
601          register int    i;
602          register char   *cp;
603          int     len;
604 <
604 >                                                /* tracked by obj_handler */
605          i = obj_nnames - sizeof(objbuf)/16;
606          if (i < 0)
607                  i = 0;

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines