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.30 by greg, Sat Jan 25 18:02:06 2014 UTC vs.
Revision 2.36 by greg, Fri May 23 17:02:07 2025 UTC

# Line 14 | Line 14 | static const char      RCSid[] = "$Id$";
14   #include "mgf_parser.h"
15   #include "color.h"
16   #include "tmesh.h"
17 + #include "lookup.h"
18  
19   #define putv(v)         printf("%18.12g %18.12g %18.12g\n",(v)[0],(v)[1],(v)[2])
20  
21   #define invert          (xf_context != NULL && xf_context->rev)
22  
23 + #define SGEN_DEF        "spec*"
24 + #define SGEN_RS         "rs_spec*"
25 + #define SGEN_TD         "td_spec*"
26 + #define SGEN_TS         "ts_spec*"
27 +
28 + char    void_str[] = "void";            /* global VOIDID */
29 + char    sgen_str[16] = SGEN_DEF;        /* generic specular */
30 +
31   double  glowdist = FHUGE;               /* glow test distance */
32  
33   double  emult = 1.;                     /* emitter multiplier */
34  
35   FILE    *matfp;                         /* material output file */
36  
37 + int     dospectra = 0;                  /* output spectral colors? */
38  
39 +
40   extern int r_comment(int ac, char **av);
41 + extern int r_color(int ac, char **av);
42   extern int r_cone(int ac, char **av);
43   extern int r_cyl(int ac, char **av);
44   extern int r_sph(int ac, char **av);
# Line 38 | Line 50 | extern char * material(void);
50   extern char * object(void);
51   extern char * addarg(char *op, char *arg);
52   extern void do_tri(char *mat, C_VERTEX *cv1, C_VERTEX *cv2, C_VERTEX *cv3, int iv);
53 < extern void cvtcolor(COLOR radrgb, register C_COLOR *ciec, double intensity);
53 > extern void cvtcolor(COLOR radrgb, C_COLOR *ciec, double intensity);
54 > extern int color_clash(int e1, int e2);
55 > extern int isgrey(COLOR rgb);
56 > extern void putrgbpat(char *pnm, COLOR rgb);
57 > extern char * specolor(COLOR radrgb, C_COLOR *ciec, double intensity);
58  
59  
60   int
# Line 57 | Line 73 | main(
73          mg_ehand[MG_E_COLOR] = c_hcolor;        /* they get color */
74          mg_ehand[MG_E_CONE] = r_cone;           /* we do cones */
75          mg_ehand[MG_E_CMIX] = c_hcolor;         /* they mix colors */
60 –        mg_ehand[MG_E_CSPEC] = c_hcolor;        /* they get spectra */
76          mg_ehand[MG_E_CXY] = c_hcolor;          /* they get chromaticities */
77 <        mg_ehand[MG_E_CCT] = c_hcolor;          /* they get color temp's */
77 >        mg_ehand[MG_E_CSPEC] = r_color;         /* we get spectra */
78 >        mg_ehand[MG_E_CCT] = r_color;           /* we get color temp's */
79          mg_ehand[MG_E_CYL] = r_cyl;             /* we do cylinders */
80          mg_ehand[MG_E_ED] = c_hmaterial;        /* they get emission */
81          mg_ehand[MG_E_FACE] = r_face;           /* we do faces */
# Line 104 | Line 120 | main(
120                          }
121                          printf(" %s", argv[i]);
122                          break;
123 +                case 's':                       /* spectral color output? */
124 +                        dospectra = !dospectra;
125 +                        break;
126                  default:
127                          goto userr;
128                  }
# Line 129 | Line 148 | main(
148                  }
149          exit(0);
150   userr:
151 <        fprintf(stderr, "Usage: %s [-g dist][-e mult][-m matf] [file.mgf] ..\n",
151 >        fprintf(stderr, "Usage: %s [-s][-g dist][-e mult][-m matf] [file.mgf] ..\n",
152                          argv[0]);
153          exit(1);
154   }
# Line 137 | Line 156 | userr:
156  
157   int
158   r_comment(              /* repeat a comment verbatim */
159 <        register int    ac,
160 <        register char   **av
159 >        int     ac,
160 >        char    **av
161   )
162   {
163          putchar('#');           /* use Radiance comment character */
# Line 152 | Line 171 | r_comment(             /* repeat a comment verbatim */
171  
172  
173   int
174 + r_color(                /* call color handler & remember name */
175 +        int     ac,
176 +        char    **av
177 + )
178 + {
179 +        int     rval = c_hcolor(ac, av);
180 +
181 +        if (rval == MG_OK)
182 +                c_ccolor->client_data = c_ccname;
183 +
184 +        return(rval);
185 + }
186 +
187 +
188 + int
189   r_cone(                 /* put out a cone */
190          int     ac,
191          char    **av
# Line 320 | Line 354 | r_face(                        /* convert a face */
354          static int      nfaces;
355          int             myi = invert;
356          char    *mat;
357 <        register int    i;
358 <        register C_VERTEX       *cv;
357 >        int     i;
358 >        C_VERTEX        *cv;
359          FVECT   v;
360  
361                                          /* check argument count and type */
# Line 381 | Line 415 | r_ies(                         /* convert an IES luminaire file */
415          char    combuf[128];
416          char    fname[48];
417          char    *oname;
418 <        register char   *op;
419 <        register int    i;
418 >        char    *op;
419 >        int     i;
420                                          /* check argument count */
421          if (ac < 2)
422                  return(MG_EARGC);
# Line 452 | Line 486 | do_tri(                /* put out smoothed triangle */
486          C_VERTEX        *cvt;
487          FVECT   v1, v2, v3;
488          FVECT   n1, n2, n3;
489 <        register int    i;
489 >        int     i;
490  
491          if (iv) {                       /* swap vertex order if inverted */
492                  cvt = cv1;
# Line 475 | Line 509 | do_tri(                /* put out smoothed triangle */
509                  bcoor[i][1] = n2[i];
510                  bcoor[i][2] = n3[i];
511          }
512 <        put_baryc(&bvecs, bcoor, 3);
512 >        fput_baryc(&bvecs, bcoor, 3, stdout);
513                                                  /* put out triangle */
514          printf("\nT-nor polygon %st%d\n", object(), ++ntris);
515          printf("0\n0\n9\n");
# Line 497 | Line 531 | char *
531   material(void)                  /* get (and print) current material */
532   {
533          char    *mname = "mat";
534 +        C_COLOR *refclr = NULL;
535 +        char    *pname;
536          COLOR   radrgb, c2;
537          double  d;
538  
# Line 507 | Line 543 | material(void)                 /* get (and print) current material *
543                                  /* else update output */
544          c_cmaterial->clock = 0;
545          if (c_cmaterial->ed > .1) {     /* emitter */
546 <                cvtcolor(radrgb, &c_cmaterial->ed_c,
546 >                pname = specolor(radrgb, &c_cmaterial->ed_c,
547                                  emult*c_cmaterial->ed/(PI*WHTEFFICACY));
548                  if (glowdist < FHUGE) {         /* do a glow */
549 <                        fprintf(matfp, "\nvoid glow %s\n0\n0\n", mname);
549 >                        fprintf(matfp, "\n%s glow %s\n0\n0\n", pname, mname);
550                          fprintf(matfp, "4 %f %f %f %f\n", colval(radrgb,RED),
551                                          colval(radrgb,GRN),
552                                          colval(radrgb,BLU), glowdist);
553                  } else {
554 <                        fprintf(matfp, "\nvoid light %s\n0\n0\n", mname);
554 >                        fprintf(matfp, "\n%s light %s\n0\n0\n", pname, mname);
555                          fprintf(matfp, "3 %f %f %f\n", colval(radrgb,RED),
556                                          colval(radrgb,GRN),
557                                          colval(radrgb,BLU));
# Line 552 | Line 588 | material(void)                 /* get (and print) current material *
588                                  colval(radrgb,GRN), colval(radrgb,BLU),
589                                  c_cmaterial->nr);
590                  return(mname);
591 +        }
592 +                                        /* check for WGMDfunc */
593 +        if (((c_cmaterial->rs > .02) & (c_cmaterial->ts > .02) &&
594 +                        fabs(c_cmaterial->rs_a - c_cmaterial->ts_a) > .02) ||
595 +                        ((c_cmaterial->rs > .05) & (c_cmaterial->rd > .05) &&
596 +                                !c_isgrey(&c_cmaterial->rs_c) &&
597 +                                !c_equiv(&c_cmaterial->rd_c, &c_cmaterial->rs_c)) ||
598 +                        color_clash(MG_E_TS, MG_E_TD) ||
599 +                        color_clash(MG_E_TD, MG_E_RD) ||
600 +                        color_clash(MG_E_RD, MG_E_TS)) {
601 +                COLOR   rs_rgb, ts_rgb, td_rgb; /* separate modifier paths */
602 +                char    rs_pname[128], ts_pname[128], td_pname[128];
603 +                strcpy(sgen_str, SGEN_RS);
604 +                strcpy(rs_pname, specolor(rs_rgb, &c_cmaterial->rs_c, c_cmaterial->rs));
605 +                strcpy(sgen_str, SGEN_TS);
606 +                strcpy(ts_pname, specolor(ts_rgb, &c_cmaterial->ts_c, c_cmaterial->ts));
607 +                strcpy(sgen_str, SGEN_TD);
608 +                strcpy(td_pname, specolor(td_rgb, &c_cmaterial->td_c, c_cmaterial->td));
609 +                strcpy(sgen_str, SGEN_DEF);
610 +                pname = specolor(radrgb, &c_cmaterial->rd_c, c_cmaterial->rd);
611 +                if (!strcmp(rs_pname, void_str) && !isgrey(rs_rgb)) {
612 +                        putrgbpat(strcpy(rs_pname,"rs_rgb*"), rs_rgb);
613 +                        colval(rs_rgb,GRN) = 1;
614                  }
615 +                if (!strcmp(ts_pname, void_str) && !isgrey(ts_rgb)) {
616 +                        putrgbpat(strcpy(ts_pname,"ts_rgb*"), ts_rgb);
617 +                        colval(ts_rgb,GRN) = 1;
618 +                }
619 +                fprintf(matfp, "\n%s WGMDfunc %s\n", pname, mname);
620 +                fprintf(matfp, "13\t%s %f %f %f\n", rs_pname, colval(rs_rgb,GRN),
621 +                                c_cmaterial->rs_a, c_cmaterial->rs_a);
622 +                fprintf(matfp, "\t%s %f %f %f\n", ts_pname, colval(ts_rgb,GRN),
623 +                                c_cmaterial->ts_a, c_cmaterial->ts_a);
624 +                fprintf(matfp, "\t%s\n\t0 0 1 .\n0\n", td_pname);
625 +                fprintf(matfp, "9\t%f %f %f\n", colval(radrgb,RED),
626 +                                colval(radrgb,GRN), colval(radrgb,BLU));
627 +                fprintf(matfp, "\t%f %f %f\n", colval(radrgb,RED),
628 +                                colval(radrgb,GRN), colval(radrgb,BLU));
629 +                fprintf(matfp, "\t%f %f %f\n", colval(td_rgb,RED),
630 +                                colval(td_rgb,GRN), colval(td_rgb,BLU));
631 +                if (c_cmaterial->sided)
632 +                        putsided(mname);
633 +                return(mname);
634 +        }
635                                          /* check for trans */
636 <        if (c_cmaterial->td > .01 || c_cmaterial->ts > .01) {
636 >        if (c_cmaterial->td + c_cmaterial->ts > .01) {
637                  double  a5, a6;
638                                                  /* average colors */
639                  d = c_cmaterial->rd + c_cmaterial->td + c_cmaterial->ts;
# Line 584 | Line 663 | material(void)                 /* get (and print) current material *
663                  return(mname);
664          }
665                                          /* check for plastic */
666 <        if (c_cmaterial->rs < .1) {
667 <                cvtcolor(radrgb, &c_cmaterial->rd_c,
666 >        if (c_cmaterial->rs < .1 && (c_cmaterial->rs < .1*c_cmaterial->rd ||
667 >                                        c_isgrey(&c_cmaterial->rs_c))) {
668 >                pname = specolor(radrgb, &c_cmaterial->rd_c,
669                                          c_cmaterial->rd/(1.-c_cmaterial->rs));
670 <                fprintf(matfp, "\nvoid plastic %s\n0\n0\n", mname);
670 >                fprintf(matfp, "\n%s plastic %s\n0\n0\n", pname, mname);
671                  fprintf(matfp, "5 %f %f %f %f %f\n", colval(radrgb,RED),
672                                  colval(radrgb,GRN), colval(radrgb,BLU),
673                                  c_cmaterial->rs, c_cmaterial->rs_a);
# Line 596 | Line 676 | material(void)                 /* get (and print) current material *
676                  return(mname);
677          }
678                                          /* else it's metal */
679 <                                                /* average colors */
680 <        cvtcolor(radrgb, &c_cmaterial->rd_c, c_cmaterial->rd);
681 <        cvtcolor(c2, &c_cmaterial->rs_c, c_cmaterial->rs);
682 <        addcolor(radrgb, c2);
683 <        fprintf(matfp, "\nvoid metal %s\n0\n0\n", mname);
679 >                                                /* compute color */
680 >        if (c_equiv(&c_cmaterial->rd_c, &c_cmaterial->rs_c)) {
681 >                pname = specolor(radrgb, &c_cmaterial->rs_c, c_cmaterial->rs+c_cmaterial->rd);
682 >        } else if (c_cmaterial->rd <= .05f) {
683 >                pname = specolor(radrgb, &c_cmaterial->rs_c, c_cmaterial->rs);
684 >                cvtcolor(c2, &c_cmaterial->rd_c, c_cmaterial->rd);
685 >                addcolor(radrgb, c2);
686 >        } else {
687 >                pname = "void";
688 >                cvtcolor(radrgb, &c_cmaterial->rd_c, c_cmaterial->rd);
689 >                cvtcolor(c2, &c_cmaterial->rs_c, c_cmaterial->rs);
690 >                addcolor(radrgb, c2);
691 >        }
692 >        fprintf(matfp, "\n%s metal %s\n0\n0\n", pname, mname);
693          fprintf(matfp, "5 %f %f %f %f %f\n", colval(radrgb,RED),
694                          colval(radrgb,GRN), colval(radrgb,BLU),
695                          c_cmaterial->rs/(c_cmaterial->rd + c_cmaterial->rs),
# Line 614 | Line 703 | material(void)                 /* get (and print) current material *
703   void
704   cvtcolor(       /* convert a CIE XYZ color to RGB */
705          COLOR   radrgb,
706 <        register C_COLOR        *ciec,
706 >        C_COLOR *ciec,
707          double  intensity
708   )
709   {
710 <        static COLOR    ciexyz;
710 >        COLOR   ciexyz;
711  
712 +        if (intensity <= 0) {
713 +                setcolor(radrgb, 0, 0, 0);
714 +                return;
715 +        }
716          c_ccvt(ciec, C_CSXY);           /* get xy representation */
717          ciexyz[1] = intensity;
718          ciexyz[0] = ciec->cx/ciec->cy*ciexyz[1];
# Line 628 | Line 721 | cvtcolor(      /* convert a CIE XYZ color to RGB */
721   }
722  
723  
724 + int color_clash(        /* do non-zero material components clash? */
725 +        int e1,
726 +        int e2
727 + )
728 + {
729 +        C_COLOR *c1;
730 +
731 +        if (e1 == e2)
732 +                return(0);
733 +        switch (e1) {
734 +        case MG_E_RD:
735 +                if (c_cmaterial->rd <= .01) return(0);
736 +                c1 = &c_cmaterial->rd_c;
737 +                break;
738 +        case MG_E_RS:
739 +                if (c_cmaterial->rs <= .01) return(0);
740 +                c1 = &c_cmaterial->rs_c;
741 +                break;
742 +        case MG_E_TD:
743 +                if (c_cmaterial->td <= .01) return(0);
744 +                c1 = &c_cmaterial->td_c;
745 +                break;
746 +        case MG_E_TS:
747 +                if (c_cmaterial->ts <= .01) return(0);
748 +                c1 = &c_cmaterial->ts_c;
749 +                break;
750 +        default:
751 +                return(0);
752 +        }
753 +        switch (e2) {
754 +        case MG_E_RD:
755 +                if (c_cmaterial->rd <= .01) return(0);
756 +                return(!c_equiv(c1, &c_cmaterial->rd_c));
757 +        case MG_E_RS:
758 +                if (c_cmaterial->rs <= .01) return(0);
759 +                return(!c_equiv(c1, &c_cmaterial->rs_c));
760 +        case MG_E_TD:
761 +                if (c_cmaterial->td <= .01) return(0);
762 +                return(!c_equiv(c1, &c_cmaterial->td_c));
763 +        case MG_E_TS:
764 +                if (c_cmaterial->ts <= .01) return(0);
765 +                return(!c_equiv(c1, &c_cmaterial->ts_c));
766 +        }
767 +        return(0);
768 + }
769 +
770 +
771 + static int      /* new spectrum definition? */
772 + newspecdef(C_COLOR *spc)
773 + {
774 +        static LUTAB    spc_tab = LU_SINIT(NULL,free);
775 +        LUENT   *lp = lu_find(&spc_tab, (const char *)spc->client_data);
776 +
777 +        if (lp == NULL)                 /* should never happen */
778 +                return(1);
779 +        if (lp->data == NULL) {         /* new entry */
780 +                lp->key = (char *)spc->client_data;
781 +                lp->data = (char *)malloc(sizeof(C_COLOR));
782 +        } else if (c_equiv(spc, (C_COLOR *)lp->data))
783 +                return(0);              /* unchanged */
784 +
785 +        if (lp->data != NULL)           /* else remember if we can */
786 +                *(C_COLOR *)lp->data = *spc;
787 +        return(1);                      /* good as new */
788 + }
789 +
790 +
791   char *
792 + specolor(       /* check if color has spectra and output accordingly */
793 +        COLOR   radrgb,
794 +        C_COLOR *clr,
795 +        double  intensity
796 + )
797 + {
798 +        static char     spname[128];
799 +        double  mult;
800 +        int     cbeg, cend, i;
801 +
802 +        if (!dospectra | !(clr->flags & C_CDSPEC) | (intensity <= FTINY)) {
803 +                cvtcolor(radrgb, clr, intensity);
804 +                return(void_str);               /* just use RGB */
805 +        }
806 +        setcolor(radrgb, intensity, intensity, intensity);
807 +        for (cbeg = 0; cbeg < C_CNSS; cbeg++)   /* trim zeros off beginning */
808 +                if (clr->ssamp[cbeg])
809 +                        break;
810 +        if (cbeg >= C_CNSS)                     /* should never happen! */
811 +                return(void_str);
812 +        if (clr->client_data != NULL) {         /* get name if available */
813 +                strcpy(spname, (char *)clr->client_data);
814 +                strcat(spname, "*");            /* make sure it's special */
815 +                if (!newspecdef(clr))           /* output already? */
816 +                        return(spname);
817 +        } else
818 +                strcpy(spname, sgen_str);
819 +        c_ccvt(clr, C_CSEFF);                   /* else output spectrum prim */
820 +        for (cend = 0; !clr->ssamp[C_CNSS-1-cend]; cend++)
821 +                ;                               /* trim zeros off end */
822 +        fprintf(matfp, "\nvoid spectrum %s\n0\n0\n", spname);
823 +        fprintf(matfp, "%d %d %d", C_CNSS+2-cbeg-cend,
824 +                C_CMINWL+cbeg*C_CWLI, C_CMAXWL-cend*C_CWLI);
825 +        mult = (C_CNSS*c_dfcolor.eff)/(clr->ssum*clr->eff);
826 +        for (i = cbeg; i < C_CNSS-cend; i++) {
827 +                if (!((i-cbeg+1)%6)) fputc('\n', matfp);
828 +                fprintf(matfp, "\t%.5f", clr->ssamp[i]*mult);
829 +        }
830 +        fputc('\n', matfp);
831 +        return(spname);
832 + }
833 +
834 +
835 + int
836 + isgrey(                         /* is RGB close match to grey? */
837 +        COLOR rgb
838 + )
839 + {
840 +        const double    yv = bright(rgb);
841 +        double          diff2 = 0;
842 +        int             i;
843 +
844 +        for (i = 3; i--; ) {
845 +                double  d = yv - colval(rgb,i);
846 +                diff2 += d*d;
847 +        }
848 +        return(diff2 <= yv*yv*0.0025);
849 + }
850 +
851 +
852 + void
853 + putrgbpat(                      /* put out RGB pattern with given name */
854 +        char *pnm,
855 +        COLOR rgb
856 + )
857 + {
858 +        fprintf(matfp, "\nvoid colorfunc %s\n", pnm);
859 +        fprintf(matfp, "4 %f %f %f .\n0\n0\n", colval(rgb,RED),
860 +                        colval(rgb,GRN), colval(rgb,BLU));
861 + }
862 +
863 +
864 + char *
865   object(void)                    /* return current object name */
866   {
867          static char     objbuf[64];
868 <        register int    i;
869 <        register char   *cp;
868 >        int     i;
869 >        char    *cp;
870          int     len;
871                                                  /* tracked by obj_handler */
872          i = obj_nnames - sizeof(objbuf)/16;
# Line 652 | Line 885 | object(void)                   /* return current object name */
885  
886   char *
887   addarg(                         /* add argument and advance pointer */
888 <        register char *op,
889 <        register char *arg
888 >        char *op,
889 >        char *arg
890   )
891   {
892          *op = ' ';

Diff Legend

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