cv/mgflib/context.c

#ifndef lint
static const char       RCSid[] = "$Id: context.c,v 1.27 2003/02/28 20:11:29 greg Exp $";
#endif
/*
 * Context handlers
 */

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include "parser.h"
#include "lookup.h"

                                /* default context values */
static C_COLOR          c_dfcolor = C_DEFCOLOR;
static C_MATERIAL       c_dfmaterial = C_DEFMATERIAL;
static C_VERTEX         c_dfvertex = C_DEFVERTEX;

                                /* the unnamed contexts */
static C_COLOR          c_uncolor = C_DEFCOLOR;
static C_MATERIAL       c_unmaterial = C_DEFMATERIAL;
static C_VERTEX         c_unvertex = C_DEFVERTEX;

                                /* the current contexts */
C_COLOR         *c_ccolor = &c_uncolor;
char            *c_ccname = NULL;
C_MATERIAL      *c_cmaterial = &c_unmaterial;
char            *c_cmname = NULL;
C_VERTEX        *c_cvertex = &c_unvertex;
char            *c_cvname = NULL;

static LUTAB    clr_tab = LU_SINIT(free,free);  /* color lookup table */
static LUTAB    mat_tab = LU_SINIT(free,free);  /* material lookup table */
static LUTAB    vtx_tab = LU_SINIT(free,free);  /* vertex lookup table */

                                /* CIE 1931 Standard Observer curves */
static C_COLOR  cie_xf = { 1, NULL, C_CDSPEC|C_CSSPEC|C_CSXY|C_CSEFF,
                        {14,42,143,435,1344,2839,3483,3362,2908,1954,956,
                        320,49,93,633,1655,2904,4334,5945,7621,9163,10263,
                        10622,10026,8544,6424,4479,2835,1649,874,468,227,
                        114,58,29,14,7,3,2,1,0}, 106836L, .467, .368, 362.230
                        };
static C_COLOR  cie_yf = { 1, NULL, C_CDSPEC|C_CSSPEC|C_CSXY|C_CSEFF,
                        {0,1,4,12,40,116,230,380,600,910,1390,2080,3230,
                        5030,7100,8620,9540,9950,9950,9520,8700,7570,6310,
                        5030,3810,2650,1750,1070,610,320,170,82,41,21,10,
                        5,2,1,1,0,0}, 106856L, .398, .542, 493.525
                        };
