| /* MIT license */ |
| var cssKeywords = require('color-name'); |
| |
| // NOTE: conversions should only return primitive values (i.e. arrays, or |
| // values that give correct `typeof` results). |
| // do not use box values types (i.e. Number(), String(), etc.) |
| |
| var reverseKeywords = {}; |
| for (var key in cssKeywords) { |
| if (cssKeywords.hasOwnProperty(key)) { |
| reverseKeywords[cssKeywords[key]] = key; |
| } |
| } |
| |
| var convert = module.exports = { |
| rgb: {channels: 3, labels: 'rgb'}, |
| hsl: {channels: 3, labels: 'hsl'}, |
| hsv: {channels: 3, labels: 'hsv'}, |
| hwb: {channels: 3, labels: 'hwb'}, |
| cmyk: {channels: 4, labels: 'cmyk'}, |
| xyz: {channels: 3, labels: 'xyz'}, |
| lab: {channels: 3, labels: 'lab'}, |
| lch: {channels: 3, labels: 'lch'}, |
| hex: {channels: 1, labels: ['hex']}, |
| keyword: {channels: 1, labels: ['keyword']}, |
| ansi16: {channels: 1, labels: ['ansi16']}, |
| ansi256: {channels: 1, labels: ['ansi256']}, |
| hcg: {channels: 3, labels: ['h', 'c', 'g']}, |
| apple: {channels: 3, labels: ['r16', 'g16', 'b16']}, |
| gray: {channels: 1, labels: ['gray']} |
| }; |
| |
| // hide .channels and .labels properties |
| for (var model in convert) { |
| if (convert.hasOwnProperty(model)) { |
| if (!('channels' in convert[model])) { |
| throw new Error('missing channels property: ' + model); |
| } |
| |
| if (!('labels' in convert[model])) { |
| throw new Error('missing channel labels property: ' + model); |
| } |
| |
| if (convert[model].labels.length !== convert[model].channels) { |
| throw new Error('channel and label counts mismatch: ' + model); |
| } |
| |
| var channels = convert[model].channels; |
| var labels = convert[model].labels; |
| delete convert[model].channels; |
| delete convert[model].labels; |
| Object.defineProperty(convert[model], 'channels', {value: channels}); |
| Object.defineProperty(convert[model], 'labels', {value: labels}); |
| } |
| } |
| |
| convert.rgb.hsl = function (rgb) { |
| var r = rgb[0] / 255; |
| var g = rgb[1] / 255; |
| var b = rgb[2] / 255; |
| var min = Math.min(r, g, b); |
| var max = Math.max(r, g, b); |
| var delta = max - min; |
| var h; |
| var s; |
| var l; |
| |
| if (max === min) { |
| h = 0; |
| } else if (r === max) { |
| h = (g - b) / delta; |
| } else if (g === max) { |
| h = 2 + (b - r) / delta; |
| } else if (b === max) { |
| h = 4 + (r - g) / delta; |
| } |
| |
| h = Math.min(h * 60, 360); |
| |
| if (h < 0) { |
| h += 360; |
| } |
| |
| l = (min + max) / 2; |
| |
| if (max === min) { |
| s = 0; |
| } else if (l <= 0.5) { |
| s = delta / (max + min); |
| } else { |
| s = delta / (2 - max - min); |
| } |
| |
| return [h, s * 100, l * 100]; |
| }; |
| |
| convert.rgb.hsv = function (rgb) { |
| var rdif; |
| var gdif; |
| var bdif; |
| var h; |
| var s; |
| |
| var r = rgb[0] / 255; |
| var g = rgb[1] / 255; |
| var b = rgb[2] / 255; |
| var v = Math.max(r, g, b); |
| var diff = v - Math.min(r, g, b); |
| var diffc = function (c) { |
| return (v - c) / 6 / diff + 1 / 2; |
| }; |
| |
| if (diff === 0) { |
| h = s = 0; |
| } else { |
| s = diff / v; |
| rdif = diffc(r); |
| gdif = diffc(g); |
| bdif = diffc(b); |
| |
| if (r === v) { |
| h = bdif - gdif; |
| } else if (g === v) { |
| h = (1 / 3) + rdif - bdif; |
| } else if (b === v) { |
| h = (2 / 3) + gdif - rdif; |
| } |
| if (h < 0) { |
| h += 1; |
| } else if (h > 1) { |
| h -= 1; |
| } |
| } |
| |
| return [ |
| h * 360, |
| s * 100, |
| v * 100 |
| ]; |
| }; |
| |
| convert.rgb.hwb = function (rgb) { |
| var r = rgb[0]; |
| var g = rgb[1]; |
| var b = rgb[2]; |
| var h = convert.rgb.hsl(rgb)[0]; |
| var w = 1 / 255 * Math.min(r, Math.min(g, b)); |
| |
| b = 1 - 1 / 255 * Math.max(r, Math.max(g, b)); |
| |
| return [h, w * 100, b * 100]; |
| }; |
| |
| convert.rgb.cmyk = function (rgb) { |
| var r = rgb[0] / 255; |
| var g = rgb[1] / 255; |
| var b = rgb[2] / 255; |
| var c; |
| var m; |
| var y; |
| var k; |
| |
| k = Math.min(1 - r, 1 - g, 1 - b); |
| c = (1 - r - k) / (1 - k) || 0; |
| m = (1 - g - k) / (1 - k) || 0; |
| y = (1 - b - k) / (1 - k) || 0; |
| |
| return [c * 100, m * 100, y * 100, k * 100]; |
| }; |
| |
| /** |
| * See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance |
| * */ |
| function comparativeDistance(x, y) { |
| return ( |
| Math.pow(x[0] - y[0], 2) + |
| Math.pow(x[1] - y[1], 2) + |
| Math.pow(x[2] - y[2], 2) |
| ); |
| } |
| |
| convert.rgb.keyword = function (rgb) { |
| var reversed = reverseKeywords[rgb]; |
| if (reversed) { |
| return reversed; |
| } |
| |
| var currentClosestDistance = Infinity; |
| var currentClosestKeyword; |
| |
| for (var keyword in cssKeywords) { |
| if (cssKeywords.hasOwnProperty(keyword)) { |
| var value = cssKeywords[keyword]; |
| |
| // Compute comparative distance |
| var distance = comparativeDistance(rgb, value); |
| |
| // Check if its less, if so set as closest |
| if (distance < currentClosestDistance) { |
| currentClosestDistance = distance; |
| currentClosestKeyword = keyword; |
| } |
| } |
| } |
| |
| return currentClosestKeyword; |
| }; |
| |
| convert.keyword.rgb = function (keyword) { |
| return cssKeywords[keyword]; |
| }; |
| |
| convert.rgb.xyz = function (rgb) { |
| var r = rgb[0] / 255; |
| var g = rgb[1] / 255; |
| var b = rgb[2] / 255; |
| |
| // assume sRGB |
| r = r > 0.04045 ? Math.pow(((r + 0.055) / 1.055), 2.4) : (r / 12.92); |
| g = g > 0.04045 ? Math.pow(((g + 0.055) / 1.055), 2.4) : (g / 12.92); |
| b = b > 0.04045 ? Math.pow(((b + 0.055) / 1.055), 2.4) : (b / 12.92); |
| |
| var x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805); |
| var y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722); |
| var z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505); |
| |
| return [x * 100, y * 100, z * 100]; |
| }; |
| |
| convert.rgb.lab = function (rgb) { |
| var xyz = convert.rgb.xyz(rgb); |
| var x = xyz[0]; |
| var y = xyz[1]; |
| var z = xyz[2]; |
| var l; |
| var a; |
| var b; |
| |
| x /= 95.047; |
| y /= 100; |
| z /= 108.883; |
| |
| x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116); |
| y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116); |
| z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116); |
| |
| l = (116 * y) - 16; |
| a = 500 * (x - y); |
| b = 200 * (y - z); |
| |
| return [l, a, b]; |
| }; |
| |
| convert.hsl.rgb = function (hsl) { |
| var h = hsl[0] / 360; |
| var s = hsl[1] / 100; |
| var l = hsl[2] / 100; |
| var t1; |
| var t2; |
| var t3; |
| var rgb; |
| var val; |
| |
| if (s === 0) { |
| val = l * 255; |
| return [val, val, val]; |
| } |
| |
| if (l < 0.5) { |
| t2 = l * (1 + s); |
| } else { |
| t2 = l + s - l * s; |
| } |
| |
| t1 = 2 * l - t2; |
| |
| rgb = [0, 0, 0]; |
| for (var i = 0; i < 3; i++) { |
| t3 = h + 1 / 3 * -(i - 1); |
| if (t3 < 0) { |
| t3++; |
| } |
| if (t3 > 1) { |
| t3--; |
| } |
| |
| if (6 * t3 < 1) { |
| val = t1 + (t2 - t1) * 6 * t3; |
| } else if (2 * t3 < 1) { |
| val = t2; |
| } else if (3 * t3 < 2) { |
| val = t1 + (t2 - t1) * (2 / 3 - t3) * 6; |
| } else { |
| val = t1; |
| } |
| |
| rgb[i] = val * 255; |
| } |
| |
| return rgb; |
| }; |
| |
| convert.hsl.hsv = function (hsl) { |
| var h = hsl[0]; |
| var s = hsl[1] / 100; |
| var l = hsl[2] / 100; |
| var smin = s; |
| var lmin = Math.max(l, 0.01); |
| var sv; |
| var v; |
| |
| l *= 2; |
| s *= (l <= 1) ? l : 2 - l; |
| smin *= lmin <= 1 ? lmin : 2 - lmin; |
| v = (l + s) / 2; |
| sv = l === 0 ? (2 * smin) / (lmin + smin) : (2 * s) / (l + s); |
| |
| return [h, sv * 100, v * 100]; |
| }; |
| |
| convert.hsv.rgb = function (hsv) { |
| var h = hsv[0] / 60; |
| var s = hsv[1] / 100; |
| var v = hsv[2] / 100; |
| var hi = Math.floor(h) % 6; |
| |
| var f = h - Math.floor(h); |
| var p = 255 * v * (1 - s); |
| var q = 255 * v * (1 - (s * f)); |
| var t = 255 * v * (1 - (s * (1 - f))); |
| v *= 255; |
| |
| switch (hi) { |
| case 0: |
| return [v, t, p]; |
| case 1: |
| return [q, v, p]; |
| case 2: |
| return [p, v, t]; |
| case 3: |
| return [p, q, v]; |
| case 4: |
| return [t, p, v]; |
| case 5: |
| return [v, p, q]; |
| } |
| }; |
| |
| convert.hsv.hsl = function (hsv) { |
| var h = hsv[0]; |
| var s = hsv[1] / 100; |
| var v = hsv[2] / 100; |
| var vmin = Math.max(v, 0.01); |
| var lmin; |
| var sl; |
| var l; |
| |
| l = (2 - s) * v; |
| lmin = (2 - s) * vmin; |
| sl = s * vmin; |
| sl /= (lmin <= 1) ? lmin : 2 - lmin; |
| sl = sl || 0; |
| l /= 2; |
| |
| return [h, sl * 100, l * 100]; |
| }; |
| |
| // http://dev.w3.org/csswg/css-color/#hwb-to-rgb |
| convert.hwb.rgb = function (hwb) { |
| var h = hwb[0] / 360; |
| var wh = hwb[1] / 100; |
| var bl = hwb[2] / 100; |
| var ratio = wh + bl; |
| var i; |
| var v; |
| var f; |
| var n; |
| |
| // wh + bl cant be > 1 |
| if (ratio > 1) { |
| wh /= ratio; |
| bl /= ratio; |
| } |
| |
| i = Math.floor(6 * h); |
| v = 1 - bl; |
| f = 6 * h - i; |
| |
| if ((i & 0x01) !== 0) { |
| f = 1 - f; |
| } |
| |
| n = wh + f * (v - wh); // linear interpolation |
| |
| var r; |
| var g; |
| var b; |
| switch (i) { |
| default: |
| case 6: |
| case 0: r = v; g = n; b = wh; break; |
| case 1: r = n; g = v; b = wh; break; |
| case 2: r = wh; g = v; b = n; break; |
| case 3: r = wh; g = n; b = v; break; |
| case 4: r = n; g = wh; b = v; break; |
| case 5: r = v; g = wh; b = n; break; |
| } |
| |
| return [r * 255, g * 255, b * 255]; |
| }; |
| |
| convert.cmyk.rgb = function (cmyk) { |
| var c = cmyk[0] / 100; |
| var m = cmyk[1] / 100; |
| var y = cmyk[2] / 100; |
| var k = cmyk[3] / 100; |
| var r; |
| var g; |
| var b; |
| |
| r = 1 - Math.min(1, c * (1 - k) + k); |
| g = 1 - Math.min(1, m * (1 - k) + k); |
| b = 1 - Math.min(1, y * (1 - k) + k); |
| |
| return [r * 255, g * 255, b * 255]; |
| }; |
| |
| convert.xyz.rgb = function (xyz) { |
| var x = xyz[0] / 100; |
| var y = xyz[1] / 100; |
| var z = xyz[2] / 100; |
| var r; |
| var g; |
| var b; |
| |
| r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986); |
| g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415); |
| b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570); |
| |
| // assume sRGB |
| r = r > 0.0031308 |
| ? ((1.055 * Math.pow(r, 1.0 / 2.4)) - 0.055) |
| : r * 12.92; |
| |
| g = g > 0.0031308 |
| ? ((1.055 * Math.pow(g, 1.0 / 2.4)) - 0.055) |
| : g * 12.92; |
| |
| b = b > 0.0031308 |
| ? ((1.055 * Math.pow(b, 1.0 / 2.4)) - 0.055) |
| : b * 12.92; |
| |
| r = Math.min(Math.max(0, r), 1); |
| g = Math.min(Math.max(0, g), 1); |
| b = Math.min(Math.max(0, b), 1); |
| |
| return [r * 255, g * 255, b * 255]; |
| }; |
| |
| convert.xyz.lab = function (xyz) { |
| var x = xyz[0]; |
| var y = xyz[1]; |
| var z = xyz[2]; |
| var l; |
| var a; |
| var b; |
| |
| x /= 95.047; |
| y /= 100; |
| z /= 108.883; |
| |
| x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116); |
| y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116); |
| z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116); |
| |
| l = (116 * y) - 16; |
| a = 500 * (x - y); |
| b = 200 * (y - z); |
| |
| return [l, a, b]; |
| }; |
| |
| convert.lab.xyz = function (lab) { |
| var l = lab[0]; |
| var a = lab[1]; |
| var b = lab[2]; |
| var x; |
| var y; |
| var z; |
| |
| y = (l + 16) / 116; |
| x = a / 500 + y; |
| z = y - b / 200; |
| |
| var y2 = Math.pow(y, 3); |
| var x2 = Math.pow(x, 3); |
| var z2 = Math.pow(z, 3); |
| y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787; |
| x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787; |
| z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787; |
| |
| x *= 95.047; |
| y *= 100; |
| z *= 108.883; |
| |
| return [x, y, z]; |
| }; |
| |
| convert.lab.lch = function (lab) { |
| var l = lab[0]; |
| var a = lab[1]; |
| var b = lab[2]; |
| var hr; |
| var h; |
| var c; |
| |
| hr = Math.atan2(b, a); |
| h = hr * 360 / 2 / Math.PI; |
| |
| if (h < 0) { |
| h += 360; |
| } |
| |
| c = Math.sqrt(a * a + b * b); |
| |
| return [l, c, h]; |
| }; |
| |
| convert.lch.lab = function (lch) { |
| var l = lch[0]; |
| var c = lch[1]; |
| var h = lch[2]; |
| var a; |
| var b; |
| var hr; |
| |
| hr = h / 360 * 2 * Math.PI; |
| a = c * Math.cos(hr); |
| b = c * Math.sin(hr); |
| |
| return [l, a, b]; |
| }; |
| |
| convert.rgb.ansi16 = function (args) { |
| var r = args[0]; |
| var g = args[1]; |
| var b = args[2]; |
| var value = 1 in arguments ? arguments[1] : convert.rgb.hsv(args)[2]; // hsv -> ansi16 optimization |
| |
| value = Math.round(value / 50); |
| |
| if (value === 0) { |
| return 30; |
| } |
| |
| var ansi = 30 |
| + ((Math.round(b / 255) << 2) |
| | (Math.round(g / 255) << 1) |
| | Math.round(r / 255)); |
| |
| if (value === 2) { |
| ansi += 60; |
| } |
| |
| return ansi; |
| }; |
| |
| convert.hsv.ansi16 = function (args) { |
| // optimization here; we already know the value and don't need to get |
| // it converted for us. |
| return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]); |
| }; |
| |
| convert.rgb.ansi256 = function (args) { |
| var r = args[0]; |
| var g = args[1]; |
| var b = args[2]; |
| |
| // we use the extended greyscale palette here, with the exception of |
| // black and white. normal palette only has 4 greyscale shades. |
| if (r === g && g === b) { |
| if (r < 8) { |
| return 16; |
| } |
| |
| if (r > 248) { |
| return 231; |
| } |
| |
| return Math.round(((r - 8) / 247) * 24) + 232; |
| } |
| |
| var ansi = 16 |
| + (36 * Math.round(r / 255 * 5)) |
| + (6 * Math.round(g / 255 * 5)) |
| + Math.round(b / 255 * 5); |
| |
| return ansi; |
| }; |
| |
| convert.ansi16.rgb = function (args) { |
| var color = args % 10; |
| |
| // handle greyscale |
| if (color === 0 || color === 7) { |
| if (args > 50) { |
| color += 3.5; |
| } |
| |
| color = color / 10.5 * 255; |
| |
| return [color, color, color]; |
| } |
| |
| var mult = (~~(args > 50) + 1) * 0.5; |
| var r = ((color & 1) * mult) * 255; |
| var g = (((color >> 1) & 1) * mult) * 255; |
| var b = (((color >> 2) & 1) * mult) * 255; |
| |
| return [r, g, b]; |
| }; |
| |
| convert.ansi256.rgb = function (args) { |
| // handle greyscale |
| if (args >= 232) { |
| var c = (args - 232) * 10 + 8; |
| return [c, c, c]; |
| } |
| |
| args -= 16; |
| |
| var rem; |
| var r = Math.floor(args / 36) / 5 * 255; |
| var g = Math.floor((rem = args % 36) / 6) / 5 * 255; |
| var b = (rem % 6) / 5 * 255; |
| |
| return [r, g, b]; |
| }; |
| |
| convert.rgb.hex = function (args) { |
| var integer = ((Math.round(args[0]) & 0xFF) << 16) |
| + ((Math.round(args[1]) & 0xFF) << 8) |
| + (Math.round(args[2]) & 0xFF); |
| |
| var string = integer.toString(16).toUpperCase(); |
| return '000000'.substring(string.length) + string; |
| }; |
| |
| convert.hex.rgb = function (args) { |
| var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i); |
| if (!match) { |
| return [0, 0, 0]; |
| } |
| |
| var colorString = match[0]; |
| |
| if (match[0].length === 3) { |
| colorString = colorString.split('').map(function (char) { |
| return char + char; |
| }).join(''); |
| } |
| |
| var integer = parseInt(colorString, 16); |
| var r = (integer >> 16) & 0xFF; |
| var g = (integer >> 8) & 0xFF; |
| var b = integer & 0xFF; |
| |
| return [r, g, b]; |
| }; |
| |
| convert.rgb.hcg = function (rgb) { |
| var r = rgb[0] / 255; |
| var g = rgb[1] / 255; |
| var b = rgb[2] / 255; |
| var max = Math.max(Math.max(r, g), b); |
| var min = Math.min(Math.min(r, g), b); |
| var chroma = (max - min); |
| var grayscale; |
| var hue; |
| |
| if (chroma < 1) { |
| grayscale = min / (1 - chroma); |
| } else { |
| grayscale = 0; |
| } |
| |
| if (chroma <= 0) { |
| hue = 0; |
| } else |
| if (max === r) { |
| hue = ((g - b) / chroma) % 6; |
| } else |
| if (max === g) { |
| hue = 2 + (b - r) / chroma; |
| } else { |
| hue = 4 + (r - g) / chroma + 4; |
| } |
| |
| hue /= 6; |
| hue %= 1; |
| |
| return [hue * 360, chroma * 100, grayscale * 100]; |
| }; |
| |
| convert.hsl.hcg = function (hsl) { |
| var s = hsl[1] / 100; |
| var l = hsl[2] / 100; |
| var c = 1; |
| var f = 0; |
| |
| if (l < 0.5) { |
| c = 2.0 * s * l; |
| } else { |
| c = 2.0 * s * (1.0 - l); |
| } |
| |
| if (c < 1.0) { |
| f = (l - 0.5 * c) / (1.0 - c); |
| } |
| |
| return [hsl[0], c * 100, f * 100]; |
| }; |
| |
| convert.hsv.hcg = function (hsv) { |
| var s = hsv[1] / 100; |
| var v = hsv[2] / 100; |
| |
| var c = s * v; |
| var f = 0; |
| |
| if (c < 1.0) { |
| f = (v - c) / (1 - c); |
| } |
| |
| return [hsv[0], c * 100, f * 100]; |
| }; |
| |
| convert.hcg.rgb = function (hcg) { |
| var h = hcg[0] / 360; |
| var c = hcg[1] / 100; |
| var g = hcg[2] / 100; |
| |
| if (c === 0.0) { |
| return [g * 255, g * 255, g * 255]; |
| } |
| |
| var pure = [0, 0, 0]; |
| var hi = (h % 1) * 6; |
| var v = hi % 1; |
| var w = 1 - v; |
| var mg = 0; |
| |
| switch (Math.floor(hi)) { |
| case 0: |
| pure[0] = 1; pure[1] = v; pure[2] = 0; break; |
| case 1: |
| pure[0] = w; pure[1] = 1; pure[2] = 0; break; |
| case 2: |
| pure[0] = 0; pure[1] = 1; pure[2] = v; break; |
| case 3: |
| pure[0] = 0; pure[1] = w; pure[2] = 1; break; |
| case 4: |
| pure[0] = v; pure[1] = 0; pure[2] = 1; break; |
| default: |
| pure[0] = 1; pure[1] = 0; pure[2] = w; |
| } |
| |
| mg = (1.0 - c) * g; |
| |
| return [ |
| (c * pure[0] + mg) * 255, |
| (c * pure[1] + mg) * 255, |
| (c * pure[2] + mg) * 255 |
| ]; |
| }; |
| |
| convert.hcg.hsv = function (hcg) { |
| var c = hcg[1] / 100; |
| var g = hcg[2] / 100; |
| |
| var v = c + g * (1.0 - c); |
| var f = 0; |
| |
| if (v > 0.0) { |
| f = c / v; |
| } |
| |
| return [hcg[0], f * 100, v * 100]; |
| }; |
| |
| convert.hcg.hsl = function (hcg) { |
| var c = hcg[1] / 100; |
| var g = hcg[2] / 100; |
| |
| var l = g * (1.0 - c) + 0.5 * c; |
| var s = 0; |
| |
| if (l > 0.0 && l < 0.5) { |
| s = c / (2 * l); |
| } else |
| if (l >= 0.5 && l < 1.0) { |
| s = c / (2 * (1 - l)); |
| } |
| |
| return [hcg[0], s * 100, l * 100]; |
| }; |
| |
| convert.hcg.hwb = function (hcg) { |
| var c = hcg[1] / 100; |
| var g = hcg[2] / 100; |
| var v = c + g * (1.0 - c); |
| return [hcg[0], (v - c) * 100, (1 - v) * 100]; |
| }; |
| |
| convert.hwb.hcg = function (hwb) { |
| var w = hwb[1] / 100; |
| var b = hwb[2] / 100; |
| var v = 1 - b; |
| var c = v - w; |
| var g = 0; |
| |
| if (c < 1) { |
| g = (v - c) / (1 - c); |
| } |
| |
| return [hwb[0], c * 100, g * 100]; |
| }; |
| |
| convert.apple.rgb = function (apple) { |
| return [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255]; |
| }; |
| |
| convert.rgb.apple = function (rgb) { |
| return [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535]; |
| }; |
| |
| convert.gray.rgb = function (args) { |
| return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255]; |
| }; |
| |
| convert.gray.hsl = convert.gray.hsv = function (args) { |
| return [0, 0, args[0]]; |
| }; |
| |
| convert.gray.hwb = function (gray) { |
| return [0, 100, gray[0]]; |
| }; |
| |
| convert.gray.cmyk = function (gray) { |
| return [0, 0, 0, gray[0]]; |
| }; |
| |
| convert.gray.lab = function (gray) { |
| return [gray[0], 0, 0]; |
| }; |
| |
| convert.gray.hex = function (gray) { |
| var val = Math.round(gray[0] / 100 * 255) & 0xFF; |
| var integer = (val << 16) + (val << 8) + val; |
| |
| var string = integer.toString(16).toUpperCase(); |
| return '000000'.substring(string.length) + string; |
| }; |
| |
| convert.rgb.gray = function (rgb) { |
| var val = (rgb[0] + rgb[1] + rgb[2]) / 3; |
| return [val / 255 * 100]; |
| }; |