root/michi/as2/src/com/seyself/math/ColorMath.as

/*
* Copyright 2007 Michiyasu Wada
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/**
* com.seyself.math.ColorMath
* 
* 色に関する計算もろもろ。
* static関数のみで構成されています。
* 
* @author               Michiyasu Wada
*/
class com.seyself.math.ColorMath
{
        
        private function ColorMath(){}
        
        /**
        * 減算
        * ２つのRGBを示す数値（ 0x000000 から 0xFFFFFF まで）から減算した数値を返します。
        * ARGBを示す数値を引数に渡した場合、アルファ値は無視されます。
        * 
        * @param col1 : Number - RGBを示す数値（ 0x000000 から 0xFFFFFF まで）
        * @param col2 : Number - RGBを示す数値（ 0x000000 から 0xFFFFFF まで）
        * @return Number - 減算混色値
        * @usage <code>
        * import com.seyself.math.ColorMath;
        * trace( ColorMath.subtract( 0xFFFF00 , 0x666666 ).toString(16) ); // 出力 : 656500
        * </code>
        */
        static function subtract( col1:Number , col2:Number ):Number
        {
                var a = toRGB( col1 );
                var b = toRGB( col2 );
                var nr = Math.max( Math.max( b[0]-(256-a[0]) , a[0]-(256-b[0]) ) , 0 );
                var ng = Math.max( Math.max( b[1]-(256-a[1]) , a[1]-(256-b[1]) ) , 0 );
                var nb = Math.max( Math.max( b[2]-(256-a[2]) , a[2]-(256-b[2]) ) , 0 );
                return toDec( nr , ng , nb );
        }
        
        /**
        * 加法混色
        * ２つのRGBを示す数値（ 0x000000 から 0xFFFFFF まで）から加法混色した数値を返します。
        * ARGBを示す数値を引数に渡した場合、アルファ値は無視されます。
        * 
        * @param col1 : Number - RGBを示す数値（ 0x000000 から 0xFFFFFF まで）
        * @param col2 : Number - RGBを示す数値（ 0x000000 から 0xFFFFFF まで）
        * @return Number - 加法混色値
        * @usage <code>
        * import com.seyself.math.ColorMath;
        * trace( ColorMath.sum( 0xFFFF00 , 0x666666 ).toString(16) ); // 出力 : ffff66
        * </code>
        */
        static function sum( col1:Number , col2:Number ):Number
        {
                var a = toRGB( col1 );
                var b = toRGB( col2 );
                var nr = Math.min( a[0]+b[0] , 255 );
                var ng = Math.min( a[1]+b[1] , 255 );
                var nb = Math.min( a[2]+b[2] , 255 );
                return toDec( nr , ng , nb );
        }
        
        /**
        * 減法混色
        * ２つのRGBを示す数値（ 0x000000 から 0xFFFFFF まで）から減法混色した数値を返します。
        * ARGBを示す数値を引数に渡した場合、アルファ値は無視されます。
        * 
        * @param col1 : Number - RGBを示す数値（ 0x000000 から 0xFFFFFF まで）
        * @param col2 : Number - RGBを示す数値（ 0x000000 から 0xFFFFFF まで）
        * @return Number - 減法混色値
        * @usage <code>
        * import com.seyself.math.ColorMath;
        * trace( ColorMath.sub( 0xFFFF00 , 0x666666 ).toString(16) ); // 出力 : 999900
        * </code>
        */
        static function sub( col1:Number , col2:Number ):Number
        {
                var a = toRGB( col1 );
                var b = toRGB( col2 );
                var nr = Math.max( a[0]-b[0] , 0 );
                var ng = Math.max( a[1]-b[1] , 0 );
                var nb = Math.max( a[2]-b[2] , 0 );
                return toDec( nr , ng , nb );
        }
        
