颜色转换、随机、16进制转换、HSV:
/**
*
* *-----------------------------------------*
* | *** 颜色转换、随机、16进制转换、HSV *** |
* *-----------------------------------------*
*
* 编辑修改收录：fengzi（疯子、wu341、wgq341）
*
* 不会写代码，我是代码搬运工。
* 联系方式：QQ（493712833）。
*
* 随 笔： https://www.cnblogs.com/fengziwu/
*
* 版权协议：请自觉遵守LGPL协议，欢迎修改、复制、转载、传播给更多需要的人。
* 免责声明：任何因使用此软件导致的纠纷与软件/程序开发者无关。
* 日 期： 2019.05.08
*/
package fengzi.colors
{
// 没有import，这个是参考别人的代码写的，我不生成代码，我是代码的搬运工
// 参考：https://blog.51cto.com/ragged/1743873
// 参考资料：https://blog.csdn.net/zeng622peng/article/details/6931485
// 这是参考资料对应的文字说明：
// 十六进制颜色值在 ActionScript 中, 与 BitmapData 类结合使用的颜色值应使用 32 位十六进制数表示。
// 32 位十六进制数是四对十六进制数字的序列。每个十六进制对定义四个颜色通道 (红、绿、蓝和 Alpha) 中每个颜色通道的强度。
// 颜色通道的强度为以范围介于 0 到 255 之间的十进制数的十六进制表示法；FF 是指全强度 (255), 00 是指通道中无颜色 (0)。
// 如您所见, 由于颜色值长度需要两位数字, 因此您需要填充一个通道, 例如用 01 代替 1。这样可确保十六进制数中始终具有八个数字。还应确保指定十六进制数前缀 0x。
// 例如, 白色 (所有通道中都是全强度) 用十六进制记数法表示为: 0xFFFFFFFF。而黑色正好相反；它在红色、绿色和蓝色中的任何一个通道中都无颜色: 0xFF000000。
// 请注意, Alpha 通道 (第一对) 仍然为全强度 (FF)。Alpha 通道中的全强度意味着没有 alpha (FF), 无强度 (00) 意味着全 alpha。
// 因此, 透明像素颜色值为 0x00FFFFFF。
// 从 ARGB 转换为十六进制值对于特定的颜色, 人们通常容易记住它的 Alpha、红色、绿色和蓝色 (ARGB) 值, 而记不住其十六进制值。
// 如果您也有同样的情况, 那么您应当了解如何从 ARGB 转换为十六进制值。
// 这可通过下面的 ActionScript 函数来实现:
// function argbtohex(a:Number, r:Number, g:Number, b:Number) { return (a<<24 | r<<16 | g<<8 | b) }
// 您可以按如下所示的方式使用该函数: hex=argbtohex(255,0,255,0)
// 输出基于 10 进制数的 32 位红色十六进制值从十六进制转换为 ARGB 值要将十六进制颜色值转换回范围介于 0 到 255 之间的四个十进制数 (每个数代表 ARGB 中的一个通道) ,
// 请使用下面的 ActionScript 函数: function hextoargb(val:Number) { var col={} col.alpha = (val › › 24) & 0xFF col.red = (val › › 16) & 0xFF col.green = (val › › 8) & 0xFF col.blue = val & 0xFF return col }
// 您可以按如下所示的方式使用该函数: argb=hextoargb(0xFFFFCC00); alpha=argb.alpha; red=argb.red; green=argb.green; blue=argb.blue; ***************** 测试 argb=hextoargb(0xcc000000); alpha=argb.alpha; red=argb.red; green=argb.green; blue=argb.blue; trace(alpha)
// 结果：204 改变cc位置的值，如ff，d6……，可以知道它们具体的十进制值是多少。比如：for(r=0;r<=0xFF;r+=0x33){……} 该句中的0xFF，0x33，测试可知分别是255和51。（0xFF写全应该是0x000000FF）
public class ColorTool
{
/**
* 随机RGB颜色数字
* @return 随机的RGB颜色数字
*/
public static function randomRGB () : uint
{
var r : uint = Math.random() * 256;
var g : uint = Math.random() * 256;
var b : uint = Math.random() * 256;
return r<<16 | g<<8 | b;
}
/**
* 随机ARGB颜色数字
* @return 随机的ARGB颜色数字
*/
public static function randomARGB () : uint
{
var a : uint = Math.random() * 256;
var r : uint = Math.random() * 256;
var g : uint = Math.random() * 256;
var b : uint = Math.random() * 256;
return a<<24 | r<<16 | g<<8 | b;
}
/**
* 随机RGB颜色，返回16进制字符串
* @param prefix 16进制的前缀，AS中是“0x”，其他语言或者软件也有使用“#”或者其他字符的，也可以设置为""空字符，则不需要前缀
* @param isCapital 是否将小写16进制字符转换为大写字符
* @return 随机的16进制字符串的RGB颜色
*/
public static function randomRGB16 ( prefix:String = "0x", isCapital:Boolean = true ) : String
{
return ColorTool.rgbTo16Number( uint(Math.random() * 256), uint(Math.random() * 256), uint(Math.random() * 256), prefix, isCapital );
}
/**
* 随机ARGB颜色，返回16进制字符串
* @param prefix 16进制的前缀，AS中是“0x”，其他语言或者软件也有使用“#”或者其他字符的，也可以设置为""空字符，则不需要前缀
* @param isCapital 是否将小写16进制字符转换为大写字符
* @return 随机的16进制字符串的ARGB颜色
*/
public static function randomARGB16 ( prefix:String = "0x", isCapital:Boolean = true ) : String
{
return ColorTool.argbTo16Number( uint(Math.random() * 256), uint(Math.random() * 256), uint(Math.random() * 256), uint(Math.random() * 256), prefix, isCapital );
}
/* --------------------- ARGB转数字（10进制） 系列方法 ---------------------------- */
/**
* RGB转10进制（Flash中默认是10进制，可以随时用 toString(16) 转换为16进制，但是在R高位不足16时候，转换时候会存在一些不算是BUG的BUG）
* @param r 全称为 red 红色
* @param g 全称为 green 绿色
* @param b 全称为 blue 蓝色
* @return 合并后的10进制的RGB数字
*/
public static function rgbToNumber ( r:uint, g:uint, b:uint ) : uint
{
return r<<16 | g<<8 | b;
}
/**
* ARGB转10进制（Flash中默认是10进制，可以随时用 toString(16) 转换为16进制，但是在A高位不足16时候，转换时候会存在一些不算是BUG的BUG）
* @param a 全称为 alpha 透明度
* @param r 全称为 red 红色
* @param g 全称为 green 绿色
* @param b 全称为 blue 蓝色
* @return 合并后的10进制的ARGB数字
*/
public static function argbToNumber ( a:uint, r:uint, g:uint, b:uint ) : uint
{
return a<<24 | r<<16 | g<<8 | b;
}
/**
* ARGB转10进制，这个方法是为透明度和RGB颜色分为两块，专门设计的
* @param a 全称为 alpha 透明度
* @param rgb 全称为 red green blue 红色 绿色 蓝色
* @return 合并后的10进制的ARGB数字
*/
public static function argbToNumber2 ( a:uint, rgb:uint ) : uint
{
return a<<24 | rgb;
}
/* ------------------------------------ ARGB转数字（16进制） 系列方法 ----------------------------*/
/**
* RGB转16进制字符串（因为10进制数字使用toString会有一些问题，所以才创建了这个系列的方法）
* @param r 全称为 red 红色
* @param g 全称为 green 绿色
* @param b 全称为 blue 蓝色
* @param prefix 16进制的前缀，AS中是“0x”，其他语言或者软件也有使用“#”或者其他字符的，也可以设置为""空字符，则不需要前缀
* @param isCapital 是否将小写16进制字符转换为大写字符
* @return 合并后的16进制的RGB数字，数字的16进制形式的字符串
*/
public static function rgbTo16Number ( r:uint, g:uint, b:uint, prefix:String = "0x", isCapital:Boolean = true ) : String
{
var rgb : uint;
if ( r < 16 )
{
var r2 : uint = 16;
rgb = r2<<16 | g<<8 | b;
var rgbStr : String = rgb.toString(16);
rgbStr = rgbStr.substring( 2 );
if ( isCapital ) return prefix + ("0" + r.toString(16) + rgbStr).toLocaleUpperCase();
else return prefix + "0" + r.toString(16) + rgbStr;
}
else
{
rgb = r<<16 | g<<8 | b;
if ( isCapital ) return prefix + rgb.toString(16).toLocaleUpperCase();
else return prefix + rgb.toString(16);
}
}
/**
* ARGB转16进制字符串（因为10进制数字使用toString会有一些问题，所以才创建了这个系列的方法）
* @param a 全称为 alpha 透明度
* @param r 全称为 red 红色
* @param g 全称为 green 绿色
* @param b 全称为 blue 蓝色
* @param prefix 16进制的前缀，AS中是“0x”，其他语言或者软件也有使用“#”或者其他字符的，也可以设置为""空字符，则不需要前缀
* @param isCapital 是否将小写16进制字符转换为大写字符
* @return 合并后的16进制的ARGB数字，数字的16进制形式的字符串
*/
public static function argbTo16Number ( a:uint, r:uint, g:uint, b:uint, prefix:String = "0x", isCapital:Boolean = true ) : String
{
var argb : uint;
if ( a < 16 )
{
var a2 : uint = 16;
argb = a2<<24 | r<<16 | g<<8 | b;
var argbStr : String = argb.toString(16);
argbStr = argbStr.substring( 2 );
if ( isCapital ) return prefix + ("0" + a.toString(16) + argbStr).toLocaleUpperCase();
else return prefix + "0" + a.toString(16) + argbStr;
}
else
{
argb = a<<24 | r<<16 | g<<8 | b;
if ( isCapital ) return prefix + argb.toString(16).toLocaleUpperCase();
else return prefix + argb.toString(16);
}
}
/**
* ARGB转16进制字符串，这个方法是为透明度和RGB颜色分为两块，专门设计的
* @param a 全称为 alpha 透明度
* @param rgb 全称为 red green blue 红色 绿色 蓝色
* @param prefix 16进制的前缀，AS中是“0x”，其他语言或者软件也有使用“#”或者其他字符的，也可以设置为""空字符，则不需要前缀
* @return 合并后的16进制的ARGB数字，数字的16进制形式的字符串
*/
public static function argbTo16Number2 ( a:uint, rgb:uint, prefix:String = "0x", isCapital:Boolean = true ) : String
{
var rgbStr : String = rgb.toString(16);
if ( rgbStr.length == 1 ) rgbStr = "00000" + rgbStr;
else if ( rgbStr.length == 2 ) rgbStr = "0000" + rgbStr;
else if ( rgbStr.length == 3 ) rgbStr = "000" + rgbStr;
else if ( rgbStr.length == 4 ) rgbStr = "00" + rgbStr;
else if ( rgbStr.length == 5 ) rgbStr = "0" + rgbStr;
var argbStr : String = a.toString(16) + rgbStr;
if ( argbStr.length == 7 ) argbStr = "0" + argbStr;
if ( isCapital ) return prefix + argbStr.toLocaleUpperCase();
else return prefix + argbStr;
}
/*------------------------------------------- 数字转ARGB 系列方法 ------------------------------*/
/**
* 10进制转RGB对象（Object），对象分别有三个属性：r、g、b
* @param rgb 全称为 red green blue 红色 绿色 蓝色
* @return 单独的颜色数字（十进制）
*/
public static function numberToRGB ( rgb:uint ) : Object
{
var color : Object = {};
color.r = (rgb >> 16) & 0xFF;
color.g = (rgb >> 8) & 0xFF;
color.b = rgb & 0xFF;
return color;
}
/**
* 10进制转ARGB对象（Object），对象分别有四个属性：a、r、g、b
* @param argb 全称为 alpha red green blue 透明度 红色 绿色 蓝色
* @return 单独的颜色数字（十进制）
*/
public static function numberToARGB ( argb:uint ) : Object
{
var color : Object = {};
color.a = (argb >> 24) & 0xFF;
color.r = (argb >> 16) & 0xFF;
color.g = (argb >> 8) & 0xFF;
color.b = argb & 0xFF;
return color;
}
/**
* 10进制转ARGB对象（Object），这个方法是为透明度和RGB颜色分为两块，专门设计的
* @param a 全称为 alpha 透明度
* @param rgb 全称为 red green blue 红色 绿色 蓝色
* @return 单独的颜色数字（十进制）
*/
public static function numberToARGB2 ( a:uint, rgb:uint ) : Object
{
var color : Object = {};
color.a = a;
color.r = (rgb >> 16) & 0xFF;
color.g = (rgb >> 8) & 0xFF;
color.b = rgb & 0xFF;
return color;
}
/*-------------------------------- RGB 和 HSV 相互转换 系列方法 ----------------------------------*/
/**
* RGB颜色 转换 HSV颜色 对象（Object），对象分别有三个属性：h、s、v
* @param r 红色
* @param g 绿色
* @param b 蓝色
* @return HSV对象，hue 色调 0-360°，saturation 饱和度 0-100%，value 明度 0-100%
*/
public static function rgbToHSV ( r:Number, g:Number, b:Number ) : Object
{
// 超过范围的极限值修正
if ( r < 0 ) r = 0;
else if ( r > 255 ) r = 255;
if ( g < 0 ) g = 0;
else if ( g > 255 ) g = 255;
if ( b < 0 ) b = 0;
else if ( b > 255 ) b = 255;
var h:Number, s:Number, v:Number, max:Number, min:Number, temp:Number;
r = r / 255;
g = g / 255;
b = b / 255;
max = Math.max(r,g,b);
min = Math.min(r,g,b);
temp = max-min;
if ( temp == 0 ) h = 0;
if ( r == max ) h = 60 * (((g-b)/temp)%6);
if ( g == max ) h = 60 * ( 2 + (b-r)/temp);
if ( b == max ) h = 60 * (4 + (r-g)/temp);
if ( isNaN(h) )
{
h = 0;
}
else if ( h < 0 )
{
h = 360 + h;
}
if ( max == 0 )
{
s = 0;
}
else
{
s = Math.round(temp / max * 100);
}
v = Math.round(max * 100);
var color : Object = {};
color.h = Math.round( h );
color.s = Math.round( s );
color.v = Math.round( v );
return color;
}
/**
* HSV颜色 转换 RGB颜色 对象（Object），对象分别有三个属性：r、g、b
* @param h 色调
* @param s 饱和度
* @param v 明度
* @return RGB对象，red 红色 0-255，green 绿色 0-255，blue 蓝色 0-255
*/
public static function hsvToRGB ( h:Number, s:Number, v:Number ) : Object
{
s *= 0.01;
v *= 0.01;
// 超过范围的极限值修正
if ( h < 0 ) h = 0;
else if ( h >= 360 ) h = 359.99;
if ( s < 0 ) s = 0;
else if ( s > 100 ) s = 100;
if ( v < 0 ) v = 0;
else if ( v > 100 ) v = 100;
var c : Number, x : Number, m : Number, r : Number, g : Number, b : Number;
c = v * s;
x = c * (1 - Math.abs((h / 60) % 2 - 1))
m = v - c;
if ( h >= 0 && h < 60 )
{
r = c, g = x, b = 0
}
else if ( h >= 60 && h < 120 )
{
r = x, g = c, b = 0;
}
else if ( h >= 120 && h < 180 )
{
r = 0, g = c, b = x;
}
else if ( h >= 180 && h < 240 )
{
r = 0, g = x, b = c;
}
else if ( h >= 240 && h < 300 )
{
r = x, g = 0, b = c;
}
else if ( h >= 300 && h < 360 )
{
r = c, g = 0, b = x;
}
var color : Object = {};
color.r = Math.round((r + m) * 255)
color.g = Math.round((g + m) * 255);
color.b = Math.round((b + m) * 255);
return color;
}
/**
* RGB颜色 转换 XYZ颜色坐标 对象（Object），对象分别有三个属性：x、y、z
* 参考：https://blog.csdn.net/gubenpeiyuan/article/details/60577008
* @param r 红色
* @param g 绿色
* @param b 蓝色
* @return 转换后的XYZ对象
*/
public static function rgbToXYZ ( r:Number, g:Number, b:Number ) : Object
{
var matrixM : Array=[[0.436052025, 0.385081593, 0.143087414],
[0.222491598, 0.716886060, 0.060621486],
[0.013929122, 0.097097002, 0.714185470]];
var rgb : Array=[r/255, g/255, b/255];
rgb[0] = rgbToXYZGamma( rgb[0] );
rgb[1] = rgbToXYZGamma( rgb[1] );
rgb[2] = rgbToXYZGamma( rgb[2] );
var xyz : Object = {};
xyz.x = 100 * (matrixM[0][0] * rgb[0] + matrixM[0][1] * rgb[1] + matrixM[0][2] * rgb[2]);
xyz.y = 100 * (matrixM[1][0] * rgb[0] + matrixM[1][1] * rgb[1] + matrixM[1][2] * rgb[2]);
xyz.z = 100 * (matrixM[2][0] * rgb[0] + matrixM[2][1] * rgb[1] + matrixM[2][2] * rgb[2]);
return xyz;
}
/**
* 校正函数
*/
private static function rgbToXYZGamma ( num:Number ) : Number {
if ( num > 0.04045 )
{
num = Math.pow((num + 0.055) / 1.055, 2.4);
}
else
{
num /= 12.92;
}
return num;
}
/**
* XYZ颜色坐标 转换 LAB颜色坐标 对象（Object），对象分别有三个属性：l、a、b
* 参考：https://blog.csdn.net/tian_110/article/details/45575869
* @param x X颜色坐标
* @param y Y颜色坐标
* @param z Z颜色坐标
* @return 转换后的XYZ对象
*/
public static function xyzToLAB ( x:Number, y:Number, z:Number ) : Object
{
x /= 96.4221;
y /= 100;
z /= 82.5221;
var fx : Number = x > 0.008856 ? Math.pow(x, 1/3) : (7.787 * x +0.137931);
var fy : Number = y > 0.008856 ? Math.pow(y, 1/3) : (7.787 * y +0.137931);
var fz : Number = z > 0.008856 ? Math.pow(z, 1/3) : (7.787 * z +0.137931);
var lab : Object = {};
lab.l = y > 0.008856 ? (116.0 * fy - 16.0) : (903.3 * y);
lab.a = 500 * (fx - fy);
lab.b = 200 * (fy - fz);
return lab;
}
/*-------------------------------- HSV 和 CIEDE2000 两个计算色差的方法 ------------------------------*/
/**
* 使用 HSV 进行色差计算，可以通过色差值，判断出颜色是否相近或者差别很大
* @param r1 红色值1，范围0-255整数
* @param g1 绿色值1，范围0-255整数
* @param b1 蓝色值1，范围0-255整数
* @param r2 红色值2，范围0-255整数
* @param g2 绿色值2，范围0-255整数
* @param b2 蓝色值2，范围0-255整数
* @return 计算出的色差值
*/
public static function distanceHSV ( r1:Number, g1:Number, b1:Number, r2:Number, g2:Number, b2:Number ) : Number
{
var R : Number = 100;
var angle : Number = 30;
var h : Number = R * Math.cos(angle / 180 * Math.PI);
var r : Number = R * Math.sin(angle / 180 * Math.PI);
var hsv1 : Object = rgbToHSV( r1, g1, b1 );
var hsv2 : Object = rgbToHSV( r2, g2, b2 );
var x1 : Number = r1 * hsv1.v / 100 * hsv1.s / 100 * Math.cos(hsv1.h / 180 * Math.PI);
var y1 : Number = r1 * hsv1.v / 100 * hsv1.s / 100 * Math.sin(hsv1.h / 180 * Math.PI);
var z1 : Number = h * (1 - hsv1.v / 100);
var x2 : Number = r * hsv2.v / 100 * hsv2.s / 100 * Math.cos(hsv2.h / 180 * Math.PI);
var y2 : Number = r * hsv2.v / 100 * hsv2.s / 100 * Math.sin(hsv2.h / 180 * Math.PI);
var z2 : Number = h * (1 - hsv2.v / 100);
var dx : Number = x1 - x2;
var dy : Number = y1 - y2;
var dz : Number = z1 - z2;
var distance : Number = Math.sqrt(dx * dx + dy * dy + dz * dz);
return distance;
}
/**
* 使用 CIEDE2000 计算颜色色差，CIEDE2000是根据人类眼睛视觉差，计算出的更适合人类的颜色差别计算方法
* 人类的眼睛接收颜色的明暗度，亮度是不一样的，即使同样纯度的红色和蓝色，还是会感觉一个更亮，一个更暗
* 参考资料：
* https://www.colortell.com/3424.html 具体色差公式
* https://www.colortell.com/colorde 在线色差计算工具 （当前算法与这个在线工具得到的值偏差0.1）
* https://blog.51cto.com/tangchao/764248 案例
* @param r1 红色值1，范围0-255整数
* @param g1 绿色值1，范围0-255整数
* @param b1 蓝色值1，范围0-255整数
* @param r2 红色值2，范围0-255整数
* @param g2 绿色值2，范围0-255整数
* @param b2 蓝色值2，范围0-255整数
* @return 计算出的色差值
*/
public static function distanceCIEDE2000 ( r1:Number, g1:Number, b1:Number, r2:Number, g2:Number, b2:Number ) : Number
{
var xyz1 : Object = rgbToXYZ( r1, g1, b1 );
var xyz2 : Object = rgbToXYZ( r2, g2, b2 );
var lab1 : Object = xyzToLAB( xyz1.x, xyz1.y, xyz1.z );
var lab2 : Object = xyzToLAB( xyz2.x, xyz2.y, xyz2.z );
var L1:Number,A1:Number,B1:Number,L2:Number,A2:Number,B2:Number;
L1=lab1.l;
A1=lab1.a;
B1=lab1.b;
L2=lab2.l;
A2=lab2.a;
B2=lab2.b;
var G:Number;//G表示CIELab 颜色空间a轴的调整因子,是彩度的函数
var KL:Number=1, KC:Number=1, KH:Number=1;// 参考实验条件
var Cab:Number = distanceE2000Saturation(A1, B1) + distanceE2000Saturation(A2, B2);
var meanCab:Number=Cab/2;
var meanCabpow7:Number=Math.pow(meanCab,7);
G=0.5*(1-Math.pow(meanCabpow7/(meanCabpow7+Math.pow(25,7)),0.5));
var LL1:Number,AA1:Number,BB1:Number,LL2:Number,AA2:Number,BB2:Number;
LL1=L1;
AA1=A1*(1+G);
BB1=B1;
LL2=L2;
AA2=A2*(1+G);
BB2=B2;
var CC1:Number,CC2:Number;//两样本的彩度值
CC1 = distanceE2000Saturation(AA1, BB1);
CC2 = distanceE2000Saturation(AA2, BB2);
var HH1:Number,HH2:Number;//两样本的色调角
HH1 = distanceE2000HueAngle(AA1,BB1);
HH2 = distanceE2000HueAngle(AA2,BB2);
var delta_LL:Number=LL1-LL2;
var delta_CC:Number=CC1-CC2;
var delta_HH:Number=2 * Math.sin(Math.PI*(HH1-HH2) / 360) * Math.pow(CC1 * CC2, 0.5);
//计算公式中的加权函数SL,SC,SH,T
var mean_LL:Number,mean_CC:Number,mean_HH:Number;
mean_LL=(LL1+LL2)/2;
mean_HH=(HH1+HH2)/2;
mean_CC=(CC1+CC2)/2;
var SL:Number,SC:Number,SH:Number,T:Number;
SL=1+0.015*Math.pow(mean_LL-50,2)/Math.pow(20+Math.pow(mean_LL-50,2),0.5);
SC=1+0.045*mean_CC;
T = 1 - 0.17 * Math.cos((mean_HH - 30) * Math.PI / 180) + 0.24 * Math.cos((2 * mean_HH) * Math.PI / 180) + 0.32 * Math.cos((3 * mean_HH + 6) * Math.PI / 180) - 0.2 * Math.cos((4 * mean_HH - 63) * Math.PI / 180);
SH=1+0.015*mean_CC*T;
//计算公式中的RT
var meanCCpow7:Number=Math.pow(mean_CC,7);
var RC:Number=2*Math.pow(meanCCpow7/(meanCCpow7+Math.pow(25,7)),0.5);
var deltaXita:Number=30*Math.exp(-Math.pow((mean_HH - 275) / 25, 2)); //△θ 以°为单位
var RT:Number=-Math.sin((2*deltaXita)*Math.PI/180)*RC;
var L_item:Number,C_item:Number,H_item:Number;
L_item=delta_LL/(KL*SL);
C_item=delta_CC/(KC*SC);
H_item=delta_HH/(KH*SH);
var E00 : Number = Math.pow(L_item * L_item + C_item * C_item + H_item * H_item + RT * C_item * H_item, 0.5);
return E00;
}
/**
* 彩度计算
*/
private static function distanceE2000Saturation ( a:Number, b:Number ) : Number
{
return Math.pow(a * a + b * b, 0.5);
}
/**
*
*/
private static function distanceE2000HueAngle ( a:Number, b:Number ) : Number
{
var h : Number = (180/Math.PI)*Math.atan(b/a); //有正有负
var hab : Number = 0;
if ( a > 0 && b > 0 )
{
hab = h;
}
else if ( a < 0 && b > 0 )
{
hab = 180 + h;
}
else if ( a < 0 &&b < 0 )
{
hab = 180 + h;
}
else
{
hab = 360 + h;
}
return hab;
}
}
}