StackGenVis: Alignment of Data, Algorithms, and Models for Stacking Ensemble Learning Using Performance Metrics
https://doi.org/10.1109/TVCG.2020.3030352
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
640 lines
20 KiB
640 lines
20 KiB
(function (global, factory) {
|
|
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vega-util'), require('d3-array'), require('d3-scale'), require('d3-interpolate')) :
|
|
typeof define === 'function' && define.amd ? define(['exports', 'vega-util', 'd3-array', 'd3-scale', 'd3-interpolate'], factory) :
|
|
(global = global || self, factory(global.vega = {}, global.vega, global.d3, global.d3, global.d3));
|
|
}(this, (function (exports, vegaUtil, d3Array, $, $$1) { 'use strict';
|
|
|
|
function bandSpace(count, paddingInner, paddingOuter) {
|
|
var space = count - paddingInner + paddingOuter * 2;
|
|
return count ? (space > 0 ? space : 1) : 0;
|
|
}
|
|
|
|
const Identity = 'identity';
|
|
|
|
const Linear = 'linear';
|
|
const Log = 'log';
|
|
const Pow = 'pow';
|
|
const Sqrt = 'sqrt';
|
|
const Symlog = 'symlog';
|
|
|
|
const Time = 'time';
|
|
const UTC = 'utc';
|
|
|
|
const Sequential = 'sequential';
|
|
const Diverging = 'diverging';
|
|
|
|
const Quantile = 'quantile';
|
|
const Quantize = 'quantize';
|
|
const Threshold = 'threshold';
|
|
|
|
const Ordinal = 'ordinal';
|
|
const Point = 'point';
|
|
const Band = 'band';
|
|
const BinOrdinal = 'bin-ordinal';
|
|
|
|
// categories
|
|
const Continuous = 'continuous';
|
|
const Discrete = 'discrete';
|
|
const Discretizing = 'discretizing';
|
|
const Interpolating = 'interpolating';
|
|
const Temporal = 'temporal';
|
|
|
|
function invertRange(scale) {
|
|
return function(_) {
|
|
var lo = _[0],
|
|
hi = _[1],
|
|
t;
|
|
|
|
if (hi < lo) {
|
|
t = lo;
|
|
lo = hi;
|
|
hi = t;
|
|
}
|
|
|
|
return [
|
|
scale.invert(lo),
|
|
scale.invert(hi)
|
|
];
|
|
}
|
|
}
|
|
|
|
function invertRangeExtent(scale) {
|
|
return function(_) {
|
|
var range = scale.range(),
|
|
lo = _[0],
|
|
hi = _[1],
|
|
min = -1, max, t, i, n;
|
|
|
|
if (hi < lo) {
|
|
t = lo;
|
|
lo = hi;
|
|
hi = t;
|
|
}
|
|
|
|
for (i=0, n=range.length; i<n; ++i) {
|
|
if (range[i] >= lo && range[i] <= hi) {
|
|
if (min < 0) min = i;
|
|
max = i;
|
|
}
|
|
}
|
|
|
|
if (min < 0) return undefined;
|
|
|
|
lo = scale.invertExtent(range[min]);
|
|
hi = scale.invertExtent(range[max]);
|
|
|
|
return [
|
|
lo[0] === undefined ? lo[1] : lo[0],
|
|
hi[1] === undefined ? hi[0] : hi[1]
|
|
];
|
|
}
|
|
}
|
|
|
|
function band() {
|
|
var scale = $.scaleOrdinal().unknown(undefined),
|
|
domain = scale.domain,
|
|
ordinalRange = scale.range,
|
|
range = [0, 1],
|
|
step,
|
|
bandwidth,
|
|
round = false,
|
|
paddingInner = 0,
|
|
paddingOuter = 0,
|
|
align = 0.5;
|
|
|
|
delete scale.unknown;
|
|
|
|
function rescale() {
|
|
var n = domain().length,
|
|
reverse = range[1] < range[0],
|
|
start = range[reverse - 0],
|
|
stop = range[1 - reverse],
|
|
space = bandSpace(n, paddingInner, paddingOuter);
|
|
|
|
step = (stop - start) / (space || 1);
|
|
if (round) {
|
|
step = Math.floor(step);
|
|
}
|
|
start += (stop - start - step * (n - paddingInner)) * align;
|
|
bandwidth = step * (1 - paddingInner);
|
|
if (round) {
|
|
start = Math.round(start);
|
|
bandwidth = Math.round(bandwidth);
|
|
}
|
|
var values = d3Array.range(n).map(function(i) { return start + step * i; });
|
|
return ordinalRange(reverse ? values.reverse() : values);
|
|
}
|
|
|
|
scale.domain = function(_) {
|
|
if (arguments.length) {
|
|
domain(_);
|
|
return rescale();
|
|
} else {
|
|
return domain();
|
|
}
|
|
};
|
|
|
|
scale.range = function(_) {
|
|
if (arguments.length) {
|
|
range = [+_[0], +_[1]];
|
|
return rescale();
|
|
} else {
|
|
return range.slice();
|
|
}
|
|
};
|
|
|
|
scale.rangeRound = function(_) {
|
|
range = [+_[0], +_[1]];
|
|
round = true;
|
|
return rescale();
|
|
};
|
|
|
|
scale.bandwidth = function() {
|
|
return bandwidth;
|
|
};
|
|
|
|
scale.step = function() {
|
|
return step;
|
|
};
|
|
|
|
scale.round = function(_) {
|
|
if (arguments.length) {
|
|
round = !!_;
|
|
return rescale();
|
|
} else {
|
|
return round;
|
|
}
|
|
};
|
|
|
|
scale.padding = function(_) {
|
|
if (arguments.length) {
|
|
paddingOuter = Math.max(0, Math.min(1, _));
|
|
paddingInner = paddingOuter;
|
|
return rescale();
|
|
} else {
|
|
return paddingInner;
|
|
}
|
|
};
|
|
|
|
scale.paddingInner = function(_) {
|
|
if (arguments.length) {
|
|
paddingInner = Math.max(0, Math.min(1, _));
|
|
return rescale();
|
|
} else {
|
|
return paddingInner;
|
|
}
|
|
};
|
|
|
|
scale.paddingOuter = function(_) {
|
|
if (arguments.length) {
|
|
paddingOuter = Math.max(0, Math.min(1, _));
|
|
return rescale();
|
|
} else {
|
|
return paddingOuter;
|
|
}
|
|
};
|
|
|
|
scale.align = function(_) {
|
|
if (arguments.length) {
|
|
align = Math.max(0, Math.min(1, _));
|
|
return rescale();
|
|
} else {
|
|
return align;
|
|
}
|
|
};
|
|
|
|
scale.invertRange = function(_) {
|
|
// bail if range has null or undefined values
|
|
if (_[0] == null || _[1] == null) return;
|
|
|
|
var lo = +_[0],
|
|
hi = +_[1],
|
|
reverse = range[1] < range[0],
|
|
values = reverse ? ordinalRange().reverse() : ordinalRange(),
|
|
n = values.length - 1, a, b, t;
|
|
|
|
// bail if either range endpoint is invalid
|
|
if (lo !== lo || hi !== hi) return;
|
|
|
|
// order range inputs, bail if outside of scale range
|
|
if (hi < lo) {
|
|
t = lo;
|
|
lo = hi;
|
|
hi = t;
|
|
}
|
|
if (hi < values[0] || lo > range[1-reverse]) return;
|
|
|
|
// binary search to index into scale range
|
|
a = Math.max(0, d3Array.bisectRight(values, lo) - 1);
|
|
b = lo===hi ? a : d3Array.bisectRight(values, hi) - 1;
|
|
|
|
// increment index a if lo is within padding gap
|
|
if (lo - values[a] > bandwidth + 1e-10) ++a;
|
|
|
|
if (reverse) {
|
|
// map + swap
|
|
t = a;
|
|
a = n - b;
|
|
b = n - t;
|
|
}
|
|
return (a > b) ? undefined : domain().slice(a, b+1);
|
|
};
|
|
|
|
scale.invert = function(_) {
|
|
var value = scale.invertRange([_, _]);
|
|
return value ? value[0] : value;
|
|
};
|
|
|
|
scale.copy = function() {
|
|
return band()
|
|
.domain(domain())
|
|
.range(range)
|
|
.round(round)
|
|
.paddingInner(paddingInner)
|
|
.paddingOuter(paddingOuter)
|
|
.align(align);
|
|
};
|
|
|
|
return rescale();
|
|
}
|
|
|
|
function pointish(scale) {
|
|
var copy = scale.copy;
|
|
|
|
scale.padding = scale.paddingOuter;
|
|
delete scale.paddingInner;
|
|
|
|
scale.copy = function() {
|
|
return pointish(copy());
|
|
};
|
|
|
|
return scale;
|
|
}
|
|
|
|
function point() {
|
|
return pointish(band().paddingInner(1));
|
|
}
|
|
|
|
var map = Array.prototype.map;
|
|
|
|
function numbers(_) {
|
|
return map.call(_, function(x) { return +x; });
|
|
}
|
|
|
|
var slice = Array.prototype.slice;
|
|
|
|
function scaleBinOrdinal() {
|
|
var domain = [],
|
|
range = [];
|
|
|
|
function scale(x) {
|
|
return x == null || x !== x
|
|
? undefined
|
|
: range[(d3Array.bisect(domain, x) - 1) % range.length];
|
|
}
|
|
|
|
scale.domain = function(_) {
|
|
if (arguments.length) {
|
|
domain = numbers(_);
|
|
return scale;
|
|
} else {
|
|
return domain.slice();
|
|
}
|
|
};
|
|
|
|
scale.range = function(_) {
|
|
if (arguments.length) {
|
|
range = slice.call(_);
|
|
return scale;
|
|
} else {
|
|
return range.slice();
|
|
}
|
|
};
|
|
|
|
scale.tickFormat = function(count, specifier) {
|
|
return $.tickFormat(domain[0], vegaUtil.peek(domain), count == null ? 10 : count, specifier);
|
|
};
|
|
|
|
scale.copy = function() {
|
|
return scaleBinOrdinal().domain(scale.domain()).range(scale.range());
|
|
};
|
|
|
|
return scale;
|
|
}
|
|
|
|
// scale registry
|
|
const scales = {};
|
|
|
|
/**
|
|
* Augment scales with their type and needed inverse methods.
|
|
*/
|
|
function create(type, constructor, metadata) {
|
|
const ctr = function scale() {
|
|
var s = constructor();
|
|
|
|
if (!s.invertRange) {
|
|
s.invertRange = s.invert ? invertRange(s)
|
|
: s.invertExtent ? invertRangeExtent(s)
|
|
: undefined;
|
|
}
|
|
|
|
s.type = type;
|
|
return s;
|
|
};
|
|
|
|
ctr.metadata = vegaUtil.toSet(vegaUtil.array(metadata));
|
|
|
|
return ctr;
|
|
}
|
|
|
|
function scale(type, scale, metadata) {
|
|
if (arguments.length > 1) {
|
|
scales[type] = create(type, scale, metadata);
|
|
return this;
|
|
} else {
|
|
return isValidScaleType(type) ? scales[type] : undefined;
|
|
}
|
|
}
|
|
|
|
// identity scale
|
|
scale(Identity, $.scaleIdentity);
|
|
|
|
// continuous scales
|
|
scale(Linear, $.scaleLinear, Continuous);
|
|
scale(Log, $.scaleLog, [Continuous, Log]);
|
|
scale(Pow, $.scalePow, Continuous);
|
|
scale(Sqrt, $.scaleSqrt, Continuous);
|
|
scale(Symlog, $.scaleSymlog, Continuous);
|
|
scale(Time, $.scaleTime, [Continuous, Temporal]);
|
|
scale(UTC, $.scaleUtc, [Continuous, Temporal]);
|
|
|
|
// sequential scales
|
|
scale(Sequential, $.scaleSequential, [Continuous, Interpolating]); // backwards compat
|
|
scale(`${Sequential}-${Linear}`, $.scaleSequential, [Continuous, Interpolating]);
|
|
scale(`${Sequential}-${Log}`, $.scaleSequentialLog, [Continuous, Interpolating, Log]);
|
|
scale(`${Sequential}-${Pow}`, $.scaleSequentialPow, [Continuous, Interpolating]);
|
|
scale(`${Sequential}-${Sqrt}`, $.scaleSequentialSqrt, [Continuous, Interpolating]);
|
|
scale(`${Sequential}-${Symlog}`, $.scaleSequentialSymlog, [Continuous, Interpolating]);
|
|
|
|
// diverging scales
|
|
scale(`${Diverging}-${Linear}`, $.scaleDiverging, [Continuous, Interpolating]);
|
|
scale(`${Diverging}-${Log}`, $.scaleDivergingLog, [Continuous, Interpolating, Log]);
|
|
scale(`${Diverging}-${Pow}`, $.scaleDivergingPow, [Continuous, Interpolating]);
|
|
scale(`${Diverging}-${Sqrt}`, $.scaleDivergingSqrt, [Continuous, Interpolating]);
|
|
scale(`${Diverging}-${Symlog}`, $.scaleDivergingSymlog, [Continuous, Interpolating]);
|
|
|
|
// discretizing scales
|
|
scale(Quantile, $.scaleQuantile, [Discretizing, Quantile]);
|
|
scale(Quantize, $.scaleQuantize, Discretizing);
|
|
scale(Threshold, $.scaleThreshold, Discretizing);
|
|
|
|
// discrete scales
|
|
scale(BinOrdinal, scaleBinOrdinal, [Discrete, Discretizing]);
|
|
scale(Ordinal, $.scaleOrdinal, Discrete);
|
|
scale(Band, band, Discrete);
|
|
scale(Point, point, Discrete);
|
|
|
|
function isValidScaleType(type) {
|
|
return vegaUtil.hasOwnProperty(scales, type);
|
|
}
|
|
|
|
function hasType(key, type) {
|
|
const s = scales[key];
|
|
return s && s.metadata[type];
|
|
}
|
|
|
|
function isContinuous(key) {
|
|
return hasType(key, Continuous);
|
|
}
|
|
|
|
function isDiscrete(key) {
|
|
return hasType(key, Discrete);
|
|
}
|
|
|
|
function isDiscretizing(key) {
|
|
return hasType(key, Discretizing);
|
|
}
|
|
|
|
function isLogarithmic(key) {
|
|
return hasType(key, Log);
|
|
}
|
|
|
|
function isTemporal(key) {
|
|
return hasType(key, Temporal);
|
|
}
|
|
|
|
function isInterpolating(key) {
|
|
return hasType(key, Interpolating);
|
|
}
|
|
|
|
function isQuantile(key) {
|
|
return hasType(key, Quantile);
|
|
}
|
|
|
|
const scaleProps = ['clamp', 'base', 'constant', 'exponent'];
|
|
|
|
function interpolateRange(interpolator, range) {
|
|
var start = range[0],
|
|
span = vegaUtil.peek(range) - start;
|
|
return function(i) { return interpolator(start + i * span); };
|
|
}
|
|
|
|
function interpolateColors(colors, type, gamma) {
|
|
return $$1.piecewise(interpolate(type || 'rgb', gamma), colors);
|
|
}
|
|
|
|
function quantizeInterpolator(interpolator, count) {
|
|
var samples = new Array(count),
|
|
n = count + 1;
|
|
for (var i = 0; i < count;) samples[i] = interpolator(++i / n);
|
|
return samples;
|
|
}
|
|
|
|
function scaleCopy(scale) {
|
|
const t = scale.type,
|
|
s = scale.copy();
|
|
s.type = t;
|
|
return s;
|
|
}
|
|
|
|
function scaleFraction(scale$1, min, max) {
|
|
var delta = max - min, i, t, s;
|
|
|
|
if (!delta || !Number.isFinite(delta)) {
|
|
return vegaUtil.constant(0.5);
|
|
} else {
|
|
i = (t = scale$1.type).indexOf('-');
|
|
t = i < 0 ? t : t.slice(i + 1);
|
|
s = scale(t)().domain([min, max]).range([0, 1]);
|
|
scaleProps.forEach(m => scale$1[m] ? s[m](scale$1[m]()) : 0);
|
|
return s;
|
|
}
|
|
}
|
|
|
|
function interpolate(type, gamma) {
|
|
var interp = $$1[method(type)];
|
|
return (gamma != null && interp && interp.gamma)
|
|
? interp.gamma(gamma)
|
|
: interp;
|
|
}
|
|
|
|
function method(type) {
|
|
return 'interpolate' + type.toLowerCase()
|
|
.split('-')
|
|
.map(function(s) { return s[0].toUpperCase() + s.slice(1); })
|
|
.join('');
|
|
}
|
|
|
|
const continuous = {
|
|
blues: 'cfe1f2bed8eca8cee58fc1de74b2d75ba3cf4592c63181bd206fb2125ca40a4a90',
|
|
greens: 'd3eecdc0e6baabdda594d3917bc77d60ba6c46ab5e329a512089430e7735036429',
|
|
greys: 'e2e2e2d4d4d4c4c4c4b1b1b19d9d9d8888887575756262624d4d4d3535351e1e1e',
|
|
oranges: 'fdd8b3fdc998fdb87bfda55efc9244f87f2cf06b18e4580bd14904b93d029f3303',
|
|
purples: 'e2e1efd4d4e8c4c5e0b4b3d6a3a0cc928ec3827cb97566ae684ea25c3696501f8c',
|
|
reds: 'fdc9b4fcb49afc9e80fc8767fa7051f6573fec3f2fdc2a25c81b1db21218970b13',
|
|
|
|
blueGreen: 'd5efedc1e8e0a7ddd18bd2be70c6a958ba9144ad77319c5d2089460e7736036429',
|
|
bluePurple: 'ccddecbad0e4a8c2dd9ab0d4919cc98d85be8b6db28a55a6873c99822287730f71',
|
|
greenBlue: 'd3eecec5e8c3b1e1bb9bd8bb82cec269c2ca51b2cd3c9fc7288abd1675b10b60a1',
|
|
orangeRed: 'fddcaffdcf9bfdc18afdad77fb9562f67d53ee6545e24932d32d1ebf130da70403',
|
|
purpleBlue: 'dbdaebc8cee4b1c3de97b7d87bacd15b9fc93a90c01e7fb70b70ab056199045281',
|
|
purpleBlueGreen: 'dbd8eac8cee4b0c3de93b7d872acd1549fc83892bb1c88a3097f8702736b016353',
|
|
purpleRed: 'dcc9e2d3b3d7ce9eccd186c0da6bb2e14da0e23189d91e6fc61159ab07498f023a',
|
|
redPurple: 'fccfccfcbec0faa9b8f98faff571a5ec539ddb3695c41b8aa908808d0179700174',
|
|
yellowGreen: 'e4f4acd1eca0b9e2949ed68880c97c62bb6e47aa5e3297502083440e723b036034',
|
|
yellowOrangeBrown: 'feeaa1fedd84fecc63feb746fca031f68921eb7215db5e0bc54c05ab3d038f3204',
|
|
yellowOrangeRed: 'fee087fed16ffebd59fea849fd903efc7335f9522bee3423de1b20ca0b22af0225',
|
|
|
|
blueOrange: '134b852f78b35da2cb9dcae1d2e5eff2f0ebfce0bafbbf74e8932fc5690d994a07',
|
|
brownBlueGreen: '704108a0651ac79548e3c78af3e6c6eef1eac9e9e48ed1c74da79e187a72025147',
|
|
purpleGreen: '5b1667834792a67fb6c9aed3e6d6e8eff0efd9efd5aedda971bb75368e490e5e29',
|
|
purpleOrange: '4114696647968f83b7b9b4d6dadbebf3eeeafce0bafbbf74e8932fc5690d994a07',
|
|
redBlue: '8c0d25bf363adf745ef4ae91fbdbc9f2efeed2e5ef9dcae15da2cb2f78b3134b85',
|
|
redGrey: '8c0d25bf363adf745ef4ae91fcdccbfaf4f1e2e2e2c0c0c0969696646464343434',
|
|
yellowGreenBlue: 'eff9bddbf1b4bde5b594d5b969c5be45b4c22c9ec02182b82163aa23479c1c3185',
|
|
redYellowBlue: 'a50026d4322cf16e43fcac64fedd90faf8c1dcf1ecabd6e875abd04a74b4313695',
|
|
redYellowGreen: 'a50026d4322cf16e43fcac63fedd8df9f7aed7ee8ea4d86e64bc6122964f006837',
|
|
pinkYellowGreen: '8e0152c0267edd72adf0b3d6faddedf5f3efe1f2cab6de8780bb474f9125276419',
|
|
spectral: '9e0142d13c4bf0704afcac63fedd8dfbf8b0e0f3a1a9dda269bda94288b55e4fa2',
|
|
|
|
viridis: '440154470e61481a6c482575472f7d443a834144873d4e8a39568c35608d31688e2d708e2a788e27818e23888e21918d1f988b1fa08822a8842ab07f35b77943bf7154c56866cc5d7ad1518fd744a5db36bcdf27d2e21be9e51afde725',
|
|
magma: '0000040404130b0924150e3720114b2c11603b0f704a107957157e651a80721f817f24828c29819a2e80a8327db6377ac43c75d1426fde4968e95462f1605df76f5cfa7f5efc8f65fe9f6dfeaf78febf84fece91fddea0fcedaffcfdbf',
|
|
inferno: '0000040403130c0826170c3b240c4f330a5f420a68500d6c5d126e6b176e781c6d86216b932667a12b62ae305cbb3755c73e4cd24644dd513ae65c30ed6925f3771af8850ffb9506fca50afcb519fac62df6d645f2e661f3f484fcffa4',
|
|
plasma: '0d088723069033059742039d5002a25d01a66a00a87801a88405a7900da49c179ea72198b12a90ba3488c33d80cb4779d35171da5a69e16462e76e5bed7953f2834cf68f44fa9a3dfca636fdb32ffec029fcce25f9dc24f5ea27f0f921',
|
|
|
|
rainbow: '6e40aa883eb1a43db3bf3cafd83fa4ee4395fe4b83ff576eff6659ff7847ff8c38f3a130e2b72fcfcc36bee044aff05b8ff4576ff65b52f6673af27828ea8d1ddfa319d0b81cbecb23abd82f96e03d82e14c6edb5a5dd0664dbf6e40aa',
|
|
sinebow: 'ff4040fc582af47218e78d0bd5a703bfbf00a7d5038de70b72f41858fc2a40ff402afc5818f4720be78d03d5a700bfbf03a7d50b8de71872f42a58fc4040ff582afc7218f48d0be7a703d5bf00bfd503a7e70b8df41872fc2a58ff4040',
|
|
|
|
browns: 'eedbbdecca96e9b97ae4a865dc9856d18954c7784cc0673fb85536ad44339f3632',
|
|
tealBlues: 'bce4d89dd3d181c3cb65b3c245a2b9368fae347da0306a932c5985',
|
|
teals: 'bbdfdfa2d4d58ac9c975bcbb61b0af4da5a43799982b8b8c1e7f7f127273006667',
|
|
warmGreys: 'dcd4d0cec5c1c0b8b4b3aaa7a59c9998908c8b827f7e7673726866665c5a59504e',
|
|
|
|
goldGreen: 'f4d166d5ca60b6c35c98bb597cb25760a6564b9c533f8f4f33834a257740146c36',
|
|
goldOrange: 'f4d166f8be5cf8aa4cf5983bf3852aef701be2621fd65322c54923b142239e3a26',
|
|
goldRed: 'f4d166f6be59f9aa51fc964ef6834bee734ae56249db5247cf4244c43141b71d3e',
|
|
|
|
lightGreyRed: 'efe9e6e1dad7d5cbc8c8bdb9bbaea9cd967ddc7b43e15f19df4011dc000b',
|
|
lightGreyTeal: 'e4eaead6dcddc8ced2b7c2c7a6b4bc64b0bf22a6c32295c11f85be1876bc',
|
|
lightMulti: 'e0f1f2c4e9d0b0de9fd0e181f6e072f6c053f3993ef77440ef4a3c',
|
|
lightOrange: 'f2e7daf7d5baf9c499fab184fa9c73f68967ef7860e8645bde515bd43d5b',
|
|
lightTealBlue: 'e3e9e0c0dccf9aceca7abfc859afc0389fb9328dad2f7ca0276b95255988',
|
|
|
|
darkBlue: '3232322d46681a5c930074af008cbf05a7ce25c0dd38daed50f3faffffff',
|
|
darkGold: '3c3c3c584b37725e348c7631ae8b2bcfa424ecc31ef9de30fff184ffffff',
|
|
darkGreen: '3a3a3a215748006f4d048942489e4276b340a6c63dd2d836ffeb2cffffaa',
|
|
darkMulti: '3737371f5287197d8c29a86995ce3fffe800ffffff',
|
|
darkRed: '3434347036339e3c38cc4037e75d1eec8620eeab29f0ce32ffeb2c'
|
|
};
|
|
|
|
const discrete = {
|
|
category10: '1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf',
|
|
category20: '1f77b4aec7e8ff7f0effbb782ca02c98df8ad62728ff98969467bdc5b0d58c564bc49c94e377c2f7b6d27f7f7fc7c7c7bcbd22dbdb8d17becf9edae5',
|
|
category20b: '393b795254a36b6ecf9c9ede6379398ca252b5cf6bcedb9c8c6d31bd9e39e7ba52e7cb94843c39ad494ad6616be7969c7b4173a55194ce6dbdde9ed6',
|
|
category20c: '3182bd6baed69ecae1c6dbefe6550dfd8d3cfdae6bfdd0a231a35474c476a1d99bc7e9c0756bb19e9ac8bcbddcdadaeb636363969696bdbdbdd9d9d9',
|
|
tableau10: '4c78a8f58518e4575672b7b254a24beeca3bb279a2ff9da69d755dbab0ac',
|
|
tableau20: '4c78a89ecae9f58518ffbf7954a24b88d27ab79a20f2cf5b43989483bcb6e45756ff9d9879706ebab0acd67195fcbfd2b279a2d6a5c99e765fd8b5a5',
|
|
accent: '7fc97fbeaed4fdc086ffff99386cb0f0027fbf5b17666666',
|
|
dark2: '1b9e77d95f027570b3e7298a66a61ee6ab02a6761d666666',
|
|
paired: 'a6cee31f78b4b2df8a33a02cfb9a99e31a1cfdbf6fff7f00cab2d66a3d9affff99b15928',
|
|
pastel1: 'fbb4aeb3cde3ccebc5decbe4fed9a6ffffcce5d8bdfddaecf2f2f2',
|
|
pastel2: 'b3e2cdfdcdaccbd5e8f4cae4e6f5c9fff2aef1e2cccccccc',
|
|
set1: 'e41a1c377eb84daf4a984ea3ff7f00ffff33a65628f781bf999999',
|
|
set2: '66c2a5fc8d628da0cbe78ac3a6d854ffd92fe5c494b3b3b3',
|
|
set3: '8dd3c7ffffb3bebadafb807280b1d3fdb462b3de69fccde5d9d9d9bc80bdccebc5ffed6f'
|
|
};
|
|
|
|
function colors(palette) {
|
|
var n = palette.length / 6 | 0, c = new Array(n), i = 0;
|
|
while (i < n) c[i] = '#' + palette.slice(i * 6, ++i * 6);
|
|
return c;
|
|
}
|
|
|
|
function apply(_, f) {
|
|
for (let k in _) scheme(k, f(_[k]));
|
|
}
|
|
|
|
const schemes = {};
|
|
apply(discrete, colors);
|
|
apply(continuous, _ => interpolateColors(colors(_)));
|
|
|
|
function scheme(name, scheme) {
|
|
name = name && name.toLowerCase();
|
|
if (arguments.length > 1) {
|
|
schemes[name] = scheme;
|
|
return this;
|
|
} else {
|
|
return schemes[name];
|
|
}
|
|
}
|
|
|
|
Object.defineProperty(exports, 'scaleImplicit', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return $.scaleImplicit;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'tickFormat', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return $.tickFormat;
|
|
}
|
|
});
|
|
exports.Band = Band;
|
|
exports.BinOrdinal = BinOrdinal;
|
|
exports.Diverging = Diverging;
|
|
exports.Identity = Identity;
|
|
exports.Linear = Linear;
|
|
exports.Log = Log;
|
|
exports.Ordinal = Ordinal;
|
|
exports.Point = Point;
|
|
exports.Pow = Pow;
|
|
exports.Quantile = Quantile;
|
|
exports.Quantize = Quantize;
|
|
exports.Sequential = Sequential;
|
|
exports.Sqrt = Sqrt;
|
|
exports.Symlog = Symlog;
|
|
exports.Threshold = Threshold;
|
|
exports.Time = Time;
|
|
exports.UTC = UTC;
|
|
exports.bandSpace = bandSpace;
|
|
exports.interpolate = interpolate;
|
|
exports.interpolateColors = interpolateColors;
|
|
exports.interpolateRange = interpolateRange;
|
|
exports.isContinuous = isContinuous;
|
|
exports.isDiscrete = isDiscrete;
|
|
exports.isDiscretizing = isDiscretizing;
|
|
exports.isInterpolating = isInterpolating;
|
|
exports.isLogarithmic = isLogarithmic;
|
|
exports.isQuantile = isQuantile;
|
|
exports.isTemporal = isTemporal;
|
|
exports.isValidScaleType = isValidScaleType;
|
|
exports.quantizeInterpolator = quantizeInterpolator;
|
|
exports.scale = scale;
|
|
exports.scaleCopy = scaleCopy;
|
|
exports.scaleFraction = scaleFraction;
|
|
exports.scheme = scheme;
|
|
|
|
Object.defineProperty(exports, '__esModule', { value: true });
|
|
|
|
})));
|
|
|