git.pond.sub.org Git - eow/blob - static/dojo-release-1.1.1/dojox/color/Generator.js

   1 if(!dojo._hasResource["dojox.color.Generator"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
   2 dojo._hasResource["dojox.color.Generator"] = true;
   3 dojo.provide("dojox.color.Generator");
   4
   5 dojox.color.Generator = new (function(){
   6         var dxc=dojox.color;
   7
   8         //      common helper functions
   9         var prep=function(obj){
  10                 if(!obj){
  11                         console.warn("dojox.color.Generator:: no base color was passed. ", obj);
  12                         return null;
  13                 }
  14                 if(!obj.toHsv){
  15                         //      either a raw string or object, return a Color.
  16                         obj=new dxc.Color(obj);
  17                 }
  18                 return obj;
  19         };
  20
  21         var factors=function(n, high, low){
  22                 var ret=[], i, step=(high-low)/n, cur=high;
  23                 for(i=0; i<n; i++,cur-=step){ ret.push(cur); }
  24                 return ret;
  25         };
  26
  27         var fill=function(color, num, factors){
  28                 var c=factors.length-1, a=[], r, g, b;
  29                 for(var i=0; i<num; i++){
  30                         if(i<factors.length){
  31                                  r=color.r+(255-color.r)*factors[i],
  32                                  g=color.g+(255-color.g)*factors[i],
  33                                  b=color.b+(255-color.b)*factors[i];
  34                                  a.push(new dxc.Color({ r:r, g:g, b:b }));
  35                         }
  36                         else if(i==factors.length){
  37                                 a.push(color);
  38                         }
  39                         else {
  40                                 if(c<0){ c=factors.length-1; }  //      just in case.
  41                                 r=color.r*(1-factors[c]),
  42                                 g=color.g*(1-factors[c]),
  43                                 b=color.b*(1-factors[c--]);
  44                                 a.push(new dxc.Color({ r:r, g:g, b:b }));
  45                         }
  46                 }
  47                 return a;
  48         };
  49
  50         var flatten=function(matrix, limit){
  51                 var ret=[];
  52                 for(var i=0; i<matrix[0].length; i++){
  53                         for(var j=0; j<matrix.length; j++){
  54                                 ret.push(matrix[j][i]);
  55                         }
  56                 }
  57                 return ret.slice(0, limit);
  58         };
  59
  60         //      the color generator
  61         this.analogous= function(/* Object */kwArgs){
  62                 //      summary
  63                 //      generates n colors based on a base color, based on a fixed hue angle delta
  64                 //      (relative to the base hue) with slight variations in saturation.
  65                 kwArgs=dojo.mixin({
  66                         series:4,                               //      number of analogous lines to generate
  67                         num:32,                                 //      number of colors to derive
  68                         angleHigh:30,                   //      the angle of difference to use, subtracted
  69                         angleLow:8,                             //      the angle of difference to use, added
  70                         high:0.5,                               //      high part of range to generate tints and shades
  71                         low:0.15                                //      low part of range to generate tints and shades
  72                 }, kwArgs||{});
  73
  74                 var base=prep(kwArgs.base, "analogous");
  75                 if(!base){ return []; }
  76
  77                 //      let start the generation.  We use series to move further away from the center.
  78                 var num=kwArgs.num, hsv=base.toHsv();
  79                 var rows=kwArgs.series+1, cols=Math.ceil(num/rows);
  80                 var fs=factors(Math.floor(cols/2), kwArgs.high, kwArgs.low);
  81
  82                 //      generate the angle differences
  83                 var ang=[];
  84                 var gen=Math.floor(kwArgs.series/2);
  85                 for(var i=1; i<=gen; i++){
  86                         var a=hsv.h+((kwArgs.angleLow*i)+1);
  87                         if(a>=360){ a-=360; }
  88                         ang.push(a);
  89                 }
  90                 ang.push(0);
  91                 for(i=1; i<=gen; i++){
  92                         a=hsv.h-(kwArgs.angleHigh*i);
  93                         if(a<0){ a+=360; }
  94                         ang.push(a);
  95                 }
  96
  97                 var m=[], cur=0;
  98                 for(i=0; i<rows; i++){
  99                         m.push(fill(dxc.fromHsv({ h: ang[cur++], s:hsv.s, v:hsv.v }), cols, fs));
 100                 }
 101                 return flatten(m, num); //      Array
 102         };
 103
 104         this.monochromatic = function(/* Object */kwArgs){
 105                 //      summary
 106                 //      generates n colors based on a base color, using alterations to the RGB model only.
 107                 kwArgs=dojo.mixin({
 108                         num:32,                                 //      number of colors to derive
 109                         high:0.5,                               //      high factor to generate tints and shades
 110                         low:0.15                                //      low factor to generate tints and shades
 111                 }, kwArgs||{});
 112
 113                 var base=prep(kwArgs.base, "monochromatic");
 114                 if(!base){ return []; }
 115
 116                 var fs=factors(Math.floor(kwArgs.num/2), kwArgs.high, kwArgs.low);
 117                 var a=fill(base, kwArgs.num, fs);
 118                 return a;       // Array
 119         };
 120
 121         this.triadic = function(/* Object */kwArgs){
 122                 //      summary
 123                 //      generates n colors from a base color, using the triadic rules, rough
 124                 //      approximation from kuler.adobe.com.
 125                 kwArgs=dojo.mixin({
 126                         num:32,                                 //      number of colors to derive
 127                         high:0.5,                               //      high factor to generate tints and shades
 128                         low:0.15                                //      low factor to generate tints and shades
 129                 }, kwArgs||{});
 130
 131                 var base=prep(kwArgs.base, "triadic");
 132                 if(!base){ return []; }
 133
 134                 var num=kwArgs.num, rows=3, cols=Math.ceil(num/rows), fs=factors(Math.floor(cols/2), kwArgs.high, kwArgs.low);
 135                 var m=[], hsv=base.toHsv();
 136
 137                 //      hue calculations
 138                 var h1=hsv.h+57, h2=hsv.h-157;
 139                 if(h1>360){ h1-=360; }
 140                 if(h2<0){ h2+=360; }
 141
 142                 //      sat calculations
 143                 var s1=(hsv.s>=20) ? hsv.s-10 : hsv.s+10;
 144                 var s2=(hsv.s>=95) ? hsv.s-5 : hsv.s+5;
 145
 146                 //      value calcs
 147                 var v2=(hsv.v>=70) ? hsv.v-30 : hsv.v+30;
 148
 149                 m.push(fill(dojox.color.fromHsv({ h:h1, s:s1, v:hsv.v }), cols, fs));
 150                 m.push(fill(base, cols, fs));
 151                 m.push(fill(dojox.color.fromHsv({ h:h2, s:s2, v:v2 }), cols, fs));
 152                 return flatten(m, num); //      Array
 153         };
 154
 155         this.complementary = function(/* Object */kwArgs){
 156                 //      summary
 157                 //      generates n colors from a base color, using complimentary rules.
 158                 kwArgs=dojo.mixin({
 159                         num:32,                                 //      number of colors to derive
 160                         high:0.5,                               //      high factor to generate tints and shades
 161                         low:0.15                                //      low factor to generate tints and shades
 162                 }, kwArgs||{});
 163
 164                 var base=prep(kwArgs.base, "complimentary");
 165                 if(!base){ return []; }
 166
 167                 var num=kwArgs.num, rows=2, cols=Math.ceil(num/rows), fs=factors(Math.floor(cols/2), kwArgs.high, kwArgs.low);
 168                 var m=[], hsv=base.toHsv();
 169                 var compliment=(hsv.h+120)%360;
 170                 m.push(fill(base, cols, fs));
 171                 m.push(fill(dojox.color.fromHsv({ h:compliment, s:hsv.s, v:hsv.v }), cols, fs));
 172                 return flatten(m, num); //      Array
 173         };
 174
 175         this.splitComplementary = function(/* Object */kwArgs){
 176                 //      summary
 177                 //      generates n colors from a base color, using split complimentary rules.
 178                 kwArgs=dojo.mixin({
 179                         num:32,                                 //      number of colors to derive
 180                         angle:30,                               //      the angle of difference to use
 181                         high:0.5,                               //      high factor to generate tints and shades
 182                         low:0.15                                //      low factor to generate tints and shades
 183                 }, kwArgs||{});
 184
 185                 var base=prep(kwArgs.base, "splitComplementary");
 186                 if(!base){ return []; }
 187
 188                 var num=kwArgs.num, rows=3, cols=Math.ceil(num/rows), fs=factors(Math.floor(cols/2), kwArgs.high, kwArgs.low);
 189                 var m=[], hsv=base.toHsv();
 190                 var compliment=(hsv.h+120)%360;
 191                 var comp1=compliment-kwArgs.angle, comp2=(compliment+kwArgs.angle)%360;
 192                 if(comp1<0){ comp1+=360; }
 193
 194                 m.push(fill(base, cols, fs));
 195                 m.push(fill(dojox.color.fromHsv({ h:comp1, s:hsv.s, v:hsv.v }), cols, fs));
 196                 m.push(fill(dojox.color.fromHsv({ h:comp2, s:hsv.s, v:hsv.v }), cols, fs));
 197                 return flatten(m, num); //      Array
 198         };
 199
 200         this.compound = function(/* Object */kwArgs){
 201                 //      summary
 202                 //      generates n colors from a base color, using a *very* rough approximation
 203                 //      of the Compound rules at http://kuler.adobe.com
 204                 kwArgs=dojo.mixin({
 205                         num:32,                                 //      number of colors to derive
 206                         angle:30,                               //      the angle of difference to use
 207                         high:0.5,                               //      high factor to generate tints and shades
 208                         low:0.15                                //      low factor to generate tints and shades
 209                 }, kwArgs||{});
 210
 211                 var base=prep(kwArgs.base, "compound");
 212                 if(!base){ return []; }
 213
 214                 var num=kwArgs.num, rows=4, cols=Math.ceil(num/rows), fs=factors(Math.floor(cols/2), kwArgs.high, kwArgs.low);
 215                 var m=[], hsv=base.toHsv();
 216                 var comp=(hsv.h+120)%360;               //      other base angle.
 217
 218                 //      hue calculations
 219                 var h1=(hsv.h+kwArgs.angle)%360, h2=comp-kwArgs.angle, h3=comp-(kwArgs.angle/2);
 220                 if(h2<0){ h2+=360; }
 221                 if(h3<0){ h3+=360; }
 222
 223                 //      saturation calculations
 224                 var s1=(hsv.s>=90 && hsv.s<=100)? hsv.s-10 : hsv.s+10;
 225                 var s2=(hsv.s<=35) ? hsv.s+25 : hsv.s-25;
 226
 227                 //      value calculations
 228                 var v1=hsv.v-20;
 229                 var v2=hsv.v;
 230
 231                 m.push(fill(base, cols, fs));
 232                 m.push(fill(dojox.color.fromHsv({ h:h1, s:s1, v:v1 }), cols, fs));
 233                 m.push(fill(dojox.color.fromHsv({ h:h2, s:s1, v:v1 }), cols, fs));
 234                 m.push(fill(dojox.color.fromHsv({ h:h3, s:s2, v:v2 }), cols, fs));
 235                 return flatten(m, num); //      Array
 236         };
 237
 238         this.shades = function(/* Object */kwArgs){
 239                 //      summary
 240                 //      generates n colors based on a base color using only changes
 241                 //      in value.  Similar to monochromatic but a bit more linear.
 242                 kwArgs=dojo.mixin({
 243                         num:32,                                 //      number of colors to derive
 244                         high:1.5,                               //      high factor to generate tints and shades
 245                         low:0.5                                 //      low factor to generate tints and shades
 246                 }, kwArgs||{});
 247
 248                 var base=prep(kwArgs.base, "shades");
 249                 if(!base){ return []; }
 250
 251                 var num=kwArgs.num, hsv=base.toHsv();
 252                 var step=(kwArgs.high-kwArgs.low)/num, cur=kwArgs.low;
 253                 var a=[];
 254                 for(var i=0; i<num; i++,cur+=step){
 255                         a.push(dxc.fromHsv({ h:hsv.h, s:hsv.s, v:Math.min(Math.round(hsv.v*cur),100) }));
 256                 }
 257                 return a;       // Array
 258         };
 259 })();
 260
 261 }