home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / haeberli / libcan / canmap.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  2.7 KB  |  133 lines
  1. /*
  2.  * Copyright 1991, 1992, 1993, 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. /*
  18.  *    canmap -
  19.  *        Support arbitrary color transforms on canvases
  20.  *
  21.  *                Paul Haeberli - 1991
  22.  *
  23.  *    exports
  24.  *
  25.     canmap *makecanmap(transfunc,levels);
  26.     void freecanmap(map);
  27.     void applycanmap(c,map);
  28.  *
  29.  */
  30. #include "stdio.h"
  31. #include "canvas.h"
  32. #include "math.h"
  33. #include "izoom.h"
  34. #include "vect.h"
  35. #include "lum.h"
  36.  
  37.  
  38. static unsigned char *randbase;
  39.  
  40. canmap *makecanmap(transfunc,levels)
  41. int (*transfunc)();
  42. int levels;
  43. {
  44.     canmap *m;
  45.     pixel *pptr;
  46.     int r, g, b, i;
  47.     float div;
  48.     vect in, out;
  49.     
  50.     m = (canmap *)mymalloc(sizeof(canmap));
  51.     m->levels = levels;
  52.     m->table = (pixel *)mymalloc(levels*levels*levels*sizeof(pixel));
  53.     div = levels-1.0;
  54.     pptr = m->table;
  55.     for(b=0; b<levels; b++) {
  56.     in.z = b/div;
  57.     for(g=0; g<levels; g++) {
  58.         in.y = g/div;
  59.         for(r=0; r<levels; r++) {
  60.         in.x = r/div;
  61.         transfunc(&in,&out);
  62.  
  63.         i = 255*out.x;
  64.         if(i&0xffffff00) {
  65.             if(i<0) i = 0; else i = 255;
  66.         }
  67.         pptr->r = i;
  68.         i = 255*out.y;
  69.         if(i&0xffffff00) {
  70.             if(i<0) i = 0; else i = 255;
  71.         }
  72.         pptr->g = i;
  73.         i = 255*out.z;
  74.         if(i&0xffffff00) {
  75.             if(i<0) i = 0; else i = 255;
  76.         }
  77.         pptr->b = i;
  78.  
  79.         pptr++;
  80.         }
  81.     }
  82.     }
  83.     return m;
  84. }
  85.  
  86. void freecanmap(map)
  87. canmap *map;
  88. {
  89.     myfree(map->table);
  90.     myfree(map);
  91. }
  92.  
  93. void applycanmap(c,map)
  94. canvas *c;
  95. canmap *map;
  96. {
  97.     int ir, ig, ib;
  98.     int n, i, l1, l2, sc;
  99.     pixel *pptr, *pos, *base; 
  100.     unsigned char *rptr;
  101.     int rmag;
  102.  
  103.     base = map->table;
  104.     l1 = map->levels;
  105.     l2 = l1*l1;
  106.     sc = l1-1;
  107.  
  108.     if(!randbase)
  109.     randbase = (unsigned char *)mymalloc(256);
  110.     rptr = randbase;
  111.  
  112.     rmag = 255/sc;
  113.     for(i=0; i<256; i++) 
  114.     *rptr++ = random()%rmag;
  115.  
  116.     n = c->xsize*c->ysize;
  117.     pptr = (pixel *)c->data;
  118.     while(n) {
  119.     i = n;
  120.     if(i>(128/3))
  121.         i = 128/3;
  122.     n = n-i;
  123.     rptr = randbase+(random()%128);
  124.     while(i--) {
  125.         ir =  ((pptr->r+(*rptr))*sc)/256;
  126.         ig =  ((pptr->g+(*rptr))*sc)/256;
  127.         ib =  ((pptr->b+(*rptr++))*sc)/256;
  128.         pos = base+(ir+ig*l1+ib*l2);
  129.         *pptr++ = *pos;
  130.     }
  131.     }
  132. }
  133.