        /**
        * 比較（暗）
        * ２つのRGBを示す数値（ 0x000000 から 0xFFFFFF まで）から比較して、RGBそれぞれ数値の低い方を合わせた数値を返します。
        * ARGBを示す数値を引数に渡した場合、アルファ値は無視されます。
        * 
        * @param col1 : Number - RGBを示す数値（ 0x000000 から 0xFFFFFF まで）
        * @param col2 : Number - RGBを示す数値（ 0x000000 から 0xFFFFFF まで）
        * @return Number - 比較（暗）値
        * @usage <code>
        * import com.seyself.math.ColorMath;
        * trace( ColorMath.min( 0xFFFF00 , 0x666666 ).toString(16) ); // 出力 : 666600
        * </code>
        */
        static function min( col1:Number , col2:Number ):Number
        {
                var a = toRGB( col1 );
                var b = toRGB( col2 );
                var r = Math.min( a[0] , b[0] );
                var g = Math.min( a[1] , b[1] );
                var b = Math.min( a[2] , b[2] );
                return toDec( r , g , b );
        }
        
        /**
        * 比較（明）
        * ２つのRGBを示す数値（ 0x000000 から 0xFFFFFF まで）から比較して、RGBそれぞれ数値の高い方を合わせた数値を返します。
        * ARGBを示す数値を引数に渡した場合、アルファ値は無視されます。
        * 
        * @param col1 : Number - RGBを示す数値（ 0x000000 から 0xFFFFFF まで）
        * @param col2 : Number - RGBを示す数値（ 0x000000 から 0xFFFFFF まで）
        * @return Number - 比較（明）値
        * @usage <code>
        * import com.seyself.math.ColorMath;
        * trace( ColorMath.max( 0xFFFF00 , 0x666666 ).toString(16) ); // 出力 : ffff66
        * </code>
        */
        static function max( col1:Number , col2:Number ):Number
        {
                var a = toRGB( col1 );
                var b = toRGB( col2 );
                var r = Math.max( a[0] , b[0] );
                var g = Math.max( a[1] , b[1] );
                var b = Math.max( a[2] , b[2] );
                return toDec( r , g , b );
        }
        
        /**
        * ARGBを示す数値（ 0x00000000 から 0xFFFFFFFF まで）、もしくはRGBを示す数値（ 0x000000 から 0xFFFFFF まで）を
        * Alpha, R, G, B それぞれ 0 から 255 までの数値に分割した配列を返します。
        * 戻り値の配列に含まれる値は [ R , G , B , Alpha ] と Alpha値 が最後になっていることに注意してください。
        * 
        * @param col : Number - ARGBを示す数値（ 0x00000000 から 0xFFFFFFFF まで）
        * @return Array - 各色の値を示す配列 [ R , G , B , Alpha ] 
        * @usage <code>
        * import com.seyself.math.ColorMath;
        * trace( ColorMath.toRGB( 0xFF336699 ) ); // 出力 : 51,102,153,255
        * </code>
        */
        public static function toRGB( col:Number ):Array
        {
                if(typeof(col)=="number"){
                        var a = Math.floor(col/16777216);
                        var r = Math.floor((col-a*16777216)/65536);
                        var g = Math.floor((col-(a*16777216+r*65536))/256);
                        var b = Math.floor((col-(a*16777216+r*65536+g*256)));
                        return [r,g,b,a];
                }
        }
        
        /**
        * 引数に R, G, B, Alpha を示す、それぞれ 0x00 から 0xFF までの数値を合算した数値を返します。
        * Alpha値は省略が可能です。省略した場合は 0 として換算されます。
        * 
        * @param r : Number - 赤（R）を示す数値（ 0x00 から 0xFF まで）
        * @param g : Number - 緑（G）を示す数値（ 0x00 から 0xFF まで）
        * @param b : Number - 青（B）を示す数値（ 0x00 から 0xFF まで）
        * @param a : Number - アルファ（A）を示す数値（ 0x00 から 0xFF まで）
        * @return Number - 各色の値から求められたARGBを示す数値
        * @usage <code>
        * import com.seyself.math.ColorMath;
        * trace( ColorMath.toDec( 51, 102 , 153, 255 ) ); // 出力 : 4281558681
        * </code>
        */
        public static function toDec( r:Number , g:Number , b:Number , a:Number ):Number
        {
                if( a ) return Math.floor(a)*16777216+Math.floor(r)*65536+Math.floor(g)*256+Math.floor(b);
                return Math.floor(r)*65536+Math.floor(g)*256+Math.floor(b);
        }
        