static C_COLOR  cie_zf = { 1, NULL, C_CDSPEC|C_CSSPEC|C_CSXY|C_CSEFF,
                        {65,201,679,2074,6456,13856,17471,17721,16692,
                        12876,8130,4652,2720,1582,782,422,203,87,39,21,17,
                        11,8,3,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
                        106770L, .147, .077, 54.363
                        };
                                /* Derived CIE 1931 Primaries (imaginary) */
static C_COLOR  cie_xp = { 1, NULL, C_CDSPEC|C_CSSPEC|C_CSXY,
                        {-174,-198,-195,-197,-202,-213,-235,-272,-333,
                        -444,-688,-1232,-2393,-4497,-6876,-6758,-5256,
                        -3100,-815,1320,3200,4782,5998,6861,7408,7754,
                        7980,8120,8199,8240,8271,8292,8309,8283,8469,
                        8336,8336,8336,8336,8336,8336},
                        127424L, 1., .0,
                        };
static C_COLOR  cie_yp = { 1, NULL, C_CDSPEC|C_CSSPEC|C_CSXY,
                        {-451,-431,-431,-430,-427,-417,-399,-366,-312,
                        -204,57,691,2142,4990,8810,9871,9122,7321,5145,
                        3023,1123,-473,-1704,-2572,-3127,-3474,-3704,
                        -3846,-3927,-3968,-3999,-4021,-4038,-4012,-4201,
                        -4066,-4066,-4066,-4066,-4066,-4066},
                        -23035L, .0, 1.,
                        };
static C_COLOR  cie_zp = { 1, NULL, C_CDSPEC|C_CSSPEC|C_CSXY,
                        {4051,4054,4052,4053,4054,4056,4059,4064,4071,
                        4074,4056,3967,3677,2933,1492,313,-440,-795,
                        -904,-918,-898,-884,-869,-863,-855,-855,-851,
                        -848,-847,-846,-846,-846,-845,-846,-843,-845,
                        -845,-845,-845,-845,-845},
                        36057L, .0, .0,
                        };

static int      setspectrum();
static int      setbbtemp();
static void     mixcolors();


int
c_hcolor(ac, av)                /* handle color entity */
int     ac;
register char   **av;
{
        double  w, wsum;
        register int    i;
        register LUENT  *lp;

        switch (mg_entity(av[0])) {
        case MG_E_COLOR:        /* get/set color context */
                if (ac > 4)
                        return(MG_EARGC);
                if (ac == 1) {          /* set unnamed color context */
                        c_uncolor = c_dfcolor;
                        c_ccolor = &c_uncolor;
                        c_ccname = NULL;
                        return(MG_OK);
                }
                if (!isname(av[1]))
                        return(MG_EILL);
                lp = lu_find(&clr_tab, av[1]);  /* lookup context */
                if (lp == NULL)
                        return(MG_EMEM);
                c_ccname = lp->key;
                c_ccolor = (C_COLOR *)lp->data;
                if (ac == 2) {          /* reestablish previous context */
                        if (c_ccolor == NULL)
                                return(MG_EUNDEF);
                        return(MG_OK);
                }
                if (av[2][0] != '=' || av[2][1])
                        return(MG_ETYPE);
                if (c_ccolor == NULL) { /* create new color context */
                        lp->key = (char *)malloc(strlen(av[1])+1);
                        if (lp->key == NULL)
                                return(MG_EMEM);
                        strcpy(lp->key, av[1]);
                        lp->data = (char *)malloc(sizeof(C_COLOR));
                        if (lp->data == NULL)
                                return(MG_EMEM);
                        c_ccname = lp->key;
                        c_ccolor = (C_COLOR *)lp->data;
                        c_ccolor->clock = 0;
                        c_ccolor->client_data = NULL;
                }
                i = c_ccolor->clock;
                if (ac == 3) {          /* use default template */
                        *c_ccolor = c_dfcolor;
                        c_ccolor->clock = i + 1;
                        return(MG_OK);
                }
                lp = lu_find(&clr_tab, av[3]);  /* lookup template */
                if (lp == NULL)
                        return(MG_EMEM);
                if (lp->data == NULL)
                        return(MG_EUNDEF);
                *c_ccolor = *(C_COLOR *)lp->data;
                c_ccolor->clock = i + 1;
                return(MG_OK);
        case MG_E_CXY:          /* assign CIE XY value */
                if (ac != 3)
                        return(MG_EARGC);
                if (!isflt(av[1]) | !isflt(av[2]))
                        return(MG_ETYPE);
                c_ccolor->cx = atof(av[1]);
                c_ccolor->cy = atof(av[2]);
                c_ccolor->flags = C_CDXY|C_CSXY;
                if ((c_ccolor->cx < 0.) | (c_ccolor->cy < 0.) |
                                (c_ccolor->cx + c_ccolor->cy > 1.))
                        return(MG_EILL);
                c_ccolor->clock++;
                return(MG_OK);
        case MG_E_CSPEC:        /* assign spectral values */
                if (ac < 5)
                        return(MG_EARGC);
                if (!isflt(av[1]) | !isflt(av[2]))
                        return(MG_ETYPE);
                return(setspectrum(c_ccolor, atof(av[1]), atof(av[2]),
                                ac-3, av+3));
        case MG_E_CCT:          /* assign black body spectrum */
                if (ac != 2)
                        return(MG_EARGC);
                if (!isflt(av[1]))
                        return(MG_ETYPE);
                return(setbbtemp(c_ccolor, atof(av[1])));
        case MG_E_CMIX:         /* mix colors */
                if (ac < 5 || (ac-1)%2)
                        return(MG_EARGC);
                if (!isflt(av[1]))
                        return(MG_ETYPE);
                wsum = atof(av[1]);
                if ((lp = lu_find(&clr_tab, av[2])) == NULL)
                        return(MG_EMEM);
                if (lp->data == NULL)
                        return(MG_EUNDEF);
                *c_ccolor = *(C_COLOR *)lp->data;
                for (i = 3; i < ac; i += 2) {
                        if (!isflt(av[i]))
                                return(MG_ETYPE);
                        w = atof(av[i]);
                        if ((lp = lu_find(&clr_tab, av[i+1])) == NULL)
                                return(MG_EMEM);
                        if (lp->data == NULL)
                                return(MG_EUNDEF);
                        mixcolors(c_ccolor, wsum, c_ccolor,
                                        w, (C_COLOR *)lp->data);
                        wsum += w;
                }
                if (wsum <= 0.)
                        return(MG_EILL);
                c_ccolor->clock++;
                return(MG_OK);
        }
        return(MG_EUNK);
}


int
c_hmaterial(ac, av)             /* handle material entity */
int     ac;
register char   **av;
{
        int     i;
        register LUENT  *lp;

        switch (mg_entity(av[0])) {
        case MG_E_MATERIAL:     /* get/set material context */
                if (ac > 4)
                        return(MG_EARGC);
                if (ac == 1) {          /* set unnamed material context */
                        c_unmaterial = c_dfmaterial;
                        c_cmaterial = &c_unmaterial;
                        c_cmname = NULL;
                        return(MG_OK);
                }
                if (!isname(av[1]))
                        return(MG_EILL);
                lp = lu_find(&mat_tab, av[1]);  /* lookup context */
                if (lp == NULL)
                        return(MG_EMEM);
                c_cmname = lp->key;
                c_cmaterial = (C_MATERIAL *)lp->data;
                if (ac == 2) {          /* reestablish previous context */
                        if (c_cmaterial == NULL)
                                return(MG_EUNDEF);
                        return(MG_OK);
                }
                if (av[2][0] != '=' || av[2][1])
                        return(MG_ETYPE);
                if (c_cmaterial == NULL) {      /* create new material */
                        lp->key = (char *)malloc(strlen(av[1])+1);
                        if (lp->key == NULL)
                                return(MG_EMEM);
                        strcpy(lp->key, av[1]);
                        lp->data = (char *)malloc(sizeof(C_MATERIAL));
                        if (lp->data == NULL)
                                return(MG_EMEM);
                        c_cmname = lp->key;
                        c_cmaterial = (C_MATERIAL *)lp->data;
                        c_cmaterial->clock = 0;
                        c_cmaterial->client_data = NULL;
                }
                i = c_cmaterial->clock;
                if (ac == 3) {          /* use default template */
                        *c_cmaterial = c_dfmaterial;
                        c_cmaterial->clock = i + 1;
                        return(MG_OK);
                }
                lp = lu_find(&mat_tab, av[3]);  /* lookup template */
                if (lp == NULL)
                        return(MG_EMEM);
                if (lp->data == NULL)
                        return(MG_EUNDEF);
                *c_cmaterial = *(C_MATERIAL *)lp->data;
                c_cmaterial->clock = i + 1;
                return(MG_OK);
        case MG_E_IR:           /* set index of refraction */
                if (ac != 3)
                        return(MG_EARGC);
                if (!isflt(av[1]) | !isflt(av[2]))
                        return(MG_ETYPE);
                c_cmaterial->nr = atof(av[1]);
                c_cmaterial->ni = atof(av[2]);
                if (c_cmaterial->nr <= FTINY)
                        return(MG_EILL);
                c_cmaterial->clock++;
                return(MG_OK);
        case MG_E_RD:           /* set diffuse reflectance */
                if (ac != 2)
                        return(MG_EARGC);
                if (!isflt(av[1]))
                        return(MG_ETYPE);
                c_cmaterial->rd = atof(av[1]);
                if ((c_cmaterial->rd < 0.) | (c_cmaterial->rd > 1.))
                        return(MG_EILL);
                c_cmaterial->rd_c = *c_ccolor;
                c_cmaterial->clock++;
                return(MG_OK);
        case MG_E_ED:           /* set diffuse emittance */
                if (ac != 2)
                        return(MG_EARGC);
                if (!isflt(av[1]))
                        return(MG_ETYPE);
                c_cmaterial->ed = atof(av[1]);
                if (c_cmaterial->ed < 0.)
                        return(MG_EILL);
                c_cmaterial->ed_c = *c_ccolor;
                c_cmaterial->clock++;
                return(MG_OK);
        case MG_E_TD:           /* set diffuse transmittance */
                if (ac != 2)
                        return(MG_EARGC);
                if (!isflt(av[1]))
                        return(MG_ETYPE);
                c_cmaterial->td = atof(av[1]);
                if ((c_cmaterial->td < 0.) | (c_cmaterial->td > 1.))
                        return(MG_EILL);
                c_cmaterial->td_c = *c_ccolor;
                c_cmaterial->clock++;
                return(MG_OK);
        case MG_E_RS:           /* set specular reflectance */
                if (ac != 3)
                        return(MG_EARGC);
                if (!isflt(av[1]) | !isflt(av[2]))
                        return(MG_ETYPE);
                c_cmaterial->rs = atof(av[1]);
                c_cmaterial->rs_a = atof(av[2]);
                if ((c_cmaterial->rs < 0.) | (c_cmaterial->rs > 1.) |
                                (c_cmaterial->rs_a < 0.))
                        return(MG_EILL);
                c_cmaterial->rs_c = *c_ccolor;
                c_cmaterial->clock++;
                return(MG_OK);
        case MG_E_TS:           /* set specular transmittance */
                if (ac != 3)
                        return(MG_EARGC);
                if (!isflt(av[1]) | !isflt(av[2]))
                        return(MG_ETYPE);
                c_cmaterial->ts = atof(av[1]);
                c_cmaterial->ts_a = atof(av[2]);
                if ((c_cmaterial->ts < 0.) | (c_cmaterial->ts > 1.) |
                                (c_cmaterial->ts_a < 0.))
                        return(MG_EILL);
                c_cmaterial->ts_c = *c_ccolor;
                c_cmaterial->clock++;
                return(MG_OK);
        case MG_E_SIDES:        /* set number of sides */
                if (ac != 2)
                        return(MG_EARGC);
                if (!isint(av[1]))
                        return(MG_ETYPE);
                i = atoi(av[1]);
                if (i == 1)
                        c_cmaterial->sided = 1;
                else if (i == 2)
                        c_cmaterial->sided = 0;
                else
                        return(MG_EILL);
                c_cmaterial->clock++;
                return(MG_OK);
        }
        return(MG_EUNK);
}


int
c_hvertex(ac, av)               /* handle a vertex entity */
int     ac;
register char   **av;
{
        int     i;
        register LUENT  *lp;

        switch (mg_entity(av[0])) {
        case MG_E_VERTEX:       /* get/set vertex context */
                if (ac > 4)
                        return(MG_EARGC);
                if (ac == 1) {          /* set unnamed vertex context */
                        c_unvertex = c_dfvertex;
                        c_cvertex = &c_unvertex;
                        c_cvname = NULL;
                        return(MG_OK);
                }
                if (!isname(av[1]))
                        return(MG_EILL);
                lp = lu_find(&vtx_tab, av[1]);  /* lookup context */
                if (lp == NULL)
                        return(MG_EMEM);
                c_cvname = lp->key;
                c_cvertex = (C_VERTEX *)lp->data;
                if (ac == 2) {          /* reestablish previous context */
                        if (c_cvertex == NULL)
                                return(MG_EUNDEF);
                        return(MG_OK);
                }
                if (av[2][0] != '=' || av[2][1])
                        return(MG_ETYPE);
                if (c_cvertex == NULL) {        /* create new vertex context */
                        lp->key = (char *)malloc(strlen(av[1])+1);
                        if (lp->key == NULL)
                                return(MG_EMEM);
                        strcpy(lp->key, av[1]);
                        lp->data = (char *)malloc(sizeof(C_VERTEX));
                        if (lp->data == NULL)
                                return(MG_EMEM);
                        c_cvname = lp->key;
                        c_cvertex = (C_VERTEX *)lp->data;
                        c_cvertex->clock = 0;
                        c_cvertex->client_data = NULL;
                }
                i = c_cvertex->clock;
                if (ac == 3) {          /* use default template */
                        *c_cvertex = c_dfvertex;
                        c_cvertex->clock = i + 1;
                        return(MG_OK);
                }
                lp = lu_find(&vtx_tab, av[3]);  /* lookup template */
                if (lp == NULL)
                        return(MG_EMEM);
                if (lp->data == NULL)
                        return(MG_EUNDEF);
                *c_cvertex = *(C_VERTEX *)lp->data;
                c_cvertex->clock = i + 1;
                return(MG_OK);
        case MG_E_POINT:        /* set point */
                if (ac != 4)
                        return(MG_EARGC);
                if (!isflt(av[1]) | !isflt(av[2]) | !isflt(av[3]))
                        return(MG_ETYPE);
                c_cvertex->p[0] = atof(av[1]);
                c_cvertex->p[1] = atof(av[2]);
                c_cvertex->p[2] = atof(av[3]);
                c_cvertex->clock++;
                return(MG_OK);
        case MG_E_NORMAL:       /* set normal */
                if (ac != 4)
                        return(MG_EARGC);
                if (!isflt(av[1]) | !isflt(av[2]) | !isflt(av[3]))
                        return(MG_ETYPE);
                c_cvertex->n[0] = atof(av[1]);
                c_cvertex->n[1] = atof(av[2]);
                c_cvertex->n[2] = atof(av[3]);
                (void)normalize(c_cvertex->n);
                c_cvertex->clock++;
                return(MG_OK);
        }
        return(MG_EUNK);
}


void
c_clearall()                    /* empty context tables */
{
        c_uncolor = c_dfcolor;
        c_ccolor = &c_uncolor;
        c_ccname = NULL;
        lu_done(&clr_tab);
        c_unmaterial = c_dfmaterial;
        c_cmaterial = &c_unmaterial;
        c_cmname = NULL;
        lu_done(&mat_tab);
        c_unvertex = c_dfvertex;
        c_cvertex = &c_unvertex;
        c_cvname = NULL;
        lu_done(&vtx_tab);
}


C_MATERIAL *
c_getmaterial(name)             /* get a named material */
char    *name;
{
        register LUENT  *lp;

        if ((lp = lu_find(&mat_tab, name)) == NULL)
                return(NULL);
        return((C_MATERIAL *)lp->data);
}


C_VERTEX *
c_getvert(name)                 /* get a named vertex */
char    *name;
{
        register LUENT  *lp;

        if ((lp = lu_find(&vtx_tab, name)) == NULL)
                return(NULL);
        return((C_VERTEX *)lp->data);
}


C_COLOR *
c_getcolor(name)                /* get a named color */
char    *name;
{
        register LUENT  *lp;

        if ((lp = lu_find(&clr_tab, name)) == NULL)
                return(NULL);
        return((C_COLOR *)lp->data);
}


int
c_isgrey(clr)                   /* check if color is grey */
register C_COLOR        *clr;
{
        if (!(clr->flags & (C_CSXY|C_CSSPEC)))
                return(1);              /* no settings == grey */
        c_ccvt(clr, C_CSXY);
        return(clr->cx >= .323 && clr->cx <= .343 &&
                        clr->cy >= .323 && clr->cy <= .343);
}


void
c_ccvt(clr, fl)                 /* convert color representations */
register C_COLOR        *clr;
int     fl;
{
        double  x, y, z;
        register int    i;

        fl &= ~clr->flags;                      /* ignore what's done */
        if (!fl)                                /* everything's done! */
                return;
        if (!(clr->flags & (C_CSXY|C_CSSPEC)))  /* nothing set! */
                *clr = c_dfcolor;
        if (fl & C_CSXY) {              /* cspec -> cxy */
                x = y = z = 0.;
                for (i = 0; i < C_CNSS; i++) {
                        x += cie_xf.ssamp[i] * clr->ssamp[i];
                        y += cie_yf.ssamp[i] * clr->ssamp[i];
                        z += cie_zf.ssamp[i] * clr->ssamp[i];
                }
                x /= (double)cie_xf.ssum;
                y /= (double)cie_yf.ssum;
                z /= (double)cie_zf.ssum;
                z += x + y;
                clr->cx = x / z;
                clr->cy = y / z;
                clr->flags |= C_CSXY;
        } else if (fl & C_CSSPEC) {     /* cxy -> cspec */
                x = clr->cx;
                y = clr->cy;
                z = 1. - x - y;
                clr->ssum = 0;
                for (i = 0; i < C_CNSS; i++) {
                        clr->ssamp[i] = x*cie_xp.ssamp[i] + y*cie_yp.ssamp[i]
                                        + z*cie_zp.ssamp[i] + .5;
                        if (clr->ssamp[i] < 0)          /* out of gamut! */
                                clr->ssamp[i] = 0;
                        else
                                clr->ssum += clr->ssamp[i];
                }
                clr->flags |= C_CSSPEC;
        }
        if (fl & C_CSEFF) {             /* compute efficacy */
                if (clr->flags & C_CSSPEC) {            /* from spectrum */
                        y = 0.;
                        for (i = 0; i < C_CNSS; i++)
                                y += cie_yf.ssamp[i] * clr->ssamp[i];
                        clr->eff = C_CLPWM * y / clr->ssum;
                } else /* clr->flags & C_CSXY */ {      /* from (x,y) */
                        clr->eff = clr->cx*cie_xf.eff + clr->cy*cie_yf.eff +
                                        (1. - clr->cx - clr->cy)*cie_zf.eff;
                }
                clr->flags |= C_CSEFF;
        }
}


static int
setspectrum(clr, wlmin, wlmax, ac, av)  /* convert a spectrum */
register C_COLOR        *clr;
double  wlmin, wlmax;
int     ac;
char    **av;
{
        double  scale;
        float   va[C_CNSS];
        register int    i, pos;
        int     n, imax;
        int     wl;
        double  wl0, wlstep;
        double  boxpos, boxstep;
                                        /* check bounds */
        if ((wlmax <= C_CMINWL) | (wlmax <= wlmin) | (wlmin >= C_CMAXWL))
                return(MG_EILL);
        wlstep = (wlmax - wlmin)/(ac-1);
        while (wlmin < C_CMINWL) {
                wlmin += wlstep;
                ac--; av++;
        }
        while (wlmax > C_CMAXWL) {
                wlmax -= wlstep;
                ac--;
        }
        imax = ac;                      /* box filter if necessary */
        boxpos = 0;
        boxstep = 1;
        if (wlstep < C_CWLI) {
                imax = (wlmax - wlmin)/C_CWLI + (1-FTINY);
                boxpos = (wlmin - C_CMINWL)/C_CWLI;
                boxstep = wlstep/C_CWLI;
                wlstep = C_CWLI;
        }
        scale = 0.;                     /* get values and maximum */
        pos = 0;
        for (i = 0; i < imax; i++) {
                va[i] = 0.; n = 0;
                while (boxpos < i+.5 && pos < ac) {
                        if (!isflt(av[pos]))
                                return(MG_ETYPE);
                        va[i] += atof(av[pos++]);
                        n++;
                        boxpos += boxstep;
                }
                if (n > 1)
                        va[i] /= (double)n;
                if (va[i] > scale)
                        scale = va[i];
                else if (va[i] < -scale)
                        scale = -va[i];
        }
        if (scale <= FTINY)
                return(MG_EILL);
        scale = C_CMAXV / scale;
        clr->ssum = 0;                  /* convert to our spacing */
        wl0 = wlmin;
        pos = 0;
        for (i = 0, wl = C_CMINWL; i < C_CNSS; i++, wl += C_CWLI)
                if ((wl < wlmin) | (wl > wlmax))
                        clr->ssamp[i] = 0;
                else {
                        while (wl0 + wlstep < wl+FTINY) {
                                wl0 += wlstep;
                                pos++;
                        }
                        if ((wl+FTINY >= wl0) & (wl-FTINY <= wl0))
                                clr->ssamp[i] = scale*va[pos] + .5;
                        else            /* interpolate if necessary */
                                clr->ssamp[i] = .5 + scale / wlstep *
                                                ( va[pos]*(wl0+wlstep - wl) +
                                                        va[pos+1]*(wl - wl0) );
                        clr->ssum += clr->ssamp[i];
                }
        clr->flags = C_CDSPEC|C_CSSPEC;
        clr->clock++;
        return(MG_OK);
}


static void
mixcolors(cres, w1, c1, w2, c2) /* mix two colors according to weights given */
register C_COLOR        *cres, *c1, *c2;
double  w1, w2;
{
        double  scale;
        float   cmix[C_CNSS];
        register int    i;

        if ((c1->flags|c2->flags) & C_CDSPEC) {         /* spectral mixing */
                c_ccvt(c1, C_CSSPEC|C_CSEFF);
                c_ccvt(c2, C_CSSPEC|C_CSEFF);
                w1 /= c1->eff*c1->ssum;
                w2 /= c2->eff*c2->ssum;
                scale = 0.;
                for (i = 0; i < C_CNSS; i++) {
                        cmix[i] = w1*c1->ssamp[i] + w2*c2->ssamp[i];
                        if (cmix[i] > scale)
                                scale = cmix[i];
                }
                scale = C_CMAXV / scale;
                cres->ssum = 0;
                for (i = 0; i < C_CNSS; i++)
                        cres->ssum += cres->ssamp[i] = scale*cmix[i] + .5;
                cres->flags = C_CDSPEC|C_CSSPEC;
        } else {                                        /* CIE xy mixing */
                c_ccvt(c1, C_CSXY);
                c_ccvt(c2, C_CSXY);
                scale = w1/c1->cy + w2/c2->cy;
                if (scale == 0.)
                        return;
                scale = 1. / scale;
                cres->cx = (c1->cx*w1/c1->cy + c2->cx*w2/c2->cy) * scale;
                cres->cy = (w1 + w2) * scale;
                cres->flags = C_CDXY|C_CSXY;
        }
}


#define C1              3.741832e-16    /* W-m^2 */
#define C2              1.4388e-2       /* m-K */

#define bbsp(l,t)       (C1/((l)*(l)*(l)*(l)*(l)*(exp(C2/((t)*(l)))-1.)))
#define bblm(t)         (C2/5./(t))

static int
setbbtemp(clr, tk)              /* set black body spectrum */
register C_COLOR        *clr;
double  tk;
{
        double  sf, wl;
        register int    i;

        if (tk < 1000)
                return(MG_EILL);
        wl = bblm(tk);                  /* scalefactor based on peak */
        if (wl < C_CMINWL*1e-9)
                wl = C_CMINWL*1e-9;
        else if (wl > C_CMAXWL*1e-9)
                wl = C_CMAXWL*1e-9;
        sf = C_CMAXV/bbsp(wl,tk);
        clr->ssum = 0;
        for (i = 0; i < C_CNSS; i++) {
                wl = (C_CMINWL + i*C_CWLI)*1e-9;
                clr->ssum += clr->ssamp[i] = sf*bbsp(wl,tk) + .5;
        }
        clr->flags = C_CDSPEC|C_CSSPEC;
        clr->clock++;
        return(MG_OK);
}

#undef  C1
#undef  C2
#undef  bbsp
#undef  bblm
Revision:	1.28
Committed:	Sun Jul 27 22:12:02 2003 UTC (20 years, 9 months ago) by schorsch
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad3R7P1, rad4R0, rad3R6, rad3R6P1, rad3R8, rad3R9, rad3R7P2
Changes since 1.27:	+12 -12 lines
Log Message:	Added grouping parens to reduce ambiguity warnings.
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	schorsch	1.28	static const char RCSid[] = "$Id: context.c,v 1.27 2003/02/28 20:11:29 greg Exp $";
3	greg	1.1	#endif
4			/*
5			* Context handlers
6			*/
7
8			#include <stdio.h>
9	greg	1.2	#include <math.h>
10	gregl	1.26	#include <stdlib.h>
11	greg	1.1	#include <string.h>
12			#include "parser.h"
13			#include "lookup.h"
14
15			/* default context values */
16			static C_COLOR c_dfcolor = C_DEFCOLOR;
17			static C_MATERIAL c_dfmaterial = C_DEFMATERIAL;
18			static C_VERTEX c_dfvertex = C_DEFVERTEX;
19
20			/* the unnamed contexts */
21			static C_COLOR c_uncolor = C_DEFCOLOR;
22			static C_MATERIAL c_unmaterial = C_DEFMATERIAL;
23			static C_VERTEX c_unvertex = C_DEFVERTEX;
24
25			/* the current contexts */
26			C_COLOR *c_ccolor = &c_uncolor;
27	greg	1.12	char *c_ccname = NULL;
28	greg	1.1	C_MATERIAL *c_cmaterial = &c_unmaterial;
29	greg	1.12	char *c_cmname = NULL;
30	greg	1.1	C_VERTEX *c_cvertex = &c_unvertex;
31	greg	1.12	char *c_cvname = NULL;
32	greg	1.1
33	greg	1.3	static LUTAB clr_tab = LU_SINIT(free,free); /* color lookup table */
34			static LUTAB mat_tab = LU_SINIT(free,free); /* material lookup table */
35			static LUTAB vtx_tab = LU_SINIT(free,free); /* vertex lookup table */
36	greg	1.1
37	greg	1.19	/* CIE 1931 Standard Observer curves */
38	gregl	1.25	static C_COLOR cie_xf = { 1, NULL, C_CDSPEC\|C_CSSPEC\|C_CSXY\|C_CSEFF,
39	greg	1.19	{14,42,143,435,1344,2839,3483,3362,2908,1954,956,
40			320,49,93,633,1655,2904,4334,5945,7621,9163,10263,
41			10622,10026,8544,6424,4479,2835,1649,874,468,227,
42			114,58,29,14,7,3,2,1,0}, 106836L, .467, .368, 362.230
43			};
44	gregl	1.25	static C_COLOR cie_yf = { 1, NULL, C_CDSPEC\|C_CSSPEC\|C_CSXY\|C_CSEFF,
45	greg	1.19	{0,1,4,12,40,116,230,380,600,910,1390,2080,3230,
46			5030,7100,8620,9540,9950,9950,9520,8700,7570,6310,
47			5030,3810,2650,1750,1070,610,320,170,82,41,21,10,
48			5,2,1,1,0,0}, 106856L, .398, .542, 493.525
49			};
50	gregl	1.25	static C_COLOR cie_zf = { 1, NULL, C_CDSPEC\|C_CSSPEC\|C_CSXY\|C_CSEFF,
51	greg	1.19	{65,201,679,2074,6456,13856,17471,17721,16692,
52			12876,8130,4652,2720,1582,782,422,203,87,39,21,17,
53			11,8,3,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
54			106770L, .147, .077, 54.363
55			};
56			/* Derived CIE 1931 Primaries (imaginary) */
57	gregl	1.25	static C_COLOR cie_xp = { 1, NULL, C_CDSPEC\|C_CSSPEC\|C_CSXY,
58	greg	1.19	{-174,-198,-195,-197,-202,-213,-235,-272,-333,
59			-444,-688,-1232,-2393,-4497,-6876,-6758,-5256,
60			-3100,-815,1320,3200,4782,5998,6861,7408,7754,
61			7980,8120,8199,8240,8271,8292,8309,8283,8469,
62			8336,8336,8336,8336,8336,8336},
63			127424L, 1., .0,
64			};
65	gregl	1.25	static C_COLOR cie_yp = { 1, NULL, C_CDSPEC\|C_CSSPEC\|C_CSXY,
66	greg	1.19	{-451,-431,-431,-430,-427,-417,-399,-366,-312,
67			-204,57,691,2142,4990,8810,9871,9122,7321,5145,
68			3023,1123,-473,-1704,-2572,-3127,-3474,-3704,
69			-3846,-3927,-3968,-3999,-4021,-4038,-4012,-4201,
70			-4066,-4066,-4066,-4066,-4066,-4066},
71			-23035L, .0, 1.,
72			};
73	gregl	1.25	static C_COLOR cie_zp = { 1, NULL, C_CDSPEC\|C_CSSPEC\|C_CSXY,
74	greg	1.19	{4051,4054,4052,4053,4054,4056,4059,4064,4071,
75			4074,4056,3967,3677,2933,1492,313,-440,-795,
76			-904,-918,-898,-884,-869,-863,-855,-855,-851,
77			-848,-847,-846,-846,-846,-845,-846,-843,-845,
78			-845,-845,-845,-845,-845},
79			36057L, .0, .0,
80			};
81	greg	1.1
82	greg	1.5	static int setspectrum();
83	greg	1.18	static int setbbtemp();
84	greg	1.5	static void mixcolors();
85
86
87	greg	1.1	int
88			c_hcolor(ac, av) /* handle color entity */
89			int ac;
90			register char **av;
91			{
92	greg	1.5	double w, wsum;
93			register int i;
94	greg	1.1	register LUENT *lp;
95
96			switch (mg_entity(av[0])) {
97			case MG_E_COLOR: /* get/set color context */
98	greg	1.4	if (ac > 4)
99			return(MG_EARGC);
100	greg	1.1	if (ac == 1) { /* set unnamed color context */
101			c_uncolor = c_dfcolor;
102			c_ccolor = &c_uncolor;
103	greg	1.12	c_ccname = NULL;
104	greg	1.1	return(MG_OK);
105			}
106	greg	1.22	if (!isname(av[1]))
107			return(MG_EILL);
108	greg	1.1	lp = lu_find(&clr_tab, av[1]); /* lookup context */
109			if (lp == NULL)
110			return(MG_EMEM);
111	greg	1.14	c_ccname = lp->key;
112	greg	1.9	c_ccolor = (C_COLOR *)lp->data;
113	greg	1.1	if (ac == 2) { /* reestablish previous context */
114	greg	1.9	if (c_ccolor == NULL)
115	greg	1.1	return(MG_EUNDEF);
116			return(MG_OK);
117			}
118			if (av[2][0] != '=' \|\| av[2][1])
119			return(MG_ETYPE);
120	greg	1.9	if (c_ccolor == NULL) { /* create new color context */
121	greg	1.1	lp->key = (char *)malloc(strlen(av[1])+1);
122			if (lp->key == NULL)
123			return(MG_EMEM);
124			strcpy(lp->key, av[1]);
125			lp->data = (char *)malloc(sizeof(C_COLOR));
126			if (lp->data == NULL)
127			return(MG_EMEM);
128	greg	1.14	c_ccname = lp->key;
129	greg	1.9	c_ccolor = (C_COLOR *)lp->data;
130			c_ccolor->clock = 0;
131	gregl	1.25	c_ccolor->client_data = NULL;
132	greg	1.1	}
133	greg	1.10	i = c_ccolor->clock;
134	greg	1.1	if (ac == 3) { /* use default template */
135			*c_ccolor = c_dfcolor;
136	greg	1.9	c_ccolor->clock = i + 1;
137	greg	1.1	return(MG_OK);
138			}
139			lp = lu_find(&clr_tab, av[3]); /* lookup template */
140			if (lp == NULL)
141			return(MG_EMEM);
142			if (lp->data == NULL)
143			return(MG_EUNDEF);
144			c_ccolor = (C_COLOR *)lp->data;
145	greg	1.9	c_ccolor->clock = i + 1;
146	greg	1.1	return(MG_OK);
147			case MG_E_CXY: /* assign CIE XY value */
148			if (ac != 3)
149			return(MG_EARGC);
150	greg	1.18	if (!isflt(av[1]) \| !isflt(av[2]))
151	greg	1.1	return(MG_ETYPE);
152			c_ccolor->cx = atof(av[1]);
153			c_ccolor->cy = atof(av[2]);
154	greg	1.5	c_ccolor->flags = C_CDXY\|C_CSXY;
155	schorsch	1.28	if ((c_ccolor->cx < 0.) \| (c_ccolor->cy < 0.) \|
156			(c_ccolor->cx + c_ccolor->cy > 1.))
157	greg	1.1	return(MG_EILL);
158	greg	1.8	c_ccolor->clock++;
159	greg	1.1	return(MG_OK);
160	greg	1.5	case MG_E_CSPEC: /* assign spectral values */
161			if (ac < 5)
162			return(MG_EARGC);
163	greg	1.18	if (!isflt(av[1]) \| !isflt(av[2]))
164	greg	1.5	return(MG_ETYPE);
165	greg	1.17	return(setspectrum(c_ccolor, atof(av[1]), atof(av[2]),
166	greg	1.5	ac-3, av+3));
167	greg	1.18	case MG_E_CCT: /* assign black body spectrum */
168			if (ac != 2)
169			return(MG_EARGC);
170			if (!isflt(av[1]))
171			return(MG_ETYPE);
172			return(setbbtemp(c_ccolor, atof(av[1])));
173	greg	1.5	case MG_E_CMIX: /* mix colors */
174			if (ac < 5 \|\| (ac-1)%2)
175			return(MG_EARGC);
176			if (!isflt(av[1]))
177			return(MG_ETYPE);
178			wsum = atof(av[1]);
179			if ((lp = lu_find(&clr_tab, av[2])) == NULL)
180			return(MG_EMEM);
181			if (lp->data == NULL)
182			return(MG_EUNDEF);
183			c_ccolor = (C_COLOR *)lp->data;
184			for (i = 3; i < ac; i += 2) {
185			if (!isflt(av[i]))
186			return(MG_ETYPE);
187			w = atof(av[i]);
188			if ((lp = lu_find(&clr_tab, av[i+1])) == NULL)
189			return(MG_EMEM);
190			if (lp->data == NULL)
191			return(MG_EUNDEF);
192			mixcolors(c_ccolor, wsum, c_ccolor,
193			w, (C_COLOR *)lp->data);
194			wsum += w;
195			}
196	greg	1.24	if (wsum <= 0.)
197			return(MG_EILL);
198	greg	1.10	c_ccolor->clock++;
199	greg	1.5	return(MG_OK);
200	greg	1.1	}
201			return(MG_EUNK);
202			}
203
204
205			int
206			c_hmaterial(ac, av) /* handle material entity */
207			int ac;
208			register char **av;
209			{
210	greg	1.9	int i;
211	greg	1.1	register LUENT *lp;
212
213			switch (mg_entity(av[0])) {
214			case MG_E_MATERIAL: /* get/set material context */
215	greg	1.4	if (ac > 4)
216			return(MG_EARGC);
217	greg	1.1	if (ac == 1) { /* set unnamed material context */
218			c_unmaterial = c_dfmaterial;
219			c_cmaterial = &c_unmaterial;
220	greg	1.12	c_cmname = NULL;
221	greg	1.1	return(MG_OK);
222			}
223	greg	1.22	if (!isname(av[1]))
224			return(MG_EILL);
225	greg	1.1	lp = lu_find(&mat_tab, av[1]); /* lookup context */
226			if (lp == NULL)
227			return(MG_EMEM);
228	greg	1.14	c_cmname = lp->key;
229	greg	1.9	c_cmaterial = (C_MATERIAL *)lp->data;
230	greg	1.1	if (ac == 2) { /* reestablish previous context */
231	greg	1.9	if (c_cmaterial == NULL)
232	greg	1.1	return(MG_EUNDEF);
233			return(MG_OK);
234			}
235			if (av[2][0] != '=' \|\| av[2][1])
236			return(MG_ETYPE);
237	greg	1.9	if (c_cmaterial == NULL) { /* create new material */
238	greg	1.1	lp->key = (char *)malloc(strlen(av[1])+1);
239			if (lp->key == NULL)
240			return(MG_EMEM);
241			strcpy(lp->key, av[1]);
242			lp->data = (char *)malloc(sizeof(C_MATERIAL));
243			if (lp->data == NULL)
244			return(MG_EMEM);
245	greg	1.14	c_cmname = lp->key;
246	greg	1.9	c_cmaterial = (C_MATERIAL *)lp->data;
247			c_cmaterial->clock = 0;
248	gregl	1.25	c_cmaterial->client_data = NULL;
249	greg	1.1	}
250	greg	1.10	i = c_cmaterial->clock;
251	greg	1.1	if (ac == 3) { /* use default template */
252			*c_cmaterial = c_dfmaterial;
253	greg	1.9	c_cmaterial->clock = i + 1;
254	greg	1.1	return(MG_OK);
255			}
256			lp = lu_find(&mat_tab, av[3]); /* lookup template */
257			if (lp == NULL)
258			return(MG_EMEM);
259			if (lp->data == NULL)
260			return(MG_EUNDEF);
261			c_cmaterial = (C_MATERIAL *)lp->data;
262	greg	1.9	c_cmaterial->clock = i + 1;
263	greg	1.1	return(MG_OK);
264	greg	1.21	case MG_E_IR: /* set index of refraction */
265			if (ac != 3)
266			return(MG_EARGC);
267			if (!isflt(av[1]) \| !isflt(av[2]))
268			return(MG_ETYPE);
269			c_cmaterial->nr = atof(av[1]);
270			c_cmaterial->ni = atof(av[2]);
271			if (c_cmaterial->nr <= FTINY)
272			return(MG_EILL);
273			c_cmaterial->clock++;
274			return(MG_OK);
275	greg	1.1	case MG_E_RD: /* set diffuse reflectance */
276			if (ac != 2)
277			return(MG_EARGC);
278			if (!isflt(av[1]))
279			return(MG_ETYPE);
280			c_cmaterial->rd = atof(av[1]);
281	schorsch	1.28	if ((c_cmaterial->rd < 0.) \| (c_cmaterial->rd > 1.))
282	greg	1.1	return(MG_EILL);
283			c_cmaterial->rd_c = *c_ccolor;
284	greg	1.2	c_cmaterial->clock++;
285	greg	1.1	return(MG_OK);
286			case MG_E_ED: /* set diffuse emittance */
287			if (ac != 2)
288			return(MG_EARGC);
289			if (!isflt(av[1]))
290			return(MG_ETYPE);
291			c_cmaterial->ed = atof(av[1]);
292			if (c_cmaterial->ed < 0.)
293			return(MG_EILL);
294			c_cmaterial->ed_c = *c_ccolor;
295	greg	1.2	c_cmaterial->clock++;
296	greg	1.1	return(MG_OK);
297			case MG_E_TD: /* set diffuse transmittance */
298			if (ac != 2)
299			return(MG_EARGC);
300			if (!isflt(av[1]))
301			return(MG_ETYPE);
302			c_cmaterial->td = atof(av[1]);
303	schorsch	1.28	if ((c_cmaterial->td < 0.) \| (c_cmaterial->td > 1.))
304	greg	1.1	return(MG_EILL);
305			c_cmaterial->td_c = *c_ccolor;
306	greg	1.8	c_cmaterial->clock++;
307	greg	1.1	return(MG_OK);
308			case MG_E_RS: /* set specular reflectance */
309			if (ac != 3)
310			return(MG_EARGC);
311	greg	1.18	if (!isflt(av[1]) \| !isflt(av[2]))
312	greg	1.1	return(MG_ETYPE);
313			c_cmaterial->rs = atof(av[1]);
314			c_cmaterial->rs_a = atof(av[2]);
315	schorsch	1.28	if ((c_cmaterial->rs < 0.) \| (c_cmaterial->rs > 1.) \|
316			(c_cmaterial->rs_a < 0.))
317	greg	1.1	return(MG_EILL);
318			c_cmaterial->rs_c = *c_ccolor;
319	greg	1.2	c_cmaterial->clock++;
320	greg	1.1	return(MG_OK);
321			case MG_E_TS: /* set specular transmittance */
322			if (ac != 3)
323			return(MG_EARGC);
324	greg	1.18	if (!isflt(av[1]) \| !isflt(av[2]))
325	greg	1.1	return(MG_ETYPE);
326			c_cmaterial->ts = atof(av[1]);
327			c_cmaterial->ts_a = atof(av[2]);
328	schorsch	1.28	if ((c_cmaterial->ts < 0.) \| (c_cmaterial->ts > 1.) \|
329			(c_cmaterial->ts_a < 0.))
330	greg	1.1	return(MG_EILL);
331			c_cmaterial->ts_c = *c_ccolor;
332	greg	1.2	c_cmaterial->clock++;
333	greg	1.1	return(MG_OK);
334	greg	1.13	case MG_E_SIDES: /* set number of sides */
335			if (ac != 2)
336			return(MG_EARGC);
337			if (!isint(av[1]))
338			return(MG_ETYPE);
339			i = atoi(av[1]);
340			if (i == 1)
341			c_cmaterial->sided = 1;
342			else if (i == 2)
343			c_cmaterial->sided = 0;
344			else
345			return(MG_EILL);
346			c_cmaterial->clock++;
347			return(MG_OK);
348	greg	1.1	}
349			return(MG_EUNK);
350			}
351
352
353			int
354			c_hvertex(ac, av) /* handle a vertex entity */
355			int ac;
356			register char **av;
357			{
358	greg	1.9	int i;
359	greg	1.1	register LUENT *lp;
360
361			switch (mg_entity(av[0])) {
362			case MG_E_VERTEX: /* get/set vertex context */
363	greg	1.4	if (ac > 4)
364			return(MG_EARGC);
365	greg	1.1	if (ac == 1) { /* set unnamed vertex context */
366			c_unvertex = c_dfvertex;
367			c_cvertex = &c_unvertex;
368	greg	1.12	c_cvname = NULL;
369	greg	1.1	return(MG_OK);
370			}
371	greg	1.22	if (!isname(av[1]))
372			return(MG_EILL);
373	greg	1.1	lp = lu_find(&vtx_tab, av[1]); /* lookup context */
374			if (lp == NULL)
375			return(MG_EMEM);
376	greg	1.14	c_cvname = lp->key;
377	greg	1.9	c_cvertex = (C_VERTEX *)lp->data;
378	greg	1.1	if (ac == 2) { /* reestablish previous context */
379	greg	1.9	if (c_cvertex == NULL)
380	greg	1.1	return(MG_EUNDEF);
381			return(MG_OK);
382			}
383			if (av[2][0] != '=' \|\| av[2][1])
384			return(MG_ETYPE);
385	greg	1.9	if (c_cvertex == NULL) { /* create new vertex context */
386	greg	1.1	lp->key = (char *)malloc(strlen(av[1])+1);
387			if (lp->key == NULL)
388			return(MG_EMEM);
389			strcpy(lp->key, av[1]);
390			lp->data = (char *)malloc(sizeof(C_VERTEX));
391			if (lp->data == NULL)
392			return(MG_EMEM);
393	greg	1.14	c_cvname = lp->key;
394	greg	1.9	c_cvertex = (C_VERTEX *)lp->data;
395	gregl	1.25	c_cvertex->clock = 0;
396			c_cvertex->client_data = NULL;
397	greg	1.1	}
398	greg	1.10	i = c_cvertex->clock;
399	greg	1.1	if (ac == 3) { /* use default template */
400			*c_cvertex = c_dfvertex;
401	greg	1.9	c_cvertex->clock = i + 1;
402	greg	1.1	return(MG_OK);
403			}
404			lp = lu_find(&vtx_tab, av[3]); /* lookup template */
405			if (lp == NULL)
406			return(MG_EMEM);
407			if (lp->data == NULL)
408			return(MG_EUNDEF);
409			c_cvertex = (C_VERTEX *)lp->data;
410	greg	1.9	c_cvertex->clock = i + 1;
411	greg	1.1	return(MG_OK);
412			case MG_E_POINT: /* set point */
413			if (ac != 4)
414			return(MG_EARGC);
415	greg	1.18	if (!isflt(av[1]) \| !isflt(av[2]) \| !isflt(av[3]))
416	greg	1.1	return(MG_ETYPE);
417			c_cvertex->p[0] = atof(av[1]);
418			c_cvertex->p[1] = atof(av[2]);
419			c_cvertex->p[2] = atof(av[3]);
420	greg	1.8	c_cvertex->clock++;
421	greg	1.1	return(MG_OK);
422			case MG_E_NORMAL: /* set normal */
423			if (ac != 4)
424			return(MG_EARGC);
425	greg	1.18	if (!isflt(av[1]) \| !isflt(av[2]) \| !isflt(av[3]))
426	greg	1.1	return(MG_ETYPE);
427			c_cvertex->n[0] = atof(av[1]);
428			c_cvertex->n[1] = atof(av[2]);
429			c_cvertex->n[2] = atof(av[3]);
430			(void)normalize(c_cvertex->n);
431	greg	1.8	c_cvertex->clock++;
432	greg	1.1	return(MG_OK);
433			}
434			return(MG_EUNK);
435			}
436
437
438			void
439			c_clearall() /* empty context tables */
440			{
441			c_uncolor = c_dfcolor;
442			c_ccolor = &c_uncolor;
443	greg	1.15	c_ccname = NULL;
444	greg	1.3	lu_done(&clr_tab);
445	greg	1.1	c_unmaterial = c_dfmaterial;
446			c_cmaterial = &c_unmaterial;
447	greg	1.15	c_cmname = NULL;
448	greg	1.3	lu_done(&mat_tab);
449	greg	1.1	c_unvertex = c_dfvertex;
450			c_cvertex = &c_unvertex;
451	greg	1.15	c_cvname = NULL;
452	greg	1.3	lu_done(&vtx_tab);
453	greg	1.1	}
454
455
456	greg	1.11	C_MATERIAL *
457			c_getmaterial(name) /* get a named material */
458			char *name;
459			{
460			register LUENT *lp;
461
462			if ((lp = lu_find(&mat_tab, name)) == NULL)
463			return(NULL);
464			return((C_MATERIAL *)lp->data);
465			}
466
467
468	greg	1.1	C_VERTEX *
469			c_getvert(name) /* get a named vertex */
470			char *name;
471			{
472			register LUENT *lp;
473
474			if ((lp = lu_find(&vtx_tab, name)) == NULL)
475			return(NULL);
476			return((C_VERTEX *)lp->data);
477	greg	1.5	}
478
479
480	greg	1.7	C_COLOR *
481			c_getcolor(name) /* get a named color */
482			char *name;
483			{
484			register LUENT *lp;
485
486			if ((lp = lu_find(&clr_tab, name)) == NULL)
487			return(NULL);
488			return((C_COLOR *)lp->data);
489			}
490
491
492	greg	1.5	int
493			c_isgrey(clr) /* check if color is grey */
494			register C_COLOR *clr;
495			{
496	greg	1.8	if (!(clr->flags & (C_CSXY\|C_CSSPEC)))
497	greg	1.5	return(1); /* no settings == grey */
498			c_ccvt(clr, C_CSXY);
499			return(clr->cx >= .323 && clr->cx <= .343 &&
500			clr->cy >= .323 && clr->cy <= .343);
501			}
502
503
504			void
505			c_ccvt(clr, fl) /* convert color representations */
506			register C_COLOR *clr;
507			int fl;
508			{
509			double x, y, z;
510			register int i;
511
512	greg	1.16	fl &= ~clr->flags; /* ignore what's done */
513			if (!fl) /* everything's done! */
514	greg	1.5	return;
515	greg	1.8	if (!(clr->flags & (C_CSXY\|C_CSSPEC))) /* nothing set! */
516	greg	1.5	*clr = c_dfcolor;
517	greg	1.16	if (fl & C_CSXY) { /* cspec -> cxy */
518	greg	1.5	x = y = z = 0.;
519			for (i = 0; i < C_CNSS; i++) {
520			x += cie_xf.ssamp[i] * clr->ssamp[i];
521			y += cie_yf.ssamp[i] * clr->ssamp[i];
522			z += cie_zf.ssamp[i] * clr->ssamp[i];
523			}
524	greg	1.17	x /= (double)cie_xf.ssum;
525			y /= (double)cie_yf.ssum;
526			z /= (double)cie_zf.ssum;
527	greg	1.5	z += x + y;
528			clr->cx = x / z;
529			clr->cy = y / z;
530			clr->flags \|= C_CSXY;
531	greg	1.16	} else if (fl & C_CSSPEC) { /* cxy -> cspec */
532	greg	1.19	x = clr->cx;
533			y = clr->cy;
534			z = 1. - x - y;
535	greg	1.5	clr->ssum = 0;
536	greg	1.19	for (i = 0; i < C_CNSS; i++) {
537			clr->ssamp[i] = xcie_xp.ssamp[i] + ycie_yp.ssamp[i]
538			+ z*cie_zp.ssamp[i] + .5;
539			if (clr->ssamp[i] < 0) /* out of gamut! */
540			clr->ssamp[i] = 0;
541			else
542			clr->ssum += clr->ssamp[i];
543			}
544	greg	1.5	clr->flags \|= C_CSSPEC;
545			}
546	greg	1.16	if (fl & C_CSEFF) { /* compute efficacy */
547	greg	1.19	if (clr->flags & C_CSSPEC) { /* from spectrum */
548	greg	1.16	y = 0.;
549			for (i = 0; i < C_CNSS; i++)
550			y += cie_yf.ssamp[i] * clr->ssamp[i];
551			clr->eff = C_CLPWM * y / clr->ssum;
552	greg	1.19	} else /* clr->flags & C_CSXY / { / from (x,y) */
553	greg	1.16	clr->eff = clr->cxcie_xf.eff + clr->cycie_yf.eff +
554			(1. - clr->cx - clr->cy)*cie_zf.eff;
555			}
556			clr->flags \|= C_CSEFF;
557			}
558	greg	1.5	}
559
560
561			static int
562			setspectrum(clr, wlmin, wlmax, ac, av) /* convert a spectrum */
563			register C_COLOR *clr;
564	greg	1.17	double wlmin, wlmax;
565	greg	1.5	int ac;
566			char **av;
567			{
568			double scale;
569	greg	1.17	float va[C_CNSS];
570			register int i, pos;
571			int n, imax;
572			int wl;
573	greg	1.5	double wl0, wlstep;
574	greg	1.20	double boxpos, boxstep;
575	greg	1.17	/* check bounds */
576	schorsch	1.28	if ((wlmax <= C_CMINWL) \| (wlmax <= wlmin) \| (wlmin >= C_CMAXWL))
577	greg	1.5	return(MG_EILL);
578	greg	1.17	wlstep = (wlmax - wlmin)/(ac-1);
579			while (wlmin < C_CMINWL) {
580			wlmin += wlstep;
581			ac--; av++;
582			}
583			while (wlmax > C_CMAXWL) {
584			wlmax -= wlstep;
585			ac--;
586			}
587			imax = ac; /* box filter if necessary */
588	greg	1.20	boxpos = 0;
589			boxstep = 1;
590	greg	1.17	if (wlstep < C_CWLI) {
591	greg	1.20	imax = (wlmax - wlmin)/C_CWLI + (1-FTINY);
592			boxpos = (wlmin - C_CMINWL)/C_CWLI;
593			boxstep = wlstep/C_CWLI;
594	greg	1.17	wlstep = C_CWLI;
595			}
596	greg	1.5	scale = 0.; /* get values and maximum */
597	greg	1.17	pos = 0;
598			for (i = 0; i < imax; i++) {
599			va[i] = 0.; n = 0;
600	greg	1.20	while (boxpos < i+.5 && pos < ac) {
601	greg	1.17	if (!isflt(av[pos]))
602			return(MG_ETYPE);
603			va[i] += atof(av[pos++]);
604			n++;
605	greg	1.20	boxpos += boxstep;
606	greg	1.17	}
607			if (n > 1)
608			va[i] /= (double)n;
609	greg	1.5	if (va[i] > scale)
610			scale = va[i];
611	greg	1.23	else if (va[i] < -scale)
612			scale = -va[i];
613	greg	1.5	}
614	greg	1.20	if (scale <= FTINY)
615	greg	1.5	return(MG_EILL);
616			scale = C_CMAXV / scale;
617			clr->ssum = 0; /* convert to our spacing */
618			wl0 = wlmin;
619			pos = 0;
620			for (i = 0, wl = C_CMINWL; i < C_CNSS; i++, wl += C_CWLI)
621	schorsch	1.28	if ((wl < wlmin) \| (wl > wlmax))
622	greg	1.5	clr->ssamp[i] = 0;
623			else {
624			while (wl0 + wlstep < wl+FTINY) {
625			wl0 += wlstep;
626			pos++;
627			}
628	schorsch	1.28	if ((wl+FTINY >= wl0) & (wl-FTINY <= wl0))
629	greg	1.18	clr->ssamp[i] = scale*va[pos] + .5;
630	greg	1.5	else /* interpolate if necessary */
631	greg	1.18	clr->ssamp[i] = .5 + scale / wlstep *
632	greg	1.5	( va[pos]*(wl0+wlstep - wl) +
633			va[pos+1]*(wl - wl0) );
634			clr->ssum += clr->ssamp[i];
635			}
636			clr->flags = C_CDSPEC\|C_CSSPEC;
637	greg	1.8	clr->clock++;
638	greg	1.5	return(MG_OK);
639			}
640
641
642			static void
643			mixcolors(cres, w1, c1, w2, c2) /* mix two colors according to weights given */
644			register C_COLOR cres, c1, *c2;
645			double w1, w2;
646			{
647			double scale;
648			float cmix[C_CNSS];
649			register int i;
650
651			if ((c1->flags\|c2->flags) & C_CDSPEC) { /* spectral mixing */
652	greg	1.16	c_ccvt(c1, C_CSSPEC\|C_CSEFF);
653			c_ccvt(c2, C_CSSPEC\|C_CSEFF);
654			w1 /= c1->eff*c1->ssum;
655	greg	1.17	w2 /= c2->eff*c2->ssum;
656	greg	1.5	scale = 0.;
657			for (i = 0; i < C_CNSS; i++) {
658			cmix[i] = w1c1->ssamp[i] + w2c2->ssamp[i];
659			if (cmix[i] > scale)
660			scale = cmix[i];
661			}
662			scale = C_CMAXV / scale;
663			cres->ssum = 0;
664			for (i = 0; i < C_CNSS; i++)
665			cres->ssum += cres->ssamp[i] = scale*cmix[i] + .5;
666			cres->flags = C_CDSPEC\|C_CSSPEC;
667			} else { /* CIE xy mixing */
668			c_ccvt(c1, C_CSXY);
669			c_ccvt(c2, C_CSXY);
670	greg	1.24	scale = w1/c1->cy + w2/c2->cy;
671			if (scale == 0.)
672			return;
673			scale = 1. / scale;
674	greg	1.5	cres->cx = (c1->cxw1/c1->cy + c2->cxw2/c2->cy) * scale;
675			cres->cy = (w1 + w2) * scale;
676			cres->flags = C_CDXY\|C_CSXY;
677			}
678	greg	1.1	}
679	greg	1.18
680
681			#define C1 3.741832e-16 /* W-m^2 */
682			#define C2 1.4388e-2 /* m-K */
683
684			#define bbsp(l,t) (C1/((l)(l)(l)(l)(l)(exp(C2/((t)(l)))-1.)))
685			#define bblm(t) (C2/5./(t))
686
687			static int
688			setbbtemp(clr, tk) /* set black body spectrum */
689			register C_COLOR *clr;
690			double tk;
691			{
692			double sf, wl;
693			register int i;
694
695			if (tk < 1000)
696			return(MG_EILL);
697			wl = bblm(tk); /* scalefactor based on peak */
698			if (wl < C_CMINWL*1e-9)
699			wl = C_CMINWL*1e-9;
700			else if (wl > C_CMAXWL*1e-9)
701			wl = C_CMAXWL*1e-9;
702			sf = C_CMAXV/bbsp(wl,tk);
703			clr->ssum = 0;
704			for (i = 0; i < C_CNSS; i++) {
705			wl = (C_CMINWL + iC_CWLI)1e-9;
706			clr->ssum += clr->ssamp[i] = sf*bbsp(wl,tk) + .5;
707			}
708			clr->flags = C_CDSPEC\|C_CSSPEC;
709			clr->clock++;
710			return(MG_OK);
711			}
712
713			#undef C1
714			#undef C2
715			#undef bbsp
716			#undef bblm