add hw2
This commit is contained in:
nik
420
node_modules/d3-contour/dist/d3-contour.js
generated
vendored
Normal file
420
node_modules/d3-contour/dist/d3-contour.js
generated
vendored
Normal file
@@ -0,0 +1,420 @@
|
||||
// https://d3js.org/d3-contour/ v4.0.2 Copyright 2012-2023 Mike Bostock
|
||||
(function (global, factory) {
|
||||
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('d3-array')) :
|
||||
typeof define === 'function' && define.amd ? define(['exports', 'd3-array'], factory) :
|
||||
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.d3 = global.d3 || {}, global.d3));
|
||||
})(this, (function (exports, d3Array) { 'use strict';
|
||||
|
||||
var array = Array.prototype;
|
||||
|
||||
var slice = array.slice;
|
||||
|
||||
function ascending(a, b) {
|
||||
return a - b;
|
||||
}
|
||||
|
||||
function area(ring) {
|
||||
var i = 0, n = ring.length, area = ring[n - 1][1] * ring[0][0] - ring[n - 1][0] * ring[0][1];
|
||||
while (++i < n) area += ring[i - 1][1] * ring[i][0] - ring[i - 1][0] * ring[i][1];
|
||||
return area;
|
||||
}
|
||||
|
||||
var constant = x => () => x;
|
||||
|
||||
function contains(ring, hole) {
|
||||
var i = -1, n = hole.length, c;
|
||||
while (++i < n) if (c = ringContains(ring, hole[i])) return c;
|
||||
return 0;
|
||||
}
|
||||
|
||||
function ringContains(ring, point) {
|
||||
var x = point[0], y = point[1], contains = -1;
|
||||
for (var i = 0, n = ring.length, j = n - 1; i < n; j = i++) {
|
||||
var pi = ring[i], xi = pi[0], yi = pi[1], pj = ring[j], xj = pj[0], yj = pj[1];
|
||||
if (segmentContains(pi, pj, point)) return 0;
|
||||
if (((yi > y) !== (yj > y)) && ((x < (xj - xi) * (y - yi) / (yj - yi) + xi))) contains = -contains;
|
||||
}
|
||||
return contains;
|
||||
}
|
||||
|
||||
function segmentContains(a, b, c) {
|
||||
var i; return collinear(a, b, c) && within(a[i = +(a[0] === b[0])], c[i], b[i]);
|
||||
}
|
||||
|
||||
function collinear(a, b, c) {
|
||||
return (b[0] - a[0]) * (c[1] - a[1]) === (c[0] - a[0]) * (b[1] - a[1]);
|
||||
}
|
||||
|
||||
function within(p, q, r) {
|
||||
return p <= q && q <= r || r <= q && q <= p;
|
||||
}
|
||||
|
||||
function noop() {}
|
||||
|
||||
var cases = [
|
||||
[],
|
||||
[[[1.0, 1.5], [0.5, 1.0]]],
|
||||
[[[1.5, 1.0], [1.0, 1.5]]],
|
||||
[[[1.5, 1.0], [0.5, 1.0]]],
|
||||
[[[1.0, 0.5], [1.5, 1.0]]],
|
||||
[[[1.0, 1.5], [0.5, 1.0]], [[1.0, 0.5], [1.5, 1.0]]],
|
||||
[[[1.0, 0.5], [1.0, 1.5]]],
|
||||
[[[1.0, 0.5], [0.5, 1.0]]],
|
||||
[[[0.5, 1.0], [1.0, 0.5]]],
|
||||
[[[1.0, 1.5], [1.0, 0.5]]],
|
||||
[[[0.5, 1.0], [1.0, 0.5]], [[1.5, 1.0], [1.0, 1.5]]],
|
||||
[[[1.5, 1.0], [1.0, 0.5]]],
|
||||
[[[0.5, 1.0], [1.5, 1.0]]],
|
||||
[[[1.0, 1.5], [1.5, 1.0]]],
|
||||
[[[0.5, 1.0], [1.0, 1.5]]],
|
||||
[]
|
||||
];
|
||||
|
||||
function Contours() {
|
||||
var dx = 1,
|
||||
dy = 1,
|
||||
threshold = d3Array.thresholdSturges,
|
||||
smooth = smoothLinear;
|
||||
|
||||
function contours(values) {
|
||||
var tz = threshold(values);
|
||||
|
||||
// Convert number of thresholds into uniform thresholds.
|
||||
if (!Array.isArray(tz)) {
|
||||
const e = d3Array.extent(values, finite);
|
||||
tz = d3Array.ticks(...d3Array.nice(e[0], e[1], tz), tz);
|
||||
while (tz[tz.length - 1] >= e[1]) tz.pop();
|
||||
while (tz[1] < e[0]) tz.shift();
|
||||
} else {
|
||||
tz = tz.slice().sort(ascending);
|
||||
}
|
||||
|
||||
return tz.map(value => contour(values, value));
|
||||
}
|
||||
|
||||
// Accumulate, smooth contour rings, assign holes to exterior rings.
|
||||
// Based on https://github.com/mbostock/shapefile/blob/v0.6.2/shp/polygon.js
|
||||
function contour(values, value) {
|
||||
const v = value == null ? NaN : +value;
|
||||
if (isNaN(v)) throw new Error(`invalid value: ${value}`);
|
||||
|
||||
var polygons = [],
|
||||
holes = [];
|
||||
|
||||
isorings(values, v, function(ring) {
|
||||
smooth(ring, values, v);
|
||||
if (area(ring) > 0) polygons.push([ring]);
|
||||
else holes.push(ring);
|
||||
});
|
||||
|
||||
holes.forEach(function(hole) {
|
||||
for (var i = 0, n = polygons.length, polygon; i < n; ++i) {
|
||||
if (contains((polygon = polygons[i])[0], hole) !== -1) {
|
||||
polygon.push(hole);
|
||||
return;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
return {
|
||||
type: "MultiPolygon",
|
||||
value: value,
|
||||
coordinates: polygons
|
||||
};
|
||||
}
|
||||
|
||||
// Marching squares with isolines stitched into rings.
|
||||
// Based on https://github.com/topojson/topojson-client/blob/v3.0.0/src/stitch.js
|
||||
function isorings(values, value, callback) {
|
||||
var fragmentByStart = new Array,
|
||||
fragmentByEnd = new Array,
|
||||
x, y, t0, t1, t2, t3;
|
||||
|
||||
// Special case for the first row (y = -1, t2 = t3 = 0).
|
||||
x = y = -1;
|
||||
t1 = above(values[0], value);
|
||||
cases[t1 << 1].forEach(stitch);
|
||||
while (++x < dx - 1) {
|
||||
t0 = t1, t1 = above(values[x + 1], value);
|
||||
cases[t0 | t1 << 1].forEach(stitch);
|
||||
}
|
||||
cases[t1 << 0].forEach(stitch);
|
||||
|
||||
// General case for the intermediate rows.
|
||||
while (++y < dy - 1) {
|
||||
x = -1;
|
||||
t1 = above(values[y * dx + dx], value);
|
||||
t2 = above(values[y * dx], value);
|
||||
cases[t1 << 1 | t2 << 2].forEach(stitch);
|
||||
while (++x < dx - 1) {
|
||||
t0 = t1, t1 = above(values[y * dx + dx + x + 1], value);
|
||||
t3 = t2, t2 = above(values[y * dx + x + 1], value);
|
||||
cases[t0 | t1 << 1 | t2 << 2 | t3 << 3].forEach(stitch);
|
||||
}
|
||||
cases[t1 | t2 << 3].forEach(stitch);
|
||||
}
|
||||
|
||||
// Special case for the last row (y = dy - 1, t0 = t1 = 0).
|
||||
x = -1;
|
||||
t2 = values[y * dx] >= value;
|
||||
cases[t2 << 2].forEach(stitch);
|
||||
while (++x < dx - 1) {
|
||||
t3 = t2, t2 = above(values[y * dx + x + 1], value);
|
||||
cases[t2 << 2 | t3 << 3].forEach(stitch);
|
||||
}
|
||||
cases[t2 << 3].forEach(stitch);
|
||||
|
||||
function stitch(line) {
|
||||
var start = [line[0][0] + x, line[0][1] + y],
|
||||
end = [line[1][0] + x, line[1][1] + y],
|
||||
startIndex = index(start),
|
||||
endIndex = index(end),
|
||||
f, g;
|
||||
if (f = fragmentByEnd[startIndex]) {
|
||||
if (g = fragmentByStart[endIndex]) {
|
||||
delete fragmentByEnd[f.end];
|
||||
delete fragmentByStart[g.start];
|
||||
if (f === g) {
|
||||
f.ring.push(end);
|
||||
callback(f.ring);
|
||||
} else {
|
||||
fragmentByStart[f.start] = fragmentByEnd[g.end] = {start: f.start, end: g.end, ring: f.ring.concat(g.ring)};
|
||||
}
|
||||
} else {
|
||||
delete fragmentByEnd[f.end];
|
||||
f.ring.push(end);
|
||||
fragmentByEnd[f.end = endIndex] = f;
|
||||
}
|
||||
} else if (f = fragmentByStart[endIndex]) {
|
||||
if (g = fragmentByEnd[startIndex]) {
|
||||
delete fragmentByStart[f.start];
|
||||
delete fragmentByEnd[g.end];
|
||||
if (f === g) {
|
||||
f.ring.push(end);
|
||||
callback(f.ring);
|
||||
} else {
|
||||
fragmentByStart[g.start] = fragmentByEnd[f.end] = {start: g.start, end: f.end, ring: g.ring.concat(f.ring)};
|
||||
}
|
||||
} else {
|
||||
delete fragmentByStart[f.start];
|
||||
f.ring.unshift(start);
|
||||
fragmentByStart[f.start = startIndex] = f;
|
||||
}
|
||||
} else {
|
||||
fragmentByStart[startIndex] = fragmentByEnd[endIndex] = {start: startIndex, end: endIndex, ring: [start, end]};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function index(point) {
|
||||
return point[0] * 2 + point[1] * (dx + 1) * 4;
|
||||
}
|
||||
|
||||
function smoothLinear(ring, values, value) {
|
||||
ring.forEach(function(point) {
|
||||
var x = point[0],
|
||||
y = point[1],
|
||||
xt = x | 0,
|
||||
yt = y | 0,
|
||||
v1 = valid(values[yt * dx + xt]);
|
||||
if (x > 0 && x < dx && xt === x) {
|
||||
point[0] = smooth1(x, valid(values[yt * dx + xt - 1]), v1, value);
|
||||
}
|
||||
if (y > 0 && y < dy && yt === y) {
|
||||
point[1] = smooth1(y, valid(values[(yt - 1) * dx + xt]), v1, value);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
contours.contour = contour;
|
||||
|
||||
contours.size = function(_) {
|
||||
if (!arguments.length) return [dx, dy];
|
||||
var _0 = Math.floor(_[0]), _1 = Math.floor(_[1]);
|
||||
if (!(_0 >= 0 && _1 >= 0)) throw new Error("invalid size");
|
||||
return dx = _0, dy = _1, contours;
|
||||
};
|
||||
|
||||
contours.thresholds = function(_) {
|
||||
return arguments.length ? (threshold = typeof _ === "function" ? _ : Array.isArray(_) ? constant(slice.call(_)) : constant(_), contours) : threshold;
|
||||
};
|
||||
|
||||
contours.smooth = function(_) {
|
||||
return arguments.length ? (smooth = _ ? smoothLinear : noop, contours) : smooth === smoothLinear;
|
||||
};
|
||||
|
||||
return contours;
|
||||
}
|
||||
|
||||
// When computing the extent, ignore infinite values (as well as invalid ones).
|
||||
function finite(x) {
|
||||
return isFinite(x) ? x : NaN;
|
||||
}
|
||||
|
||||
// Is the (possibly invalid) x greater than or equal to the (known valid) value?
|
||||
// Treat any invalid value as below negative infinity.
|
||||
function above(x, value) {
|
||||
return x == null ? false : +x >= value;
|
||||
}
|
||||
|
||||
// During smoothing, treat any invalid value as negative infinity.
|
||||
function valid(v) {
|
||||
return v == null || isNaN(v = +v) ? -Infinity : v;
|
||||
}
|
||||
|
||||
function smooth1(x, v0, v1, value) {
|
||||
const a = value - v0;
|
||||
const b = v1 - v0;
|
||||
const d = isFinite(a) || isFinite(b) ? a / b : Math.sign(a) / Math.sign(b);
|
||||
return isNaN(d) ? x : x + d - 0.5;
|
||||
}
|
||||
|
||||
function defaultX(d) {
|
||||
return d[0];
|
||||
}
|
||||
|
||||
function defaultY(d) {
|
||||
return d[1];
|
||||
}
|
||||
|
||||
function defaultWeight() {
|
||||
return 1;
|
||||
}
|
||||
|
||||
function density() {
|
||||
var x = defaultX,
|
||||
y = defaultY,
|
||||
weight = defaultWeight,
|
||||
dx = 960,
|
||||
dy = 500,
|
||||
r = 20, // blur radius
|
||||
k = 2, // log2(grid cell size)
|
||||
o = r * 3, // grid offset, to pad for blur
|
||||
n = (dx + o * 2) >> k, // grid width
|
||||
m = (dy + o * 2) >> k, // grid height
|
||||
threshold = constant(20);
|
||||
|
||||
function grid(data) {
|
||||
var values = new Float32Array(n * m),
|
||||
pow2k = Math.pow(2, -k),
|
||||
i = -1;
|
||||
|
||||
for (const d of data) {
|
||||
var xi = (x(d, ++i, data) + o) * pow2k,
|
||||
yi = (y(d, i, data) + o) * pow2k,
|
||||
wi = +weight(d, i, data);
|
||||
if (wi && xi >= 0 && xi < n && yi >= 0 && yi < m) {
|
||||
var x0 = Math.floor(xi),
|
||||
y0 = Math.floor(yi),
|
||||
xt = xi - x0 - 0.5,
|
||||
yt = yi - y0 - 0.5;
|
||||
values[x0 + y0 * n] += (1 - xt) * (1 - yt) * wi;
|
||||
values[x0 + 1 + y0 * n] += xt * (1 - yt) * wi;
|
||||
values[x0 + 1 + (y0 + 1) * n] += xt * yt * wi;
|
||||
values[x0 + (y0 + 1) * n] += (1 - xt) * yt * wi;
|
||||
}
|
||||
}
|
||||
|
||||
d3Array.blur2({data: values, width: n, height: m}, r * pow2k);
|
||||
return values;
|
||||
}
|
||||
|
||||
function density(data) {
|
||||
var values = grid(data),
|
||||
tz = threshold(values),
|
||||
pow4k = Math.pow(2, 2 * k);
|
||||
|
||||
// Convert number of thresholds into uniform thresholds.
|
||||
if (!Array.isArray(tz)) {
|
||||
tz = d3Array.ticks(Number.MIN_VALUE, d3Array.max(values) / pow4k, tz);
|
||||
}
|
||||
|
||||
return Contours()
|
||||
.size([n, m])
|
||||
.thresholds(tz.map(d => d * pow4k))
|
||||
(values)
|
||||
.map((c, i) => (c.value = +tz[i], transform(c)));
|
||||
}
|
||||
|
||||
density.contours = function(data) {
|
||||
var values = grid(data),
|
||||
contours = Contours().size([n, m]),
|
||||
pow4k = Math.pow(2, 2 * k),
|
||||
contour = value => {
|
||||
value = +value;
|
||||
var c = transform(contours.contour(values, value * pow4k));
|
||||
c.value = value; // preserve exact threshold value
|
||||
return c;
|
||||
};
|
||||
Object.defineProperty(contour, "max", {get: () => d3Array.max(values) / pow4k});
|
||||
return contour;
|
||||
};
|
||||
|
||||
function transform(geometry) {
|
||||
geometry.coordinates.forEach(transformPolygon);
|
||||
return geometry;
|
||||
}
|
||||
|
||||
function transformPolygon(coordinates) {
|
||||
coordinates.forEach(transformRing);
|
||||
}
|
||||
|
||||
function transformRing(coordinates) {
|
||||
coordinates.forEach(transformPoint);
|
||||
}
|
||||
|
||||
// TODO Optimize.
|
||||
function transformPoint(coordinates) {
|
||||
coordinates[0] = coordinates[0] * Math.pow(2, k) - o;
|
||||
coordinates[1] = coordinates[1] * Math.pow(2, k) - o;
|
||||
}
|
||||
|
||||
function resize() {
|
||||
o = r * 3;
|
||||
n = (dx + o * 2) >> k;
|
||||
m = (dy + o * 2) >> k;
|
||||
return density;
|
||||
}
|
||||
|
||||
density.x = function(_) {
|
||||
return arguments.length ? (x = typeof _ === "function" ? _ : constant(+_), density) : x;
|
||||
};
|
||||
|
||||
density.y = function(_) {
|
||||
return arguments.length ? (y = typeof _ === "function" ? _ : constant(+_), density) : y;
|
||||
};
|
||||
|
||||
density.weight = function(_) {
|
||||
return arguments.length ? (weight = typeof _ === "function" ? _ : constant(+_), density) : weight;
|
||||
};
|
||||
|
||||
density.size = function(_) {
|
||||
if (!arguments.length) return [dx, dy];
|
||||
var _0 = +_[0], _1 = +_[1];
|
||||
if (!(_0 >= 0 && _1 >= 0)) throw new Error("invalid size");
|
||||
return dx = _0, dy = _1, resize();
|
||||
};
|
||||
|
||||
density.cellSize = function(_) {
|
||||
if (!arguments.length) return 1 << k;
|
||||
if (!((_ = +_) >= 1)) throw new Error("invalid cell size");
|
||||
return k = Math.floor(Math.log(_) / Math.LN2), resize();
|
||||
};
|
||||
|
||||
density.thresholds = function(_) {
|
||||
return arguments.length ? (threshold = typeof _ === "function" ? _ : Array.isArray(_) ? constant(slice.call(_)) : constant(_), density) : threshold;
|
||||
};
|
||||
|
||||
density.bandwidth = function(_) {
|
||||
if (!arguments.length) return Math.sqrt(r * (r + 1));
|
||||
if (!((_ = +_) >= 0)) throw new Error("invalid bandwidth");
|
||||
return r = (Math.sqrt(4 * _ * _ + 1) - 1) / 2, resize();
|
||||
};
|
||||
|
||||
return density;
|
||||
}
|
||||
|
||||
exports.contourDensity = density;
|
||||
exports.contours = Contours;
|
||||
|
||||
}));
|
||||
Reference in New Issue
Block a user