        /**
        * RGBそれぞれの数値から、HSV(HSB) に換算した配列を返します。
        * （表記上HSVとしていますが B が Blue と混同しないためにHSVを用いています。）
        * RGB の値はそれぞれ以下の通りです。
        *     R - 0 から 255 までの数値
        *     G - 0 から 255 までの数値
        *     B - 0 から 255 までの数値
        * 
        * HSV の値はそれぞれ以下の通りです。
        *     H - 0 から 360 までの数値
        *     S - 0 から 100 までの数値
        *     V - 0 から 100 までの数値
        * 
        * アルファを含めた計算はできません。
        * 
        * @param r : Number - 赤（R）を示す数値（ 0x00 から 0xFF まで）
        * @param g : Number - 緑（G）を示す数値（ 0x00 から 0xFF まで）
        * @param b : Number - 青（B）を示す数値（ 0x00 から 0xFF まで）
        * @return Array - HSVに変換した値 [ H, S, V ] 
        * @usage <code>
        * import com.seyself.math.ColorMath;
        * var rgb = ColorMath.toRGB( 0xFF6600 );
        * trace( ColorMath.convertHSV.apply( null , rgb ) ); // 出力 : 24,100,50
        * </code>
        */
        public static function convertHSV( r:Number, g:Number, b:Number ):Array
        {
                r/=255; g/=255; b/=255;
                var h=0, s=0, v=0;
                var x, y;
                if(r>=g) x=r; else x=g; if(b>x) x=b;
                if(r<=g) y=r; else y=g; if(b<y) y=b;
                v=x; 
                var c=x-y;
                if(x==0) s=0; else s=c/x;
                if(s!=0){
                        if(r==x){
                                h=(g-b)/c;
                        } else {
                                if(g==x){
                                        h=2+(b-r)/c;
                                } else {
                                        if(b==x){
                                                h=4+(r-g)/c;
                                        }
                                }
                        }
                        h=h*60;
                        if(h<0) h=h+360;
                }
                return [ h, s*100, v*100 ];
        }
        
        /**
        * HSV（HSB）それぞれの数値からRGBを割り出して配列として返します。
        * （表記上HSVとしていますが B が Blue と混同しないためにHSVを用いています。）
        * RGB の値はそれぞれ以下の通りです。
        *     R - 0 から 255 までの数値
        *     G - 0 から 255 までの数値
        *     B - 0 から 255 までの数値
        * 
        * HSV の値はそれぞれ以下の通りです。
        *     H - 0 から 360 までの数値
        *     S - 0 から 100 までの数値
        *     V - 0 から 100 までの数値
        * 
        * Hが上記範囲外の場合 0 から 360 の範囲内に相当する数値に置き換えられます。
        * アルファを含めた計算はできません。
        * 
        * @param h : Number - 色相（Hue）を示す数値（ 0 から 360 まで）
        * @param s : Number - 彩度（Saturation）を示す数値（ 0 から 100 まで）
        * @param v : Number - 明度（Value）を示す数値（ 0 から 100 まで）
        * @return Array - RGBに変換した値 [ R, G, B ] 
        * @usage <code>
        * import com.seyself.math.ColorMath;
        * trace( ColorMath.convertRGB( 24, 100, 50 ) ); // 出力 : 255,102,0
        * </code>
        */
        public static function convertRGB( h:Number, s:Number, v:Number ):Array
        {
                s=s/100, v=v/100;
                var r=0, g=0, b=0;
                var i, x, y, z;
                if(s<0) s=0; if(s>1) s=1; if(v<0) v=0; if(v>1) v=1;
                h=h%360; if(h<0) h+=360; h/=60;
                i = Math.floor(h);
                x=v*(1-s); y=v*(1-s*(h-i)); z=v*(1-s*(1-h+i));
                switch(i){
                        case 0 : r=v; g=z; b=x; break;
                        case 1 : r=y; g=v; b=x; break;
                        case 2 : r=x; g=v; b=z; break;
                        case 3 : r=x; g=y; b=v; break;
                        case 4 : r=z; g=x; b=v; break;
                        case 5 : r=v; g=x; b=y; break;
                }
                return [ r*255, g*255, b*255 ];
        }

        
}