Annotation of researchv10no/cmd/view2d/Old/cvmap.c, revision 1.1.1.1

1.1       root        1: /*
                      2:    format of color map for experimental anti-aliasing:
                      3:   0- 62   brightest rainbow
                      4:  64-126   3/4 bright
                      5: 128-190   1/2 bright
                      6: 192-254   1/4 bright
                      7:     255   black
                      8: */
                      9: 
                     10: #include <stdio.h>
                     11: #define RED   0x4
                     12: #define GREEN 0x2
                     13: #define BLUE  0x1
                     14: #define SAVCOLOR    mapr[i]=255.499*r;mapg[i]=255.499*g;mapb[i]=255.499*b;
                     15: 
                     16: int
                     17: cvmap ( map, maxi, mapr,mapg,mapb )  /* load color map, return black index*/
                     18:   char *map;   /* string describing kind of map */
                     19:   int maxi;
                     20:   int mapr[],mapg[],mapb[]; /* colors, 0 through maxi */
                     21: {
                     22:   int i, j;
                     23:   int max1, max2;
                     24:   double r, g, b;
                     25:   double dm = maxi;
                     26:   double sqrt();
                     27:   int antial = 0;
                     28:   FILE *mapf;
                     29:   if(maxi<0) error("maxi must be >= 0");
                     30:   if(maxi>=254) error("maxi must be < 254");
                     31:   switch(*map){
                     32:     case 'a': /* experimental -- for anti-aliasing */
                     33:       antial++;
                     34:       maxi=62;
                     35:       dm = maxi;
                     36:       for(i=0; i<=maxi; i++){
                     37:         rainbow(1-i/dm,1.,1.,&r,&g,&b);
                     38:         SAVCOLOR;
                     39:       }
                     40:       break;
                     41:     case 'f': /* input from file */
                     42:       mapf = fopen(map+1,"r");
                     43:       if( mapf==NULL ) error("can't open %s",map+1);
                     44:       for(i=0; i<=maxi; i++){
                     45:         if(fscanf(mapf,"%d %d %d",&mapr[i],&mapg[i],&mapb[i])!=3)
                     46:           error("trouble reading color map %d",i);
                     47:       }
                     48:       fclose(mapf);
                     49:       break;
                     50:     case 'r': /* red v. blue */
                     51:       for(i=0; i<=maxi; i++){
                     52:         r=sqrt(i/dm); g=sqrt(0.); b=sqrt(1-i/dm);
                     53:         brit(&r,&g,&b);
                     54:         SAVCOLOR;
                     55:       }
                     56:       break;
                     57:     case NULL:
                     58:     case 's': /* blue-to-red rainbow */
                     59:       for(i=0; i<=maxi; i++){
                     60:         rainbow(1-i/dm,1.,1.,&r,&g,&b);
                     61:         r=sqrt(r); g=sqrt(g); b=sqrt(b);
                     62:         SAVCOLOR;
                     63:       }
                     64:       break;
                     65:     case 'g':   /* normal map, corrected for gamma */
                     66:       for(i=0; i<=maxi; i++){
                     67:         r=sqrt(i/dm); g=sqrt(i/dm); b=sqrt(i/dm);
                     68:         SAVCOLOR;
                     69:       }
                     70:       break;
                     71:     case 'i':   /* like g, but inverse video */
                     72:       for(i=0; i<=maxi; i++){
                     73:         r=sqrt(1-i/dm); g=sqrt(1-i/dm); b=sqrt(1-i/dm);
                     74:         SAVCOLOR;
                     75:       }
                     76:       break;
                     77:     default:
                     78:     err:
                     79:       fprintf(stderr,"unrecognized color map %s\n",map);
                     80:   }
                     81:   for(i=0; i<=maxi; i++){
                     82:     cvput(0x1C);cvput(i);
                     83:       cvput(mapr[i]);cvput(mapg[i]);cvput(mapb[i]);
                     84:   }
                     85:   if(antial){
                     86:     for(j=1;j<4;j++){
                     87:       for(i=0; i<=maxi; i++){
                     88:         cvput(0x1C);cvput(i+j*(maxi+1));
                     89:           r=mapr[i]/254.5; r=r*r; r=(4-j)*r/4; cvput((int)(254.999*sqrt(r)));
                     90:           r=mapg[i]/254.5; r=r*r; r=(4-j)*r/4; cvput((int)(254.999*sqrt(r)));
                     91:           r=mapb[i]/254.5; r=r*r; r=(4-j)*r/4; cvput((int)(254.999*sqrt(r)));
                     92:       }
                     93:     }
                     94:   }
                     95:   cvput(0x1B); cvput(255); cvput(0);    /* LUTA */
                     96:   return(255);
                     97: }
                     98: 
                     99: brit(r,g,b)
                    100:   double *r, *g, *b;
                    101: {
                    102:   /*  convert from r+g+b=1 to max(r,g,b)=1 */
                    103:   double t;
                    104:   t = (*r>*b)?*r:*b;
                    105:   if(*g>t) t = *g;
                    106:   *r /= t;
                    107:   *g /= t;
                    108:   *b /= t;
                    109: }
                    110: 
                    111: 
                    112: 
                    113: /**** taken from /n/research/netlib/misc/rainbow *****/
                    114: /*   rainbow(h, s, v, r, g, b)
                    115:      double h, s, v, *r, *g, *b;
                    116: 
                    117:  This routine computes colors suitable for use in color level plots.
                    118:  Typically s=v=1 and h varies from 0 (red) to 1 (blue) in
                    119:  equally spaced steps.  (h>1 gives magenta.)
                    120:  To convert for frame buffer, use   R = (int)(255.999*sqrt(*r))  etc.
                    121:  complaints =>  Eric Grosse   research!ehg    201-582-5828
                    122: */
                    123: 
                    124: #include <math.h>
                    125: double huextab[] = {
                    126:   .0000,.0156,.0313,.0469,.0625,.0781,.0938,.1094,.1250,.1406,
                    127:   .1563,.1719,.1875,.2031,.2188,.2344,.2500,.2656,.2813,.2969,
                    128:   .3125,.3281,.3438,.3594,.3750,.3906,.4063,.4219,.4375,.4531,
                    129:   .4688,.4844,.5000,.5156,.5313,.5469,.5625,.5781,.5938,.6094,
                    130:   .6250,.6406,.6563,.6719,.6875,.7031,.7188,.7344,.7500,.7656,
                    131:   .7813,.7969,.8125,.8281,.8438,.8594,.8750,.8906,.9063,.9219,
                    132:   .9375,.9531,.9688,.9844,1.  };
                    133: double huettab[] = {
                    134:   .0000,.0052,.0105,.0160,.0218,.0277,.0339,.0404,.0471,.0542,
                    135:   .0616,.0693,.0775,.0862,.0954,.1052,.1157,.1269,.1390,.1519,
                    136:   .1660,.1824,.1974,.2115,.2248,.2374,.2495,.2609,.2719,.2824,
                    137:   .2926,.3023,.3118,.3210,.3300,.3456,.3600,.3761,.3943,.4153,
                    138:   .4399,.4688,.5048,.5211,.5359,.5494,.5617,.5729,.5832,.5925,
                    139:   .6010,.6088,.6160,.6225,.6285,.6340,.6390,.6436,.6478,.6516,
                    140:   .6552,.6584,.6614,.6642,.6667 };
                    141:   /* computed from the FMC-1 color difference formula */
                    142:   /* Hitachi monitor, max(r,g,b)=1, n=65,  7 Jan 1985 */
                    143: 
                    144: rainbow(h, s, v, r, g, b)
                    145: double h, s, v, *r, *g, *b;
                    146: {
                    147:   double *x = huextab;
                    148:   double *t = huettab;
                    149:   while( (x[1]<=h) && (x[1]<1.) ){ ++x; ++t; }
                    150:   h = t[0] + (t[1]-t[0])*(h-x[0])/(x[1]-x[0]);
                    151:   dhsv2rgb(h,s,v,r,g,b);
                    152: }
                    153: 
                    154: dhsv2rgb(h, s, v, r, g, b)    /*...hexcone model...*/
                    155: double h, s, v, *r, *g, *b;    /* all variables in range [0,1] */
                    156: {
                    157:   int i;
                    158:   double f, m, n, k;
                    159:   h *= 6;
                    160:   i = (int)floor(h);
                    161:   f = h-i;
                    162:   m = (1-s);
                    163:   n = (1-s*f);
                    164:   k = (1-(s*(1-f)));
                    165:   switch(i){
                    166:     case 0: *r=1; *g=k; *b=m; break;
                    167:     case 1: *r=n; *g=1; *b=m; break;
                    168:     case 2: *r=m; *g=1; *b=k; break;
                    169:     case 3: *r=m; *g=n; *b=1; break;
                    170:     case 4: *r=k; *g=m; *b=1; break;
                    171:     case 5: *r=1; *g=m; *b=n; break;
                    172:     default: error("bad i: %f %d",h,i);
                    173:   }
                    174:   f = *r;
                    175:   if( f < *g ) f = *g;
                    176:   if( f < *b ) f = *b;
                    177:   f = v / f;
                    178:   *r *= f;
                    179:   *g *= f;
                    180:   *b *= f;
                    181: }

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.