|
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ |
|
var d3_composite = require("d3-composite-projections"); |
|
var d3_geo = require("d3-geo"); |
|
var d3_request = require("d3-request"); |
|
var d3_selection = require("d3-selection"); |
|
var d3_transition = require("d3-transition"); |
|
var topojson = require("topojson"); |
|
|
|
var width = 960; |
|
var height = 500; |
|
|
|
var projection = d3_composite.geoAlbersUsa(); |
|
|
|
var path = d3_geo.geoPath() |
|
.projection(projection); |
|
|
|
var svg = d3_selection.select("body").append("svg") |
|
.attr("width", width) |
|
.attr("height", height); |
|
|
|
var t = d3_transition.transition() |
|
.on("interrupt", function(d,i){ |
|
console.info(i); |
|
}); |
|
|
|
d3_request.json("us.json", function(error, topojsonData) { |
|
var us = topojson.feature(topojsonData, topojsonData.objects.states); |
|
|
|
svg.selectAll(".region") |
|
.data(us.features) |
|
.enter() |
|
.append("path") |
|
.attr("d", path) |
|
.attr("class","region") |
|
.style("fill", "#aca") |
|
.style("stroke", "#000") |
|
.style("stroke-width", "0.5px") |
|
.on("mouseover", function(d,i) { |
|
d3_selection.select(this) |
|
.transition(t) |
|
.style("fill", "red"); |
|
}) |
|
.on("mouseout", function(d,i) { |
|
d3_selection.select(this).interrupt(); |
|
d3_selection.select(this) |
|
.transition(t) |
|
.style("fill", "#aca"); |
|
}); |
|
|
|
svg |
|
.append("path") |
|
.style("fill","none") |
|
.style("stroke","#f00") |
|
.attr("d", projection.getCompositionBorders()); |
|
|
|
}); |
|
|
|
},{"d3-composite-projections":5,"d3-geo":10,"d3-request":13,"d3-selection":14,"d3-transition":16,"topojson":17}],2:[function(require,module,exports){ |
|
// https://d3js.org/d3-array/ Version 1.0.1. Copyright 2016 Mike Bostock. |
|
(function (global, factory) { |
|
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : |
|
typeof define === 'function' && define.amd ? define(['exports'], factory) : |
|
(factory((global.d3 = global.d3 || {}))); |
|
}(this, function (exports) { 'use strict'; |
|
|
|
function ascending(a, b) { |
|
return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; |
|
} |
|
|
|
function bisector(compare) { |
|
if (compare.length === 1) compare = ascendingComparator(compare); |
|
return { |
|
left: function(a, x, lo, hi) { |
|
if (lo == null) lo = 0; |
|
if (hi == null) hi = a.length; |
|
while (lo < hi) { |
|
var mid = lo + hi >>> 1; |
|
if (compare(a[mid], x) < 0) lo = mid + 1; |
|
else hi = mid; |
|
} |
|
return lo; |
|
}, |
|
right: function(a, x, lo, hi) { |
|
if (lo == null) lo = 0; |
|
if (hi == null) hi = a.length; |
|
while (lo < hi) { |
|
var mid = lo + hi >>> 1; |
|
if (compare(a[mid], x) > 0) hi = mid; |
|
else lo = mid + 1; |
|
} |
|
return lo; |
|
} |
|
}; |
|
} |
|
|
|
function ascendingComparator(f) { |
|
return function(d, x) { |
|
return ascending(f(d), x); |
|
}; |
|
} |
|
|
|
var ascendingBisect = bisector(ascending); |
|
var bisectRight = ascendingBisect.right; |
|
var bisectLeft = ascendingBisect.left; |
|
|
|
function descending(a, b) { |
|
return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN; |
|
} |
|
|
|
function number(x) { |
|
return x === null ? NaN : +x; |
|
} |
|
|
|
function variance(array, f) { |
|
var n = array.length, |
|
m = 0, |
|
a, |
|
d, |
|
s = 0, |
|
i = -1, |
|
j = 0; |
|
|
|
if (f == null) { |
|
while (++i < n) { |
|
if (!isNaN(a = number(array[i]))) { |
|
d = a - m; |
|
m += d / ++j; |
|
s += d * (a - m); |
|
} |
|
} |
|
} |
|
|
|
else { |
|
while (++i < n) { |
|
if (!isNaN(a = number(f(array[i], i, array)))) { |
|
d = a - m; |
|
m += d / ++j; |
|
s += d * (a - m); |
|
} |
|
} |
|
} |
|
|
|
if (j > 1) return s / (j - 1); |
|
} |
|
|
|
function deviation(array, f) { |
|
var v = variance(array, f); |
|
return v ? Math.sqrt(v) : v; |
|
} |
|
|
|
function extent(array, f) { |
|
var i = -1, |
|
n = array.length, |
|
a, |
|
b, |
|
c; |
|
|
|
if (f == null) { |
|
while (++i < n) if ((b = array[i]) != null && b >= b) { a = c = b; break; } |
|
while (++i < n) if ((b = array[i]) != null) { |
|
if (a > b) a = b; |
|
if (c < b) c = b; |
|
} |
|
} |
|
|
|
else { |
|
while (++i < n) if ((b = f(array[i], i, array)) != null && b >= b) { a = c = b; break; } |
|
while (++i < n) if ((b = f(array[i], i, array)) != null) { |
|
if (a > b) a = b; |
|
if (c < b) c = b; |
|
} |
|
} |
|
|
|
return [a, c]; |
|
} |
|
|
|
var array = Array.prototype; |
|
|
|
var slice = array.slice; |
|
var map = array.map; |
|
|
|
function constant(x) { |
|
return function() { |
|
return x; |
|
}; |
|
} |
|
|
|
function identity(x) { |
|
return x; |
|
} |
|
|
|
function range(start, stop, step) { |
|
start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step; |
|
|
|
var i = -1, |
|
n = Math.max(0, Math.ceil((stop - start) / step)) | 0, |
|
range = new Array(n); |
|
|
|
while (++i < n) { |
|
range[i] = start + i * step; |
|
} |
|
|
|
return range; |
|
} |
|
|
|
var e10 = Math.sqrt(50); |
|
var e5 = Math.sqrt(10); |
|
var e2 = Math.sqrt(2); |
|
function ticks(start, stop, count) { |
|
var step = tickStep(start, stop, count); |
|
return range( |
|
Math.ceil(start / step) * step, |
|
Math.floor(stop / step) * step + step / 2, // inclusive |
|
step |
|
); |
|
} |
|
|
|
function tickStep(start, stop, count) { |
|
var step0 = Math.abs(stop - start) / Math.max(0, count), |
|
step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)), |
|
error = step0 / step1; |
|
if (error >= e10) step1 *= 10; |
|
else if (error >= e5) step1 *= 5; |
|
else if (error >= e2) step1 *= 2; |
|
return stop < start ? -step1 : step1; |
|
} |
|
|
|
function sturges(values) { |
|
return Math.ceil(Math.log(values.length) / Math.LN2) + 1; |
|
} |
|
|
|
function histogram() { |
|
var value = identity, |
|
domain = extent, |
|
threshold = sturges; |
|
|
|
function histogram(data) { |
|
var i, |
|
n = data.length, |
|
x, |
|
values = new Array(n); |
|
|
|
for (i = 0; i < n; ++i) { |
|
values[i] = value(data[i], i, data); |
|
} |
|
|
|
var xz = domain(values), |
|
x0 = xz[0], |
|
x1 = xz[1], |
|
tz = threshold(values, x0, x1); |
|
|
|
// Convert number of thresholds into uniform thresholds. |
|
if (!Array.isArray(tz)) tz = ticks(x0, x1, tz); |
|
|
|
// Remove any thresholds outside the domain. |
|
var m = tz.length; |
|
while (tz[0] <= x0) tz.shift(), --m; |
|
while (tz[m - 1] >= x1) tz.pop(), --m; |
|
|
|
var bins = new Array(m + 1), |
|
bin; |
|
|
|
// Initialize bins. |
|
for (i = 0; i <= m; ++i) { |
|
bin = bins[i] = []; |
|
bin.x0 = i > 0 ? tz[i - 1] : x0; |
|
bin.x1 = i < m ? tz[i] : x1; |
|
} |
|
|
|
// Assign data to bins by value, ignoring any outside the domain. |
|
for (i = 0; i < n; ++i) { |
|
x = values[i]; |
|
if (x0 <= x && x <= x1) { |
|
bins[bisectRight(tz, x, 0, m)].push(data[i]); |
|
} |
|
} |
|
|
|
return bins; |
|
} |
|
|
|
histogram.value = function(_) { |
|
return arguments.length ? (value = typeof _ === "function" ? _ : constant(_), histogram) : value; |
|
}; |
|
|
|
histogram.domain = function(_) { |
|
return arguments.length ? (domain = typeof _ === "function" ? _ : constant([_[0], _[1]]), histogram) : domain; |
|
}; |
|
|
|
histogram.thresholds = function(_) { |
|
return arguments.length ? (threshold = typeof _ === "function" ? _ : Array.isArray(_) ? constant(slice.call(_)) : constant(_), histogram) : threshold; |
|
}; |
|
|
|
return histogram; |
|
} |
|
|
|
function quantile(array, p, f) { |
|
if (f == null) f = number; |
|
if (!(n = array.length)) return; |
|
if ((p = +p) <= 0 || n < 2) return +f(array[0], 0, array); |
|
if (p >= 1) return +f(array[n - 1], n - 1, array); |
|
var n, |
|
h = (n - 1) * p, |
|
i = Math.floor(h), |
|
a = +f(array[i], i, array), |
|
b = +f(array[i + 1], i + 1, array); |
|
return a + (b - a) * (h - i); |
|
} |
|
|
|
function freedmanDiaconis(values, min, max) { |
|
values = map.call(values, number).sort(ascending); |
|
return Math.ceil((max - min) / (2 * (quantile(values, 0.75) - quantile(values, 0.25)) * Math.pow(values.length, -1 / 3))); |
|
} |
|
|
|
function scott(values, min, max) { |
|
return Math.ceil((max - min) / (3.5 * deviation(values) * Math.pow(values.length, -1 / 3))); |
|
} |
|
|
|
function max(array, f) { |
|
var i = -1, |
|
n = array.length, |
|
a, |
|
b; |
|
|
|
if (f == null) { |
|
while (++i < n) if ((b = array[i]) != null && b >= b) { a = b; break; } |
|
while (++i < n) if ((b = array[i]) != null && b > a) a = b; |
|
} |
|
|
|
else { |
|
while (++i < n) if ((b = f(array[i], i, array)) != null && b >= b) { a = b; break; } |
|
while (++i < n) if ((b = f(array[i], i, array)) != null && b > a) a = b; |
|
} |
|
|
|
return a; |
|
} |
|
|
|
function mean(array, f) { |
|
var s = 0, |
|
n = array.length, |
|
a, |
|
i = -1, |
|
j = n; |
|
|
|
if (f == null) { |
|
while (++i < n) if (!isNaN(a = number(array[i]))) s += a; else --j; |
|
} |
|
|
|
else { |
|
while (++i < n) if (!isNaN(a = number(f(array[i], i, array)))) s += a; else --j; |
|
} |
|
|
|
if (j) return s / j; |
|
} |
|
|
|
function median(array, f) { |
|
var numbers = [], |
|
n = array.length, |
|
a, |
|
i = -1; |
|
|
|
if (f == null) { |
|
while (++i < n) if (!isNaN(a = number(array[i]))) numbers.push(a); |
|
} |
|
|
|
else { |
|
while (++i < n) if (!isNaN(a = number(f(array[i], i, array)))) numbers.push(a); |
|
} |
|
|
|
return quantile(numbers.sort(ascending), 0.5); |
|
} |
|
|
|
function merge(arrays) { |
|
var n = arrays.length, |
|
m, |
|
i = -1, |
|
j = 0, |
|
merged, |
|
array; |
|
|
|
while (++i < n) j += arrays[i].length; |
|
merged = new Array(j); |
|
|
|
while (--n >= 0) { |
|
array = arrays[n]; |
|
m = array.length; |
|
while (--m >= 0) { |
|
merged[--j] = array[m]; |
|
} |
|
} |
|
|
|
return merged; |
|
} |
|
|
|
function min(array, f) { |
|
var i = -1, |
|
n = array.length, |
|
a, |
|
b; |
|
|
|
if (f == null) { |
|
while (++i < n) if ((b = array[i]) != null && b >= b) { a = b; break; } |
|
while (++i < n) if ((b = array[i]) != null && a > b) a = b; |
|
} |
|
|
|
else { |
|
while (++i < n) if ((b = f(array[i], i, array)) != null && b >= b) { a = b; break; } |
|
while (++i < n) if ((b = f(array[i], i, array)) != null && a > b) a = b; |
|
} |
|
|
|
return a; |
|
} |
|
|
|
function pairs(array) { |
|
var i = 0, n = array.length - 1, p = array[0], pairs = new Array(n < 0 ? 0 : n); |
|
while (i < n) pairs[i] = [p, p = array[++i]]; |
|
return pairs; |
|
} |
|
|
|
function permute(array, indexes) { |
|
var i = indexes.length, permutes = new Array(i); |
|
while (i--) permutes[i] = array[indexes[i]]; |
|
return permutes; |
|
} |
|
|
|
function scan(array, compare) { |
|
if (!(n = array.length)) return; |
|
var i = 0, |
|
n, |
|
j = 0, |
|
xi, |
|
xj = array[j]; |
|
|
|
if (!compare) compare = ascending; |
|
|
|
while (++i < n) if (compare(xi = array[i], xj) < 0 || compare(xj, xj) !== 0) xj = xi, j = i; |
|
|
|
if (compare(xj, xj) === 0) return j; |
|
} |
|
|
|
function shuffle(array, i0, i1) { |
|
var m = (i1 == null ? array.length : i1) - (i0 = i0 == null ? 0 : +i0), |
|
t, |
|
i; |
|
|
|
while (m) { |
|
i = Math.random() * m-- | 0; |
|
t = array[m + i0]; |
|
array[m + i0] = array[i + i0]; |
|
array[i + i0] = t; |
|
} |
|
|
|
return array; |
|
} |
|
|
|
function sum(array, f) { |
|
var s = 0, |
|
n = array.length, |
|
a, |
|
i = -1; |
|
|
|
if (f == null) { |
|
while (++i < n) if (a = +array[i]) s += a; // Note: zero and null are equivalent. |
|
} |
|
|
|
else { |
|
while (++i < n) if (a = +f(array[i], i, array)) s += a; |
|
} |
|
|
|
return s; |
|
} |
|
|
|
function transpose(matrix) { |
|
if (!(n = matrix.length)) return []; |
|
for (var i = -1, m = min(matrix, length), transpose = new Array(m); ++i < m;) { |
|
for (var j = -1, n, row = transpose[i] = new Array(n); ++j < n;) { |
|
row[j] = matrix[j][i]; |
|
} |
|
} |
|
return transpose; |
|
} |
|
|
|
function length(d) { |
|
return d.length; |
|
} |
|
|
|
function zip() { |
|
return transpose(arguments); |
|
} |
|
|
|
exports.bisect = bisectRight; |
|
exports.bisectRight = bisectRight; |
|
exports.bisectLeft = bisectLeft; |
|
exports.ascending = ascending; |
|
exports.bisector = bisector; |
|
exports.descending = descending; |
|
exports.deviation = deviation; |
|
exports.extent = extent; |
|
exports.histogram = histogram; |
|
exports.thresholdFreedmanDiaconis = freedmanDiaconis; |
|
exports.thresholdScott = scott; |
|
exports.thresholdSturges = sturges; |
|
exports.max = max; |
|
exports.mean = mean; |
|
exports.median = median; |
|
exports.merge = merge; |
|
exports.min = min; |
|
exports.pairs = pairs; |
|
exports.permute = permute; |
|
exports.quantile = quantile; |
|
exports.range = range; |
|
exports.scan = scan; |
|
exports.shuffle = shuffle; |
|
exports.sum = sum; |
|
exports.ticks = ticks; |
|
exports.tickStep = tickStep; |
|
exports.transpose = transpose; |
|
exports.variance = variance; |
|
exports.zip = zip; |
|
|
|
Object.defineProperty(exports, '__esModule', { value: true }); |
|
|
|
})); |
|
},{}],3:[function(require,module,exports){ |
|
// https://d3js.org/d3-collection/ Version 1.0.1. Copyright 2016 Mike Bostock. |
|
(function (global, factory) { |
|
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : |
|
typeof define === 'function' && define.amd ? define(['exports'], factory) : |
|
(factory((global.d3 = global.d3 || {}))); |
|
}(this, function (exports) { 'use strict'; |
|
|
|
var prefix = "$"; |
|
|
|
function Map() {} |
|
|
|
Map.prototype = map.prototype = { |
|
constructor: Map, |
|
has: function(key) { |
|
return (prefix + key) in this; |
|
}, |
|
get: function(key) { |
|
return this[prefix + key]; |
|
}, |
|
set: function(key, value) { |
|
this[prefix + key] = value; |
|
return this; |
|
}, |
|
remove: function(key) { |
|
var property = prefix + key; |
|
return property in this && delete this[property]; |
|
}, |
|
clear: function() { |
|
for (var property in this) if (property[0] === prefix) delete this[property]; |
|
}, |
|
keys: function() { |
|
var keys = []; |
|
for (var property in this) if (property[0] === prefix) keys.push(property.slice(1)); |
|
return keys; |
|
}, |
|
values: function() { |
|
var values = []; |
|
for (var property in this) if (property[0] === prefix) values.push(this[property]); |
|
return values; |
|
}, |
|
entries: function() { |
|
var entries = []; |
|
for (var property in this) if (property[0] === prefix) entries.push({key: property.slice(1), value: this[property]}); |
|
return entries; |
|
}, |
|
size: function() { |
|
var size = 0; |
|
for (var property in this) if (property[0] === prefix) ++size; |
|
return size; |
|
}, |
|
empty: function() { |
|
for (var property in this) if (property[0] === prefix) return false; |
|
return true; |
|
}, |
|
each: function(f) { |
|
for (var property in this) if (property[0] === prefix) f(this[property], property.slice(1), this); |
|
} |
|
}; |
|
|
|
function map(object, f) { |
|
var map = new Map; |
|
|
|
// Copy constructor. |
|
if (object instanceof Map) object.each(function(value, key) { map.set(key, value); }); |
|
|
|
// Index array by numeric index or specified key function. |
|
else if (Array.isArray(object)) { |
|
var i = -1, |
|
n = object.length, |
|
o; |
|
|
|
if (f == null) while (++i < n) map.set(i, object[i]); |
|
else while (++i < n) map.set(f(o = object[i], i, object), o); |
|
} |
|
|
|
// Convert object to map. |
|
else if (object) for (var key in object) map.set(key, object[key]); |
|
|
|
return map; |
|
} |
|
|
|
function nest() { |
|
var keys = [], |
|
sortKeys = [], |
|
sortValues, |
|
rollup, |
|
nest; |
|
|
|
function apply(array, depth, createResult, setResult) { |
|
if (depth >= keys.length) return rollup != null |
|
? rollup(array) : (sortValues != null |
|
? array.sort(sortValues) |
|
: array); |
|
|
|
var i = -1, |
|
n = array.length, |
|
key = keys[depth++], |
|
keyValue, |
|
value, |
|
valuesByKey = map(), |
|
values, |
|
result = createResult(); |
|
|
|
while (++i < n) { |
|
if (values = valuesByKey.get(keyValue = key(value = array[i]) + "")) { |
|
values.push(value); |
|
} else { |
|
valuesByKey.set(keyValue, [value]); |
|
} |
|
} |
|
|
|
valuesByKey.each(function(values, key) { |
|
setResult(result, key, apply(values, depth, createResult, setResult)); |
|
}); |
|
|
|
return result; |
|
} |
|
|
|
function entries(map, depth) { |
|
if (++depth > keys.length) return map; |
|
var array, sortKey = sortKeys[depth - 1]; |
|
if (rollup != null && depth >= keys.length) array = map.entries(); |
|
else array = [], map.each(function(v, k) { array.push({key: k, values: entries(v, depth)}); }); |
|
return sortKey != null ? array.sort(function(a, b) { return sortKey(a.key, b.key); }) : array; |
|
} |
|
|
|
return nest = { |
|
object: function(array) { return apply(array, 0, createObject, setObject); }, |
|
map: function(array) { return apply(array, 0, createMap, setMap); }, |
|
entries: function(array) { return entries(apply(array, 0, createMap, setMap), 0); }, |
|
key: function(d) { keys.push(d); return nest; }, |
|
sortKeys: function(order) { sortKeys[keys.length - 1] = order; return nest; }, |
|
sortValues: function(order) { sortValues = order; return nest; }, |
|
rollup: function(f) { rollup = f; return nest; } |
|
}; |
|
} |
|
|
|
function createObject() { |
|
return {}; |
|
} |
|
|
|
function setObject(object, key, value) { |
|
object[key] = value; |
|
} |
|
|
|
function createMap() { |
|
return map(); |
|
} |
|
|
|
function setMap(map, key, value) { |
|
map.set(key, value); |
|
} |
|
|
|
function Set() {} |
|
|
|
var proto = map.prototype; |
|
|
|
Set.prototype = set.prototype = { |
|
constructor: Set, |
|
has: proto.has, |
|
add: function(value) { |
|
value += ""; |
|
this[prefix + value] = value; |
|
return this; |
|
}, |
|
remove: proto.remove, |
|
clear: proto.clear, |
|
values: proto.keys, |
|
size: proto.size, |
|
empty: proto.empty, |
|
each: proto.each |
|
}; |
|
|
|
function set(object, f) { |
|
var set = new Set; |
|
|
|
// Copy constructor. |
|
if (object instanceof Set) object.each(function(value) { set.add(value); }); |
|
|
|
// Otherwise, assume it’s an array. |
|
else if (object) { |
|
var i = -1, n = object.length; |
|
if (f == null) while (++i < n) set.add(object[i]); |
|
else while (++i < n) set.add(f(object[i], i, object)); |
|
} |
|
|
|
return set; |
|
} |
|
|
|
function keys(map) { |
|
var keys = []; |
|
for (var key in map) keys.push(key); |
|
return keys; |
|
} |
|
|
|
function values(map) { |
|
var values = []; |
|
for (var key in map) values.push(map[key]); |
|
return values; |
|
} |
|
|
|
function entries(map) { |
|
var entries = []; |
|
for (var key in map) entries.push({key: key, value: map[key]}); |
|
return entries; |
|
} |
|
|
|
exports.nest = nest; |
|
exports.set = set; |
|
exports.map = map; |
|
exports.keys = keys; |
|
exports.values = values; |
|
exports.entries = entries; |
|
|
|
Object.defineProperty(exports, '__esModule', { value: true }); |
|
|
|
})); |
|
},{}],4:[function(require,module,exports){ |
|
// https://d3js.org/d3-color/ Version 1.0.1. Copyright 2016 Mike Bostock. |
|
(function (global, factory) { |
|
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : |
|
typeof define === 'function' && define.amd ? define(['exports'], factory) : |
|
(factory((global.d3 = global.d3 || {}))); |
|
}(this, function (exports) { 'use strict'; |
|
|
|
function define(constructor, factory, prototype) { |
|
constructor.prototype = factory.prototype = prototype; |
|
prototype.constructor = constructor; |
|
} |
|
|
|
function extend(parent, definition) { |
|
var prototype = Object.create(parent.prototype); |
|
for (var key in definition) prototype[key] = definition[key]; |
|
return prototype; |
|
} |
|
|
|
function Color() {} |
|
|
|
var darker = 0.7; |
|
var brighter = 1 / darker; |
|
|
|
var reHex3 = /^#([0-9a-f]{3})$/; |
|
var reHex6 = /^#([0-9a-f]{6})$/; |
|
var reRgbInteger = /^rgb\(\s*([-+]?\d+)\s*,\s*([-+]?\d+)\s*,\s*([-+]?\d+)\s*\)$/; |
|
var reRgbPercent = /^rgb\(\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*\)$/; |
|
var reRgbaInteger = /^rgba\(\s*([-+]?\d+)\s*,\s*([-+]?\d+)\s*,\s*([-+]?\d+)\s*,\s*([-+]?\d+(?:\.\d+)?)\s*\)$/; |
|
var reRgbaPercent = /^rgba\(\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)\s*\)$/; |
|
var reHslPercent = /^hsl\(\s*([-+]?\d+(?:\.\d+)?)\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*\)$/; |
|
var reHslaPercent = /^hsla\(\s*([-+]?\d+(?:\.\d+)?)\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)\s*\)$/; |
|
var named = { |
|
aliceblue: 0xf0f8ff, |
|
antiquewhite: 0xfaebd7, |
|
aqua: 0x00ffff, |
|
aquamarine: 0x7fffd4, |
|
azure: 0xf0ffff, |
|
beige: 0xf5f5dc, |
|
bisque: 0xffe4c4, |
|
black: 0x000000, |
|
blanchedalmond: 0xffebcd, |
|
blue: 0x0000ff, |
|
blueviolet: 0x8a2be2, |
|
brown: 0xa52a2a, |
|
burlywood: 0xdeb887, |
|
cadetblue: 0x5f9ea0, |
|
chartreuse: 0x7fff00, |
|
chocolate: 0xd2691e, |
|
coral: 0xff7f50, |
|
cornflowerblue: 0x6495ed, |
|
cornsilk: 0xfff8dc, |
|
crimson: 0xdc143c, |
|
cyan: 0x00ffff, |
|
darkblue: 0x00008b, |
|
darkcyan: 0x008b8b, |
|
darkgoldenrod: 0xb8860b, |
|
darkgray: 0xa9a9a9, |
|
darkgreen: 0x006400, |
|
darkgrey: 0xa9a9a9, |
|
darkkhaki: 0xbdb76b, |
|
darkmagenta: 0x8b008b, |
|
darkolivegreen: 0x556b2f, |
|
darkorange: 0xff8c00, |
|
darkorchid: 0x9932cc, |
|
darkred: 0x8b0000, |
|
darksalmon: 0xe9967a, |
|
darkseagreen: 0x8fbc8f, |
|
darkslateblue: 0x483d8b, |
|
darkslategray: 0x2f4f4f, |
|
darkslategrey: 0x2f4f4f, |
|
darkturquoise: 0x00ced1, |
|
darkviolet: 0x9400d3, |
|
deeppink: 0xff1493, |
|
deepskyblue: 0x00bfff, |
|
dimgray: 0x696969, |
|
dimgrey: 0x696969, |
|
dodgerblue: 0x1e90ff, |
|
firebrick: 0xb22222, |
|
floralwhite: 0xfffaf0, |
|
forestgreen: 0x228b22, |
|
fuchsia: 0xff00ff, |
|
gainsboro: 0xdcdcdc, |
|
ghostwhite: 0xf8f8ff, |
|
gold: 0xffd700, |
|
goldenrod: 0xdaa520, |
|
gray: 0x808080, |
|
green: 0x008000, |
|
greenyellow: 0xadff2f, |
|
grey: 0x808080, |
|
honeydew: 0xf0fff0, |
|
hotpink: 0xff69b4, |
|
indianred: 0xcd5c5c, |
|
indigo: 0x4b0082, |
|
ivory: 0xfffff0, |
|
khaki: 0xf0e68c, |
|
lavender: 0xe6e6fa, |
|
lavenderblush: 0xfff0f5, |
|
lawngreen: 0x7cfc00, |
|
lemonchiffon: 0xfffacd, |
|
lightblue: 0xadd8e6, |
|
lightcoral: 0xf08080, |
|
lightcyan: 0xe0ffff, |
|
lightgoldenrodyellow: 0xfafad2, |
|
lightgray: 0xd3d3d3, |
|
lightgreen: 0x90ee90, |
|
lightgrey: 0xd3d3d3, |
|
lightpink: 0xffb6c1, |
|
lightsalmon: 0xffa07a, |
|
lightseagreen: 0x20b2aa, |
|
lightskyblue: 0x87cefa, |
|
lightslategray: 0x778899, |
|
lightslategrey: 0x778899, |
|
lightsteelblue: 0xb0c4de, |
|
lightyellow: 0xffffe0, |
|
lime: 0x00ff00, |
|
limegreen: 0x32cd32, |
|
linen: 0xfaf0e6, |
|
magenta: 0xff00ff, |
|
maroon: 0x800000, |
|
mediumaquamarine: 0x66cdaa, |
|
mediumblue: 0x0000cd, |
|
mediumorchid: 0xba55d3, |
|
mediumpurple: 0x9370db, |
|
mediumseagreen: 0x3cb371, |
|
mediumslateblue: 0x7b68ee, |
|
mediumspringgreen: 0x00fa9a, |
|
mediumturquoise: 0x48d1cc, |
|
mediumvioletred: 0xc71585, |
|
midnightblue: 0x191970, |
|
mintcream: 0xf5fffa, |
|
mistyrose: 0xffe4e1, |
|
moccasin: 0xffe4b5, |
|
navajowhite: 0xffdead, |
|
navy: 0x000080, |
|
oldlace: 0xfdf5e6, |
|
olive: 0x808000, |
|
olivedrab: 0x6b8e23, |
|
orange: 0xffa500, |
|
orangered: 0xff4500, |
|
orchid: 0xda70d6, |
|
palegoldenrod: 0xeee8aa, |
|
palegreen: 0x98fb98, |
|
paleturquoise: 0xafeeee, |
|
palevioletred: 0xdb7093, |
|
papayawhip: 0xffefd5, |
|
peachpuff: 0xffdab9, |
|
peru: 0xcd853f, |
|
pink: 0xffc0cb, |
|
plum: 0xdda0dd, |
|
powderblue: 0xb0e0e6, |
|
purple: 0x800080, |
|
rebeccapurple: 0x663399, |
|
red: 0xff0000, |
|
rosybrown: 0xbc8f8f, |
|
royalblue: 0x4169e1, |
|
saddlebrown: 0x8b4513, |
|
salmon: 0xfa8072, |
|
sandybrown: 0xf4a460, |
|
seagreen: 0x2e8b57, |
|
seashell: 0xfff5ee, |
|
sienna: 0xa0522d, |
|
silver: 0xc0c0c0, |
|
skyblue: 0x87ceeb, |
|
slateblue: 0x6a5acd, |
|
slategray: 0x708090, |
|
slategrey: 0x708090, |
|
snow: 0xfffafa, |
|
springgreen: 0x00ff7f, |
|
steelblue: 0x4682b4, |
|
tan: 0xd2b48c, |
|
teal: 0x008080, |
|
thistle: 0xd8bfd8, |
|
tomato: 0xff6347, |
|
turquoise: 0x40e0d0, |
|
violet: 0xee82ee, |
|
wheat: 0xf5deb3, |
|
white: 0xffffff, |
|
whitesmoke: 0xf5f5f5, |
|
yellow: 0xffff00, |
|
yellowgreen: 0x9acd32 |
|
}; |
|
|
|
define(Color, color, { |
|
displayable: function() { |
|
return this.rgb().displayable(); |
|
}, |
|
toString: function() { |
|
return this.rgb() + ""; |
|
} |
|
}); |
|
|
|
function color(format) { |
|
var m; |
|
format = (format + "").trim().toLowerCase(); |
|
return (m = reHex3.exec(format)) ? (m = parseInt(m[1], 16), new Rgb((m >> 8 & 0xf) | (m >> 4 & 0x0f0), (m >> 4 & 0xf) | (m & 0xf0), ((m & 0xf) << 4) | (m & 0xf), 1)) // #f00 |
|
: (m = reHex6.exec(format)) ? rgbn(parseInt(m[1], 16)) // #ff0000 |
|
: (m = reRgbInteger.exec(format)) ? new Rgb(m[1], m[2], m[3], 1) // rgb(255, 0, 0) |
|
: (m = reRgbPercent.exec(format)) ? new Rgb(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, 1) // rgb(100%, 0%, 0%) |
|
: (m = reRgbaInteger.exec(format)) ? rgba(m[1], m[2], m[3], m[4]) // rgba(255, 0, 0, 1) |
|
: (m = reRgbaPercent.exec(format)) ? rgba(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, m[4]) // rgb(100%, 0%, 0%, 1) |
|
: (m = reHslPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, 1) // hsl(120, 50%, 50%) |
|
: (m = reHslaPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, m[4]) // hsla(120, 50%, 50%, 1) |
|
: named.hasOwnProperty(format) ? rgbn(named[format]) |
|
: format === "transparent" ? new Rgb(NaN, NaN, NaN, 0) |
|
: null; |
|
} |
|
|
|
function rgbn(n) { |
|
return new Rgb(n >> 16 & 0xff, n >> 8 & 0xff, n & 0xff, 1); |
|
} |
|
|
|
function rgba(r, g, b, a) { |
|
if (a <= 0) r = g = b = NaN; |
|
return new Rgb(r, g, b, a); |
|
} |
|
|
|
function rgbConvert(o) { |
|
if (!(o instanceof Color)) o = color(o); |
|
if (!o) return new Rgb; |
|
o = o.rgb(); |
|
return new Rgb(o.r, o.g, o.b, o.opacity); |
|
} |
|
|
|
function rgb(r, g, b, opacity) { |
|
return arguments.length === 1 ? rgbConvert(r) : new Rgb(r, g, b, opacity == null ? 1 : opacity); |
|
} |
|
|
|
function Rgb(r, g, b, opacity) { |
|
this.r = +r; |
|
this.g = +g; |
|
this.b = +b; |
|
this.opacity = +opacity; |
|
} |
|
|
|
define(Rgb, rgb, extend(Color, { |
|
brighter: function(k) { |
|
k = k == null ? brighter : Math.pow(brighter, k); |
|
return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity); |
|
}, |
|
darker: function(k) { |
|
k = k == null ? darker : Math.pow(darker, k); |
|
return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity); |
|
}, |
|
rgb: function() { |
|
return this; |
|
}, |
|
displayable: function() { |
|
return (0 <= this.r && this.r <= 255) |
|
&& (0 <= this.g && this.g <= 255) |
|
&& (0 <= this.b && this.b <= 255) |
|
&& (0 <= this.opacity && this.opacity <= 1); |
|
}, |
|
toString: function() { |
|
var a = this.opacity; a = isNaN(a) ? 1 : Math.max(0, Math.min(1, a)); |
|
return (a === 1 ? "rgb(" : "rgba(") |
|
+ Math.max(0, Math.min(255, Math.round(this.r) || 0)) + ", " |
|
+ Math.max(0, Math.min(255, Math.round(this.g) || 0)) + ", " |
|
+ Math.max(0, Math.min(255, Math.round(this.b) || 0)) |
|
+ (a === 1 ? ")" : ", " + a + ")"); |
|
} |
|
})); |
|
|
|
function hsla(h, s, l, a) { |
|
if (a <= 0) h = s = l = NaN; |
|
else if (l <= 0 || l >= 1) h = s = NaN; |
|
else if (s <= 0) h = NaN; |
|
return new Hsl(h, s, l, a); |
|
} |
|
|
|
function hslConvert(o) { |
|
if (o instanceof Hsl) return new Hsl(o.h, o.s, o.l, o.opacity); |
|
if (!(o instanceof Color)) o = color(o); |
|
if (!o) return new Hsl; |
|
if (o instanceof Hsl) return o; |
|
o = o.rgb(); |
|
var r = o.r / 255, |
|
g = o.g / 255, |
|
b = o.b / 255, |
|
min = Math.min(r, g, b), |
|
max = Math.max(r, g, b), |
|
h = NaN, |
|
s = max - min, |
|
l = (max + min) / 2; |
|
if (s) { |
|
if (r === max) h = (g - b) / s + (g < b) * 6; |
|
else if (g === max) h = (b - r) / s + 2; |
|
else h = (r - g) / s + 4; |
|
s /= l < 0.5 ? max + min : 2 - max - min; |
|
h *= 60; |
|
} else { |
|
s = l > 0 && l < 1 ? 0 : h; |
|
} |
|
return new Hsl(h, s, l, o.opacity); |
|
} |
|
|
|
function hsl(h, s, l, opacity) { |
|
return arguments.length === 1 ? hslConvert(h) : new Hsl(h, s, l, opacity == null ? 1 : opacity); |
|
} |
|
|
|
function Hsl(h, s, l, opacity) { |
|
this.h = +h; |
|
this.s = +s; |
|
this.l = +l; |
|
this.opacity = +opacity; |
|
} |
|
|
|
define(Hsl, hsl, extend(Color, { |
|
brighter: function(k) { |
|
k = k == null ? brighter : Math.pow(brighter, k); |
|
return new Hsl(this.h, this.s, this.l * k, this.opacity); |
|
}, |
|
darker: function(k) { |
|
k = k == null ? darker : Math.pow(darker, k); |
|
return new Hsl(this.h, this.s, this.l * k, this.opacity); |
|
}, |
|
rgb: function() { |
|
var h = this.h % 360 + (this.h < 0) * 360, |
|
s = isNaN(h) || isNaN(this.s) ? 0 : this.s, |
|
l = this.l, |
|
m2 = l + (l < 0.5 ? l : 1 - l) * s, |
|
m1 = 2 * l - m2; |
|
return new Rgb( |
|
hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2), |
|
hsl2rgb(h, m1, m2), |
|
hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2), |
|
this.opacity |
|
); |
|
}, |
|
displayable: function() { |
|
return (0 <= this.s && this.s <= 1 || isNaN(this.s)) |
|
&& (0 <= this.l && this.l <= 1) |
|
&& (0 <= this.opacity && this.opacity <= 1); |
|
} |
|
})); |
|
|
|
/* From FvD 13.37, CSS Color Module Level 3 */ |
|
function hsl2rgb(h, m1, m2) { |
|
return (h < 60 ? m1 + (m2 - m1) * h / 60 |
|
: h < 180 ? m2 |
|
: h < 240 ? m1 + (m2 - m1) * (240 - h) / 60 |
|
: m1) * 255; |
|
} |
|
|
|
var deg2rad = Math.PI / 180; |
|
var rad2deg = 180 / Math.PI; |
|
|
|
var Kn = 18; |
|
var Xn = 0.950470; |
|
var Yn = 1; |
|
var Zn = 1.088830; |
|
var t0 = 4 / 29; |
|
var t1 = 6 / 29; |
|
var t2 = 3 * t1 * t1; |
|
var t3 = t1 * t1 * t1; |
|
function labConvert(o) { |
|
if (o instanceof Lab) return new Lab(o.l, o.a, o.b, o.opacity); |
|
if (o instanceof Hcl) { |
|
var h = o.h * deg2rad; |
|
return new Lab(o.l, Math.cos(h) * o.c, Math.sin(h) * o.c, o.opacity); |
|
} |
|
if (!(o instanceof Rgb)) o = rgbConvert(o); |
|
var b = rgb2xyz(o.r), |
|
a = rgb2xyz(o.g), |
|
l = rgb2xyz(o.b), |
|
x = xyz2lab((0.4124564 * b + 0.3575761 * a + 0.1804375 * l) / Xn), |
|
y = xyz2lab((0.2126729 * b + 0.7151522 * a + 0.0721750 * l) / Yn), |
|
z = xyz2lab((0.0193339 * b + 0.1191920 * a + 0.9503041 * l) / Zn); |
|
return new Lab(116 * y - 16, 500 * (x - y), 200 * (y - z), o.opacity); |
|
} |
|
|
|
function lab(l, a, b, opacity) { |
|
return arguments.length === 1 ? labConvert(l) : new Lab(l, a, b, opacity == null ? 1 : opacity); |
|
} |
|
|
|
function Lab(l, a, b, opacity) { |
|
this.l = +l; |
|
this.a = +a; |
|
this.b = +b; |
|
this.opacity = +opacity; |
|
} |
|
|
|
define(Lab, lab, extend(Color, { |
|
brighter: function(k) { |
|
return new Lab(this.l + Kn * (k == null ? 1 : k), this.a, this.b, this.opacity); |
|
}, |
|
darker: function(k) { |
|
return new Lab(this.l - Kn * (k == null ? 1 : k), this.a, this.b, this.opacity); |
|
}, |
|
rgb: function() { |
|
var y = (this.l + 16) / 116, |
|
x = isNaN(this.a) ? y : y + this.a / 500, |
|
z = isNaN(this.b) ? y : y - this.b / 200; |
|
y = Yn * lab2xyz(y); |
|
x = Xn * lab2xyz(x); |
|
z = Zn * lab2xyz(z); |
|
return new Rgb( |
|
xyz2rgb( 3.2404542 * x - 1.5371385 * y - 0.4985314 * z), // D65 -> sRGB |
|
xyz2rgb(-0.9692660 * x + 1.8760108 * y + 0.0415560 * z), |
|
xyz2rgb( 0.0556434 * x - 0.2040259 * y + 1.0572252 * z), |
|
this.opacity |
|
); |
|
} |
|
})); |
|
|
|
function xyz2lab(t) { |
|
return t > t3 ? Math.pow(t, 1 / 3) : t / t2 + t0; |
|
} |
|
|
|
function lab2xyz(t) { |
|
return t > t1 ? t * t * t : t2 * (t - t0); |
|
} |
|
|
|
function xyz2rgb(x) { |
|
return 255 * (x <= 0.0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055); |
|
} |
|
|
|
function rgb2xyz(x) { |
|
return (x /= 255) <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4); |
|
} |
|
|
|
function hclConvert(o) { |
|
if (o instanceof Hcl) return new Hcl(o.h, o.c, o.l, o.opacity); |
|
if (!(o instanceof Lab)) o = labConvert(o); |
|
var h = Math.atan2(o.b, o.a) * rad2deg; |
|
return new Hcl(h < 0 ? h + 360 : h, Math.sqrt(o.a * o.a + o.b * o.b), o.l, o.opacity); |
|
} |
|
|
|
function hcl(h, c, l, opacity) { |
|
return arguments.length === 1 ? hclConvert(h) : new Hcl(h, c, l, opacity == null ? 1 : opacity); |
|
} |
|
|
|
function Hcl(h, c, l, opacity) { |
|
this.h = +h; |
|
this.c = +c; |
|
this.l = +l; |
|
this.opacity = +opacity; |
|
} |
|
|
|
define(Hcl, hcl, extend(Color, { |
|
brighter: function(k) { |
|
return new Hcl(this.h, this.c, this.l + Kn * (k == null ? 1 : k), this.opacity); |
|
}, |
|
darker: function(k) { |
|
return new Hcl(this.h, this.c, this.l - Kn * (k == null ? 1 : k), this.opacity); |
|
}, |
|
rgb: function() { |
|
return labConvert(this).rgb(); |
|
} |
|
})); |
|
|
|
var A = -0.14861; |
|
var B = +1.78277; |
|
var C = -0.29227; |
|
var D = -0.90649; |
|
var E = +1.97294; |
|
var ED = E * D; |
|
var EB = E * B; |
|
var BC_DA = B * C - D * A; |
|
function cubehelixConvert(o) { |
|
if (o instanceof Cubehelix) return new Cubehelix(o.h, o.s, o.l, o.opacity); |
|
if (!(o instanceof Rgb)) o = rgbConvert(o); |
|
var r = o.r / 255, |
|
g = o.g / 255, |
|
b = o.b / 255, |
|
l = (BC_DA * b + ED * r - EB * g) / (BC_DA + ED - EB), |
|
bl = b - l, |
|
k = (E * (g - l) - C * bl) / D, |
|
s = Math.sqrt(k * k + bl * bl) / (E * l * (1 - l)), // NaN if l=0 or l=1 |
|
h = s ? Math.atan2(k, bl) * rad2deg - 120 : NaN; |
|
return new Cubehelix(h < 0 ? h + 360 : h, s, l, o.opacity); |
|
} |
|
|
|
function cubehelix(h, s, l, opacity) { |
|
return arguments.length === 1 ? cubehelixConvert(h) : new Cubehelix(h, s, l, opacity == null ? 1 : opacity); |
|
} |
|
|
|
function Cubehelix(h, s, l, opacity) { |
|
this.h = +h; |
|
this.s = +s; |
|
this.l = +l; |
|
this.opacity = +opacity; |
|
} |
|
|
|
define(Cubehelix, cubehelix, extend(Color, { |
|
brighter: function(k) { |
|
k = k == null ? brighter : Math.pow(brighter, k); |
|
return new Cubehelix(this.h, this.s, this.l * k, this.opacity); |
|
}, |
|
darker: function(k) { |
|
k = k == null ? darker : Math.pow(darker, k); |
|
return new Cubehelix(this.h, this.s, this.l * k, this.opacity); |
|
}, |
|
rgb: function() { |
|
var h = isNaN(this.h) ? 0 : (this.h + 120) * deg2rad, |
|
l = +this.l, |
|
a = isNaN(this.s) ? 0 : this.s * l * (1 - l), |
|
cosh = Math.cos(h), |
|
sinh = Math.sin(h); |
|
return new Rgb( |
|
255 * (l + a * (A * cosh + B * sinh)), |
|
255 * (l + a * (C * cosh + D * sinh)), |
|
255 * (l + a * (E * cosh)), |
|
this.opacity |
|
); |
|
} |
|
})); |
|
|
|
exports.color = color; |
|
exports.rgb = rgb; |
|
exports.hsl = hsl; |
|
exports.lab = lab; |
|
exports.hcl = hcl; |
|
exports.cubehelix = cubehelix; |
|
|
|
Object.defineProperty(exports, '__esModule', { value: true }); |
|
|
|
})); |
|
},{}],5:[function(require,module,exports){ |
|
// http://geoexamples.com/d3-composite-projections/ Version 1.0.0. Copyright 2016 Roger Veciana i Rovira. |
|
(function (global, factory) { |
|
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('d3-geo'), require('d3-path')) : |
|
typeof define === 'function' && define.amd ? define(['exports', 'd3-geo', 'd3-path'], factory) : |
|
(factory((global.d3 = global.d3 || {}),global.d3,global.d3)); |
|
}(this, function (exports,d3Geo,d3Path) { 'use strict'; |
|
|
|
var epsilon = 1e-6; |
|
|
|
// The projections must have mutually exclusive clip regions on the sphere, |
|
// as this will avoid emitting interleaving lines and polygons. |
|
function multiplex(streams) { |
|
var n = streams.length; |
|
return { |
|
point: function(x, y) { var i = -1; while (++i < n) streams[i].point(x, y); }, |
|
sphere: function() { var i = -1; while (++i < n) streams[i].sphere(); }, |
|
lineStart: function() { var i = -1; while (++i < n) streams[i].lineStart(); }, |
|
lineEnd: function() { var i = -1; while (++i < n) streams[i].lineEnd(); }, |
|
polygonStart: function() { var i = -1; while (++i < n) streams[i].polygonStart(); }, |
|
polygonEnd: function() { var i = -1; while (++i < n) streams[i].polygonEnd(); } |
|
}; |
|
} |
|
|
|
// A composite projection for the United States, configured by default for |
|
// 960×500. Also works quite well at 960×600 with scale 1285. The set of |
|
// standard parallels for each region comes from USGS, which is published here: |
|
// http://egsc.usgs.gov/isb/pubs/MapProjections/projections.html#albers |
|
function albersUsa() { |
|
var cache, |
|
cacheStream, |
|
lower48 = d3Geo.geoAlbers(), lower48Point, |
|
alaska = d3Geo.geoConicEqualArea().rotate([154, 0]).center([-2, 58.5]).parallels([55, 65]), alaskaPoint, // EPSG:3338 |
|
hawaii = d3Geo.geoConicEqualArea().rotate([157, 0]).center([-3, 19.9]).parallels([8, 18]), hawaiiPoint, // ESRI:102007 |
|
point, pointStream = {point: function(x, y) { point = [x, y]; }}; |
|
|
|
function albersUsa(coordinates) { |
|
var x = coordinates[0], y = coordinates[1]; |
|
return point = null, |
|
(lower48Point.point(x, y), point) |
|
|| (alaskaPoint.point(x, y), point) |
|
|| (hawaiiPoint.point(x, y), point); |
|
} |
|
|
|
albersUsa.invert = function(coordinates) { |
|
var k = lower48.scale(), |
|
t = lower48.translate(), |
|
x = (coordinates[0] - t[0]) / k, |
|
y = (coordinates[1] - t[1]) / k; |
|
return (y >= 0.120 && y < 0.234 && x >= -0.425 && x < -0.214 ? alaska |
|
: y >= 0.166 && y < 0.234 && x >= -0.214 && x < -0.115 ? hawaii |
|
: lower48).invert(coordinates); |
|
}; |
|
|
|
albersUsa.stream = function(stream) { |
|
return cache && cacheStream === stream ? cache : cache = multiplex([lower48.stream(cacheStream = stream), alaska.stream(stream), hawaii.stream(stream)]); |
|
}; |
|
|
|
albersUsa.precision = function(_) { |
|
if (!arguments.length) return lower48.precision(); |
|
lower48.precision(_), alaska.precision(_), hawaii.precision(_); |
|
return albersUsa; |
|
}; |
|
|
|
albersUsa.scale = function(_) { |
|
if (!arguments.length) return lower48.scale(); |
|
lower48.scale(_), alaska.scale(_ * 0.35), hawaii.scale(_); |
|
return albersUsa.translate(lower48.translate()); |
|
}; |
|
|
|
albersUsa.translate = function(_) { |
|
if (!arguments.length) return lower48.translate(); |
|
var k = lower48.scale(), x = +_[0], y = +_[1]; |
|
|
|
lower48Point = lower48 |
|
.translate(_) |
|
.clipExtent([[x - 0.455 * k, y - 0.238 * k], [x + 0.455 * k, y + 0.238 * k]]) |
|
.stream(pointStream); |
|
|
|
alaskaPoint = alaska |
|
.translate([x - 0.307 * k, y + 0.201 * k]) |
|
.clipExtent([[x - 0.425 * k + epsilon, y + 0.120 * k + epsilon], [x - 0.214 * k - epsilon, y + 0.234 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
hawaiiPoint = hawaii |
|
.translate([x - 0.205 * k, y + 0.212 * k]) |
|
.clipExtent([[x - 0.214 * k + epsilon, y + 0.166 * k + epsilon], [x - 0.115 * k - epsilon, y + 0.234 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
return albersUsa; |
|
}; |
|
|
|
albersUsa.drawCompositionBorders = function(context) { |
|
var hawaii1 = lower48([-102.91, 26.3]); |
|
var hawaii2 = lower48([-104.0, 27.5]); |
|
var hawaii3 = lower48([-108.0, 29.1]); |
|
var hawaii4 = lower48([-110.0, 29.1]); |
|
|
|
var alaska1 = lower48([-110.0, 26.7]); |
|
var alaska2 = lower48([-112.8, 27.6]); |
|
var alaska3 = lower48([-114.3, 30.6]); |
|
var alaska4 = lower48([-119.3, 30.1]); |
|
|
|
context.moveTo(hawaii1[0], hawaii1[1]); |
|
context.lineTo(hawaii2[0], hawaii2[1]); |
|
context.lineTo(hawaii3[0], hawaii3[1]); |
|
context.lineTo(hawaii4[0], hawaii4[1]); |
|
|
|
context.moveTo(alaska1[0], alaska1[1]); |
|
context.lineTo(alaska2[0], alaska2[1]); |
|
context.lineTo(alaska3[0], alaska3[1]); |
|
context.lineTo(alaska4[0], alaska4[1]); |
|
|
|
}; |
|
albersUsa.getCompositionBorders = function() { |
|
var context = d3Path.path(); |
|
this.drawCompositionBorders(context); |
|
return context.toString(); |
|
|
|
}; |
|
|
|
|
|
return albersUsa.scale(1070); |
|
} |
|
|
|
// The projections must have mutually exclusive clip regions on the sphere, |
|
// as this will avoid emitting interleaving lines and polygons. |
|
function multiplex$1(streams) { |
|
var n = streams.length; |
|
return { |
|
point: function(x, y) { var i = -1; while (++i < n) streams[i].point(x, y); }, |
|
sphere: function() { var i = -1; while (++i < n) streams[i].sphere(); }, |
|
lineStart: function() { var i = -1; while (++i < n) streams[i].lineStart(); }, |
|
lineEnd: function() { var i = -1; while (++i < n) streams[i].lineEnd(); }, |
|
polygonStart: function() { var i = -1; while (++i < n) streams[i].polygonStart(); }, |
|
polygonEnd: function() { var i = -1; while (++i < n) streams[i].polygonEnd(); } |
|
}; |
|
} |
|
|
|
// A composite projection for the United States, configured by default for |
|
// 960×500. Also works quite well at 960×600 with scale 1285. The set of |
|
// standard parallels for each region comes from USGS, which is published here: |
|
// http://egsc.usgs.gov/isb/pubs/MapProjections/projections.html#albers |
|
function albersUsaTerritories() { |
|
var cache, |
|
cacheStream, |
|
lower48 = d3Geo.geoAlbers(), lower48Point, |
|
alaska = d3Geo.geoConicEqualArea().rotate([154, 0]).center([-2, 58.5]).parallels([55, 65]), alaskaPoint, // EPSG:3338 |
|
hawaii = d3Geo.geoConicEqualArea().rotate([157, 0]).center([-3, 19.9]).parallels([8, 18]), hawaiiPoint, // ESRI:102007 |
|
puertoRico = d3Geo.geoConicEqualArea().rotate([66, 0]).center([0, 18]).parallels([8, 18]), puertoRicoPoint, //Taken from https://bl.ocks.org/mbostock/5629120 |
|
samoa = d3Geo.geoEquirectangular().rotate([173, 14]), samoaPoint, // EPSG:4169 |
|
guam = d3Geo.geoEquirectangular().rotate([-145, -16.8]), guamPoint, |
|
point, pointStream = {point: function(x, y) { point = [x, y]; }}; |
|
|
|
/* |
|
var puertoRicoBbox = [[-68.3, 19], [-63.9, 17]]; |
|
var samoaBbox = [[-171, -14], [-168, -14.8]]; |
|
var guamBbox = [[144, 20.8], [146.5, 12.7]]; |
|
*/ |
|
|
|
function albersUsa(coordinates) { |
|
var x = coordinates[0], y = coordinates[1]; |
|
|
|
return point = null, |
|
(lower48Point.point(x, y), point) || |
|
(alaskaPoint.point(x, y), point) || |
|
(hawaiiPoint.point(x, y), point) || |
|
(puertoRicoPoint.point(x, y), point) || |
|
(samoaPoint.point(x, y), point) || |
|
(guamPoint.point(x, y), point); |
|
} |
|
|
|
albersUsa.invert = function(coordinates) { |
|
|
|
var k = lower48.scale(), |
|
t = lower48.translate(), |
|
x = (coordinates[0] - t[0]) / k, |
|
y = (coordinates[1] - t[1]) / k; |
|
/* |
|
//How are the return values calculated: |
|
console.info("******"); |
|
var c0 = puertoRico(puertoRicoBbox[0]); |
|
var x0 = (c0[0] - t[0]) / k; |
|
var y0 = (c0[1] - t[1]) / k; |
|
|
|
console.info("p0 puertoRico", x0 + ' - ' + y0); |
|
|
|
var c1 = puertoRico(puertoRicoBbox[1]); |
|
var x1 = (c1[0] - t[0]) / k; |
|
var y1 = (c1[1] - t[1]) / k; |
|
|
|
console.info("p1 puertoRico", x1 + ' - ' + y1); |
|
|
|
c0 = samoa(samoaBbox[0]); |
|
x0 = (c0[0] - t[0]) / k; |
|
y0 = (c0[1] - t[1]) / k; |
|
|
|
console.info("p0 samoa", x0 + ' - ' + y0); |
|
|
|
c1 = samoa(samoaBbox[1]); |
|
x1 = (c1[0] - t[0]) / k; |
|
y1 = (c1[1] - t[1]) / k; |
|
|
|
console.info("p1 samoa", x1 + ' - ' + y1); |
|
|
|
c0 = guam(guamBbox[0]); |
|
x0 = (c0[0] - t[0]) / k; |
|
y0 = (c0[1] - t[1]) / k; |
|
|
|
console.info("p0 guam", x0 + ' - ' + y0); |
|
|
|
c1 = guam(guamBbox[1]); |
|
x1 = (c1[0] - t[0]) / k; |
|
y1 = (c1[1] - t[1]) / k; |
|
|
|
console.info("p1 guam", x1 + ' - ' + y1); |
|
*/ |
|
|
|
return (y >= 0.120 && y < 0.234 && x >= -0.425 && x < -0.214 ? alaska |
|
: y >= 0.166 && y < 0.234 && x >= -0.214 && x < -0.115 ? hawaii |
|
: y >= 0.2064 && y < 0.2413 && x >= 0.312 && x < 0.385 ? puertoRico |
|
: y >= 0.09 && y < 0.1197 && x >= -0.4243 && x < -0.3232 ? samoa |
|
: y >= -0.0518 && y < 0.0895 && x >= -0.4243 && x < -0.3824 ? guam |
|
: lower48).invert(coordinates); |
|
|
|
}; |
|
|
|
albersUsa.stream = function(stream) { |
|
return cache && cacheStream === stream ? cache : cache = multiplex$1([lower48.stream(cacheStream = stream), alaska.stream(stream), hawaii.stream(stream), puertoRico.stream(stream), samoa.stream(stream), guam.stream(stream)]); |
|
}; |
|
|
|
albersUsa.precision = function(_) { |
|
if (!arguments.length) {return lower48.precision();} |
|
lower48.precision(_); |
|
alaska.precision(_); |
|
hawaii.precision(_); |
|
puertoRico.precision(_); |
|
samoa.precision(_); |
|
guam.precision(_); |
|
return albersUsa; |
|
}; |
|
|
|
albersUsa.scale = function(_) { |
|
if (!arguments.length) {return lower48.scale();} |
|
lower48.scale(_); |
|
alaska.scale(_ * 0.35); |
|
hawaii.scale(_); |
|
puertoRico.scale(_); |
|
samoa.scale(_* 2); |
|
guam.scale(_); |
|
return albersUsa.translate(lower48.translate()); |
|
}; |
|
|
|
albersUsa.translate = function(_) { |
|
if (!arguments.length) {return lower48.translate();} |
|
var k = lower48.scale(), x = +_[0], y = +_[1]; |
|
|
|
/* |
|
var c0 = puertoRico.translate([x + 0.350 * k, y + 0.224 * k])(puertoRicoBbox[0]); |
|
var x0 = (x - c0[0]) / k; |
|
var y0 = (y - c0[1]) / k; |
|
|
|
var c1 = puertoRico.translate([x + 0.350 * k, y + 0.224 * k])(puertoRicoBbox[1]); |
|
var x1 = (x - c1[0]) / k; |
|
var y1 = (y - c1[1]) / k; |
|
|
|
console.info('puertoRico: p0: ' + x0 + ', ' + y0 + ' , p1: ' + x1 + ' - ' + y1); |
|
console.info('.clipExtent([[x '+ |
|
(x0<0?'+ ':'- ') + Math.abs(x0.toFixed(4))+ |
|
' * k + epsilon, y '+ |
|
(y0<0?'+ ':'- ') + Math.abs(y0.toFixed(4))+ |
|
' * k + epsilon],[x '+ |
|
(x1<0?'+ ':'- ') + Math.abs(x1.toFixed(4))+ |
|
' * k - epsilon, y '+ |
|
(y1<0?'+ ':'- ') + Math.abs(y1.toFixed(4))+ |
|
' * k - epsilon]])'); |
|
|
|
c0 = samoa.translate([x - 0.492 * k, y + 0.09 * k])(samoaBbox[0]); |
|
x0 = (x - c0[0]) / k; |
|
y0 = (y - c0[1]) / k; |
|
|
|
c1 = samoa.translate([x - 0.492 * k, y + 0.09 * k])(samoaBbox[1]); |
|
x1 = (x - c1[0]) / k; |
|
y1 = (y - c1[1]) / k; |
|
|
|
console.info('samoa: p0: ' + x0 + ', ' + y0 + ' , p1: ' + x1 + ' - ' + y1); |
|
console.info('.clipExtent([[x '+ |
|
(x0<0?'+ ':'- ') + Math.abs(x0.toFixed(4))+ |
|
' * k + epsilon, y '+ |
|
(y0<0?'+ ':'- ') + Math.abs(y0.toFixed(4))+ |
|
' * k + epsilon],[x '+ |
|
(x1<0?'+ ':'- ') + Math.abs(x1.toFixed(4))+ |
|
' * k - epsilon, y '+ |
|
(y1<0?'+ ':'- ') + Math.abs(y1.toFixed(4))+ |
|
' * k - epsilon]])'); |
|
|
|
c0 = guam.translate([x - 0.408 * k, y + 0.018 * k])(guamBbox[0]); |
|
x0 = (x - c0[0]) / k; |
|
y0 = (y - c0[1]) / k; |
|
|
|
c1 = guam.translate([x - 0.408 * k, y + 0.018 * k])(guamBbox[1]); |
|
x1 = (x - c1[0]) / k; |
|
y1 = (y - c1[1]) / k; |
|
|
|
console.info('guam: p0: ' + x0 + ', ' + y0 + ' , p1: ' + x1 + ' - ' + y1); |
|
console.info('.clipExtent([[x '+ |
|
(x0<0?'+ ':'- ') + Math.abs(x0.toFixed(4))+ |
|
' * k + epsilon, y '+ |
|
(y0<0?'+ ':'- ') + Math.abs(y0.toFixed(4))+ |
|
' * k + epsilon],[x '+ |
|
(x1<0?'+ ':'- ') + Math.abs(x1.toFixed(4))+ |
|
' * k - epsilon, y '+ |
|
(y1<0?'+ ':'- ') + Math.abs(y1.toFixed(4))+ |
|
' * k - epsilon]])'); |
|
*/ |
|
|
|
lower48Point = lower48 |
|
.translate(_) |
|
.clipExtent([[x - 0.455 * k, y - 0.238 * k], [x + 0.455 * k, y + 0.238 * k]]) |
|
.stream(pointStream); |
|
|
|
alaskaPoint = alaska |
|
.translate([x - 0.307 * k, y + 0.201 * k]) |
|
.clipExtent([[x - 0.425 * k + epsilon, y + 0.120 * k + epsilon], [x - 0.214 * k - epsilon, y + 0.233 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
hawaiiPoint = hawaii |
|
.translate([x - 0.205 * k, y + 0.212 * k]) |
|
.clipExtent([[x - 0.214 * k + epsilon, y + 0.166 * k + epsilon], [x - 0.115 * k - epsilon, y + 0.233 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
puertoRicoPoint = puertoRico |
|
.translate([x + 0.350 * k, y + 0.224 * k]) |
|
.clipExtent([[x + 0.312 * k + epsilon, y + 0.2064 * k + epsilon],[x + 0.385 * k - epsilon, y + 0.233 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
samoaPoint = samoa |
|
.translate([x - 0.492 * k, y + 0.09 * k]) |
|
.clipExtent([[x - 0.4243 * k + epsilon, y + 0.0903 * k + epsilon],[x - 0.3233 * k - epsilon, y + 0.1197 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
guamPoint = guam |
|
.translate([x - 0.408 * k, y + 0.018 * k]) |
|
.clipExtent([[x - 0.4244 * k + epsilon, y - 0.0519 * k + epsilon],[x - 0.3824 * k - epsilon, y + 0.0895 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
|
|
return albersUsa; |
|
}; |
|
|
|
albersUsa.drawCompositionBorders = function(context) { |
|
|
|
/* |
|
console.info("CLIP EXTENT hawaii: ", hawaii.clipExtent()); |
|
console.info("UL BBOX:", lower48.invert([hawaii.clipExtent()[0][0], hawaii.clipExtent()[0][1]])); |
|
console.info("UR BBOX:", lower48.invert([hawaii.clipExtent()[1][0], hawaii.clipExtent()[0][1]])); |
|
console.info("LD BBOX:", lower48.invert([hawaii.clipExtent()[1][0], hawaii.clipExtent()[1][1]])); |
|
console.info("LL BBOX:", lower48.invert([hawaii.clipExtent()[0][0], hawaii.clipExtent()[1][1]])); |
|
|
|
console.info("CLIP EXTENT alaska: ", alaska.clipExtent()); |
|
console.info("UL BBOX:", lower48.invert([alaska.clipExtent()[0][0], alaska.clipExtent()[0][1]])); |
|
console.info("UR BBOX:", lower48.invert([alaska.clipExtent()[1][0], alaska.clipExtent()[0][1]])); |
|
console.info("LD BBOX:", lower48.invert([alaska.clipExtent()[1][0], alaska.clipExtent()[1][1]])); |
|
console.info("LL BBOX:", lower48.invert([alaska.clipExtent()[0][0], alaska.clipExtent()[1][1]])); |
|
|
|
console.info("CLIP EXTENT puertoRico: ", puertoRico.clipExtent()); |
|
console.info("UL BBOX:", lower48.invert([puertoRico.clipExtent()[0][0], puertoRico.clipExtent()[0][1]])); |
|
console.info("UR BBOX:", lower48.invert([puertoRico.clipExtent()[1][0], puertoRico.clipExtent()[0][1]])); |
|
console.info("LD BBOX:", lower48.invert([puertoRico.clipExtent()[1][0], puertoRico.clipExtent()[1][1]])); |
|
console.info("LL BBOX:", lower48.invert([puertoRico.clipExtent()[0][0], puertoRico.clipExtent()[1][1]])); |
|
|
|
console.info("CLIP EXTENT samoa: ", samoa.clipExtent()); |
|
console.info("UL BBOX:", lower48.invert([samoa.clipExtent()[0][0], samoa.clipExtent()[0][1]])); |
|
console.info("UR BBOX:", lower48.invert([samoa.clipExtent()[1][0], samoa.clipExtent()[0][1]])); |
|
console.info("LD BBOX:", lower48.invert([samoa.clipExtent()[1][0], samoa.clipExtent()[1][1]])); |
|
console.info("LL BBOX:", lower48.invert([samoa.clipExtent()[0][0], samoa.clipExtent()[1][1]])); |
|
|
|
|
|
console.info("CLIP EXTENT guam: ", guam.clipExtent()); |
|
console.info("UL BBOX:", lower48.invert([guam.clipExtent()[0][0], guam.clipExtent()[0][1]])); |
|
console.info("UR BBOX:", lower48.invert([guam.clipExtent()[1][0], guam.clipExtent()[0][1]])); |
|
console.info("LD BBOX:", lower48.invert([guam.clipExtent()[1][0], guam.clipExtent()[1][1]])); |
|
console.info("LL BBOX:", lower48.invert([guam.clipExtent()[0][0], guam.clipExtent()[1][1]])); |
|
*/ |
|
|
|
var ulhawaii = lower48([-110.4641, 28.2805]); |
|
var urhawaii = lower48([-104.0597, 28.9528]); |
|
var ldhawaii = lower48([-103.7049, 25.1031]); |
|
var llhawaii = lower48([-109.8337, 24.4531]); |
|
|
|
var ulalaska = lower48([ -124.4745, 28.1407]); |
|
var uralaska = lower48([ -110.931, 30.8844]); |
|
var ldalaska = lower48([-109.8337, 24.4531]); |
|
var llalaska = lower48([-122.4628, 21.8562]); |
|
|
|
var ulpuertoRico = lower48([-76.8579, 25.1544]); |
|
var urpuertoRico = lower48([-72.429, 24.2097]); |
|
var ldpuertoRico = lower48([-72.8265, 22.7056]); |
|
var llpuertoRico = lower48([-77.1852, 23.6392]); |
|
|
|
|
|
var ulsamoa = lower48([-125.0093, 29.7791]); |
|
var ursamoa = lower48([-118.5193, 31.3262]); |
|
var ldsamoa = lower48([-118.064, 29.6912]); |
|
var llsamoa = lower48([-124.4369, 28.169]); |
|
|
|
var ulguam = lower48([-128.1314, 37.4582]); |
|
var urguam = lower48([-125.2132, 38.214]); |
|
var ldguam = lower48([-122.3616, 30.5115]); |
|
var llguam = lower48([-125.0315, 29.8211]); |
|
|
|
context.moveTo(ulhawaii[0], ulhawaii[1]); |
|
context.lineTo(urhawaii[0], urhawaii[1]); |
|
context.lineTo(ldhawaii[0], ldhawaii[1]); |
|
context.lineTo(ldhawaii[0], ldhawaii[1]); |
|
context.lineTo(llhawaii[0], llhawaii[1]); |
|
context.closePath(); |
|
|
|
context.moveTo(ulalaska[0], ulalaska[1]); |
|
context.lineTo(uralaska[0], uralaska[1]); |
|
context.lineTo(ldalaska[0], ldalaska[1]); |
|
context.lineTo(ldalaska[0], ldalaska[1]); |
|
context.lineTo(llalaska[0], llalaska[1]); |
|
context.closePath(); |
|
|
|
context.moveTo(ulpuertoRico[0], ulpuertoRico[1]); |
|
context.lineTo(urpuertoRico[0], urpuertoRico[1]); |
|
context.lineTo(ldpuertoRico[0], ldpuertoRico[1]); |
|
context.lineTo(ldpuertoRico[0], ldpuertoRico[1]); |
|
context.lineTo(llpuertoRico[0], llpuertoRico[1]); |
|
context.closePath(); |
|
|
|
context.moveTo(ulsamoa[0], ulsamoa[1]); |
|
context.lineTo(ursamoa[0], ursamoa[1]); |
|
context.lineTo(ldsamoa[0], ldsamoa[1]); |
|
context.lineTo(ldsamoa[0], ldsamoa[1]); |
|
context.lineTo(llsamoa[0], llsamoa[1]); |
|
context.closePath(); |
|
|
|
context.moveTo(ulguam[0], ulguam[1]); |
|
context.lineTo(urguam[0], urguam[1]); |
|
context.lineTo(ldguam[0], ldguam[1]); |
|
context.lineTo(ldguam[0], ldguam[1]); |
|
context.lineTo(llguam[0], llguam[1]); |
|
context.closePath(); |
|
|
|
}; |
|
albersUsa.getCompositionBorders = function() { |
|
var context = d3Path.path(); |
|
this.drawCompositionBorders(context); |
|
return context.toString(); |
|
|
|
}; |
|
|
|
|
|
return albersUsa.scale(1070); |
|
} |
|
|
|
// The projections must have mutually exclusive clip regions on the sphere, |
|
// as this will avoid emitting interleaving lines and polygons. |
|
function multiplex$2(streams) { |
|
var n = streams.length; |
|
return { |
|
point: function(x, y) { var i = -1; while (++i < n) {streams[i].point(x, y); }}, |
|
sphere: function() { var i = -1; while (++i < n) {streams[i].sphere(); }}, |
|
lineStart: function() { var i = -1; while (++i < n) {streams[i].lineStart(); }}, |
|
lineEnd: function() { var i = -1; while (++i < n) {streams[i].lineEnd(); }}, |
|
polygonStart: function() { var i = -1; while (++i < n) {streams[i].polygonStart(); }}, |
|
polygonEnd: function() { var i = -1; while (++i < n) {streams[i].polygonEnd(); }} |
|
}; |
|
} |
|
|
|
// A composite projection for Spain, configured by default for 960×500. |
|
function conicConformalSpain() { |
|
var cache, |
|
cacheStream, |
|
|
|
iberianPeninsule = d3Geo.geoConicConformal().rotate([5, -38.6]).parallels([0,60]), iberianPeninsulePoint, |
|
canaryIslands = d3Geo.geoConicConformal().rotate([5, -38.6]).parallels([0,60]), canaryIslandsPoint, |
|
|
|
point, pointStream = {point: function(x, y) { point = [x, y]; }}; |
|
|
|
/* |
|
var iberianPeninsuleBbox = [[-11, 46], [4, 35]]; |
|
var canaryIslandsBbox = [[-19.0, 28.85], [-12.7, 28.1]]; |
|
*/ |
|
|
|
function conicConformalSpain(coordinates) { |
|
var x = coordinates[0], y = coordinates[1]; |
|
return point = null, |
|
(iberianPeninsulePoint.point(x, y), point) || |
|
(canaryIslandsPoint.point(x, y), point); |
|
} |
|
|
|
conicConformalSpain.invert = function(coordinates) { |
|
var k = iberianPeninsule.scale(), |
|
t = iberianPeninsule.translate(), |
|
x = (coordinates[0] - t[0]) / k, |
|
y = (coordinates[1] - t[1]) / k; |
|
/* |
|
//How are the return values calculated: |
|
var c0 = canaryIslands(canaryIslandsBbox[0]); |
|
var x0 = (c0[0] - t[0]) / k; |
|
var y0 = (c0[1] - t[1]) / k; |
|
|
|
console.info("p0 canary islands", x0 + ' - ' + y0); |
|
|
|
|
|
var c1 = canaryIslands(canaryIslandsBbox[1]); |
|
var x1 = (c1[0] - t[0]) / k; |
|
var y1 = (c1[1] - t[1]) / k; |
|
|
|
console.info("p1 canary islands", x1 + ' - ' + y1); |
|
*/ |
|
return (y >= 0.05346 && y< 0.0897 && x >= -0.13388 && x < -0.0322 ? canaryIslands |
|
: iberianPeninsule).invert(coordinates); |
|
}; |
|
|
|
conicConformalSpain.stream = function(stream) { |
|
return cache && cacheStream === stream ? cache : cache = multiplex$2([iberianPeninsule.stream(cacheStream = stream), canaryIslands.stream(stream)]); |
|
}; |
|
|
|
conicConformalSpain.precision = function(_) { |
|
if (!arguments.length) {return iberianPeninsule.precision();} |
|
iberianPeninsule.precision(_); |
|
canaryIslands.precision(_); |
|
return conicConformalSpain; |
|
}; |
|
|
|
conicConformalSpain.scale = function(_) { |
|
if (!arguments.length) {return iberianPeninsule.scale();} |
|
iberianPeninsule.scale(_); |
|
canaryIslands.scale(_); |
|
return conicConformalSpain.translate(iberianPeninsule.translate()); |
|
}; |
|
|
|
conicConformalSpain.translate = function(_) { |
|
if (!arguments.length) {return iberianPeninsule.translate();} |
|
var k = iberianPeninsule.scale(), x = +_[0], y = +_[1]; |
|
/* |
|
var c0 = iberianPeninsule(iberianPeninsuleBbox[0]); |
|
var x0 = (x - c0[0]) / k; |
|
var y0 = (y - c0[1]) / k; |
|
|
|
var c1 = iberianPeninsule(iberianPeninsuleBbox[1]); |
|
var x1 = (x - c1[0]) / k; |
|
var y1 = (y - c1[1]) / k; |
|
|
|
console.info('Iberian Peninsula: p0: ' + x0 + ', ' + y0 + ' , p1: ' + x1 + ' - ' + y1); |
|
|
|
c0 = canaryIslands.translate([x + 0.1 * k, y - 0.094 * k])(canaryIslandsBbox[0]); |
|
x0 = (x - c0[0]) / k; |
|
y0 = (y - c0[1]) / k; |
|
|
|
c1 = canaryIslands.translate([x + 0.1 * k, y - 0.094 * k])(canaryIslandsBbox[1]); |
|
x1 = (x - c1[0]) / k; |
|
y1 = (y - c1[1]) / k; |
|
|
|
console.info('Canry Islands: p0: ' + x0 + ', ' + y0 + ' , p1: ' + x1 + ' - ' + y1); |
|
*/ |
|
iberianPeninsulePoint = iberianPeninsule |
|
.translate(_) |
|
.clipExtent([[x - 0.06857 * k, y - 0.1288 * k],[x + 0.13249 * k, y + 0.05292 * k]]) |
|
.stream(pointStream); |
|
|
|
canaryIslandsPoint = canaryIslands |
|
.translate([x + 0.1 * k, y - 0.094 * k]) |
|
.clipExtent([[x - 0.1331 * k + epsilon, y + 0.053457 * k + epsilon],[x - 0.0354 * k - epsilon, y + 0.08969 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
return conicConformalSpain; |
|
}; |
|
|
|
conicConformalSpain.drawCompositionBorders = function(context) { |
|
/* |
|
console.info("CLIP EXTENT: ", canaryIslands.clipExtent()); |
|
console.info("UL BBOX:", iberianPeninsule.invert([canaryIslands.clipExtent()[0][0], canaryIslands.clipExtent()[0][1]])); |
|
console.info("UR BBOX:", iberianPeninsule.invert([canaryIslands.clipExtent()[1][0], canaryIslands.clipExtent()[0][1]])); |
|
console.info("LD BBOX:", iberianPeninsule.invert([canaryIslands.clipExtent()[1][0], canaryIslands.clipExtent()[1][1]])); |
|
*/ |
|
|
|
var ulCanaryIslands = iberianPeninsule([-14.0346750522884, 34.96500729877966]); |
|
var urCanaryIslands = iberianPeninsule([-7.4208899681602025, 35.53698899616862]); |
|
var ldCanaryIslands = iberianPeninsule([-7.314827535125545, 33.54359498636456]); |
|
|
|
context.moveTo(ulCanaryIslands[0], ulCanaryIslands[1]); |
|
context.lineTo(urCanaryIslands[0], urCanaryIslands[1]); |
|
context.lineTo(ldCanaryIslands[0], ldCanaryIslands[1]); |
|
}; |
|
conicConformalSpain.getCompositionBorders = function() { |
|
var context = d3Path.path(); |
|
this.drawCompositionBorders(context); |
|
return context.toString(); |
|
}; |
|
|
|
return conicConformalSpain.scale(2700); |
|
} |
|
|
|
// The projections must have mutually exclusive clip regions on the sphere, |
|
// as this will avoid emitting interleaving lines and polygons. |
|
function multiplex$3(streams) { |
|
var n = streams.length; |
|
return { |
|
point: function(x, y) { var i = -1; while (++i < n) {streams[i].point(x, y); }}, |
|
sphere: function() { var i = -1; while (++i < n) {streams[i].sphere(); }}, |
|
lineStart: function() { var i = -1; while (++i < n) {streams[i].lineStart(); }}, |
|
lineEnd: function() { var i = -1; while (++i < n) {streams[i].lineEnd(); }}, |
|
polygonStart: function() { var i = -1; while (++i < n) {streams[i].polygonStart(); }}, |
|
polygonEnd: function() { var i = -1; while (++i < n) {streams[i].polygonEnd(); }} |
|
}; |
|
} |
|
|
|
// A composite projection for Portugal, configured by default for 960×500. |
|
function conicConformalPortugal() { |
|
var cache, |
|
cacheStream, |
|
iberianPeninsule = d3Geo.geoConicConformal().rotate([10, -39.3]).parallels([0, 60]), iberianPeninsulePoint, |
|
madeira = d3Geo.geoConicConformal().rotate([17, -32.7]).parallels([0, 60]), madeiraPoint, |
|
azores = d3Geo.geoConicConformal().rotate([27.8, -38.6]).parallels([0, 60]), azoresPoint, |
|
|
|
point, pointStream = {point: function(x, y) { point = [x, y]; }}; |
|
|
|
/* |
|
var iberianPeninsuleBbox = [[-11, 46], [4, 34]]; |
|
var madeiraBbox = [[-17.85, 33.6], [-16, 32.02]]; |
|
var azoresBbox = [[-32, 40.529], [-23.98, 35.75]]; |
|
*/ |
|
|
|
|
|
function conicConformalPortugal(coordinates) { |
|
var x = coordinates[0], y = coordinates[1]; |
|
return point = null, |
|
(iberianPeninsulePoint.point(x, y), point) || |
|
(madeiraPoint.point(x, y), point) || |
|
(azoresPoint.point(x, y), point); |
|
} |
|
|
|
conicConformalPortugal.invert = function(coordinates) { |
|
var k = iberianPeninsule.scale(), |
|
t = iberianPeninsule.translate(), |
|
x = (coordinates[0] - t[0]) / k, |
|
y = (coordinates[1] - t[1]) / k; |
|
|
|
/* |
|
//How are the return values calculated: |
|
console.info("******"); |
|
var c0 = madeira(madeiraBbox[0]); |
|
var x0 = (c0[0] - t[0]) / k; |
|
var y0 = (c0[1] - t[1]) / k; |
|
|
|
console.info("p0 madeira", x0 + ' - ' + y0); |
|
|
|
var c1 = madeira(madeiraBbox[1]); |
|
var x1 = (c1[0] - t[0]) / k; |
|
var y1 = (c1[1] - t[1]) / k; |
|
|
|
console.info("p1 madeira", x1 + ' - ' + y1); |
|
|
|
c0 = azores(azoresBbox[0]); |
|
x0 = (c0[0] - t[0]) / k; |
|
y0 = (c0[1] - t[1]) / k; |
|
|
|
console.info("p0 azores", x0 + ' - ' + y0); |
|
|
|
c1 = azores(azoresBbox[1]); |
|
x1 = (c1[0] - t[0]) / k; |
|
y1 = (c1[1] - t[1]) / k; |
|
|
|
console.info("p1 azores", x1 + ' - ' + y1); |
|
*/ |
|
|
|
return (y >= 0.0093 && y< 0.03678 && x >= -0.03875 && x < -0.0116 ? madeira |
|
: y >= -0.0412 && y< 0.0091 && x >= -0.07782 && x < -0.01166 ? azores |
|
: iberianPeninsule).invert(coordinates); |
|
}; |
|
|
|
conicConformalPortugal.stream = function(stream) { |
|
return cache && cacheStream === stream ? cache : cache = multiplex$3([iberianPeninsule.stream(cacheStream = stream), madeira.stream(stream), azores.stream(stream)]); |
|
}; |
|
|
|
conicConformalPortugal.precision = function(_) { |
|
if (!arguments.length) {return iberianPeninsule.precision();} |
|
iberianPeninsule.precision(_); |
|
madeira.precision(_); |
|
azores.precision(_); |
|
return conicConformalPortugal; |
|
}; |
|
|
|
conicConformalPortugal.scale = function(_) { |
|
if (!arguments.length) {return iberianPeninsule.scale();} |
|
iberianPeninsule.scale(_); |
|
madeira.scale(_); |
|
azores.scale(_ * 0.6); |
|
return conicConformalPortugal.translate(iberianPeninsule.translate()); |
|
}; |
|
|
|
conicConformalPortugal.translate = function(_) { |
|
if (!arguments.length) {return iberianPeninsule.translate();} |
|
var k = iberianPeninsule.scale(), x = +_[0], y = +_[1]; |
|
/* |
|
var c0 = iberianPeninsule(iberianPeninsuleBbox[0]); |
|
var x0 = (x - c0[0]) / k; |
|
var y0 = (y - c0[1]) / k; |
|
|
|
var c1 = iberianPeninsule(iberianPeninsuleBbox[1]); |
|
var x1 = (x - c1[0]) / k; |
|
var y1 = (y - c1[1]) / k; |
|
|
|
console.info('Iberian Peninsula: p0: ' + x0 + ', ' + y0 + ' , p1: ' + x1 + ' - ' + y1); |
|
console.info('.clipExtent([[x '+ |
|
(x0<0?'+ ':'- ') + Math.abs(x0.toFixed(4))+ |
|
' * k, y '+ |
|
(y0<0?'+ ':'- ') + Math.abs(y0.toFixed(4))+ |
|
' * k],[x '+ |
|
(x1<0?'+ ':'- ') + Math.abs(x1.toFixed(4))+ |
|
' * k, y '+ |
|
(y1<0?'+ ':'- ') + Math.abs(y1.toFixed(4))+ |
|
' * k]])'); |
|
|
|
c0 = madeira.translate([x - 0.0265 * k, y + 0.025 * k])(madeiraBbox[0]); |
|
x0 = (x - c0[0]) / k; |
|
y0 = (y - c0[1]) / k; |
|
|
|
c1 = madeira.translate([x - 0.0265 * k, y + 0.025 * k])(madeiraBbox[1]); |
|
x1 = (x - c1[0]) / k; |
|
y1 = (y - c1[1]) / k; |
|
|
|
console.info('Madeira: p0: ' + x0 + ', ' + y0 + ' , p1: ' + x1 + ' - ' + y1); |
|
console.info('.clipExtent([[x '+ |
|
(x0<0?'+ ':'- ') + Math.abs(x0.toFixed(4))+ |
|
' * k + epsilon, y '+ |
|
(y0<0?'+ ':'- ') + Math.abs(y0.toFixed(4))+ |
|
' * k + epsilon],[x '+ |
|
(x1<0?'+ ':'- ') + Math.abs(x1.toFixed(4))+ |
|
' * k - epsilon, y '+ |
|
(y1<0?'+ ':'- ') + Math.abs(y1.toFixed(4))+ |
|
' * k - epsilon]])'); |
|
|
|
c0 = azores.translate([x - 0.045 * k, y + -0.02 * k])(azoresBbox[0]); |
|
x0 = (x - c0[0]) / k; |
|
y0 = (y - c0[1]) / k; |
|
|
|
c1 = azores.translate([x - 0.045 * k, y + -0.02 * k])(azoresBbox[1]); |
|
x1 = (x - c1[0]) / k; |
|
y1 = (y - c1[1]) / k; |
|
|
|
console.info('Azores: p0: ' + x0 + ', ' + y0 + ' , p1: ' + x1 + ' - ' + y1); |
|
console.info('.clipExtent([[x '+ |
|
(x0<0?'+ ':'- ') + Math.abs(x0.toFixed(4))+ |
|
' * k + epsilon, y '+ |
|
(y0<0?'+ ':'- ') + Math.abs(y0.toFixed(4))+ |
|
' * k + epsilon],[x '+ |
|
(x1<0?'+ ':'- ') + Math.abs(x1.toFixed(4))+ |
|
' * k - epsilon, y '+ |
|
(y1<0?'+ ':'- ') + Math.abs(y1.toFixed(4))+ |
|
' * k - epsilon]])'); |
|
*/ |
|
iberianPeninsulePoint = iberianPeninsule |
|
.translate(_) |
|
.clipExtent([[x - 0.0115 * k, y - 0.1138 * k],[x +0.2105 * k, y +0.0673 * k]]) |
|
.stream(pointStream); |
|
|
|
|
|
madeiraPoint = madeira |
|
.translate([x - 0.0265 * k, y + 0.025 * k]) |
|
.clipExtent([[x - 0.0388 * k + epsilon, y + 0.0093 * k + epsilon],[x - 0.0116 * k - epsilon, y + 0.0368 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
azoresPoint = azores |
|
.translate([x - 0.045 * k, y + -0.02 * k]) |
|
.clipExtent([[x - 0.0778 * k + epsilon, y - 0.0413 * k + epsilon],[x - 0.0117 * k - epsilon, y + 0.0091 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
return conicConformalPortugal; |
|
}; |
|
|
|
conicConformalPortugal.drawCompositionBorders = function(context) { |
|
/* |
|
console.info("CLIP EXTENT MADEIRA: ", madeira.clipExtent()); |
|
console.info("UL BBOX:", iberianPeninsule.invert([madeira.clipExtent()[0][0], madeira.clipExtent()[0][1]])); |
|
console.info("UR BBOX:", iberianPeninsule.invert([madeira.clipExtent()[1][0], madeira.clipExtent()[0][1]])); |
|
console.info("LD BBOX:", iberianPeninsule.invert([madeira.clipExtent()[1][0], madeira.clipExtent()[1][1]])); |
|
console.info("LL BBOX:", iberianPeninsule.invert([madeira.clipExtent()[0][0], madeira.clipExtent()[1][1]])); |
|
|
|
console.info("CLIP EXTENT AZORES: ", azores.clipExtent()); |
|
console.info("UL BBOX:", iberianPeninsule.invert([azores.clipExtent()[0][0], azores.clipExtent()[0][1]])); |
|
console.info("UR BBOX:", iberianPeninsule.invert([azores.clipExtent()[1][0], azores.clipExtent()[0][1]])); |
|
console.info("LD BBOX:", iberianPeninsule.invert([azores.clipExtent()[1][0], azores.clipExtent()[1][1]])); |
|
console.info("LL BBOX:", iberianPeninsule.invert([azores.clipExtent()[0][0], azores.clipExtent()[1][1]])); |
|
*/ |
|
|
|
var ulmadeira = iberianPeninsule([-12.8351, 38.7113]); |
|
var urmadeira = iberianPeninsule([-10.8482, 38.7633]); |
|
var ldmadeira = iberianPeninsule([-10.8181, 37.2072]); |
|
var llmadeira = iberianPeninsule([-12.7345, 37.1573]); |
|
|
|
var ulazores = iberianPeninsule([-16.0753, 41.4436]); |
|
var urazores = iberianPeninsule([-10.9168, 41.6861]); |
|
var ldazores = iberianPeninsule([-10.8557, 38.7747]); |
|
var llazores = iberianPeninsule([-15.6728, 38.5505]); |
|
|
|
context.moveTo(ulmadeira[0], ulmadeira[1]); |
|
context.lineTo(urmadeira[0], urmadeira[1]); |
|
context.lineTo(ldmadeira[0], ldmadeira[1]); |
|
context.lineTo(ldmadeira[0], ldmadeira[1]); |
|
context.lineTo(llmadeira[0], llmadeira[1]); |
|
context.closePath(); |
|
|
|
context.moveTo(ulazores[0], ulazores[1]); |
|
context.lineTo(urazores[0], urazores[1]); |
|
context.lineTo(ldazores[0], ldazores[1]); |
|
context.lineTo(ldazores[0], ldazores[1]); |
|
context.lineTo(llazores[0], llazores[1]); |
|
context.closePath(); |
|
|
|
}; |
|
conicConformalPortugal.getCompositionBorders = function() { |
|
var context = d3Path.path(); |
|
this.drawCompositionBorders(context); |
|
return context.toString(); |
|
}; |
|
|
|
return conicConformalPortugal.scale(4200); |
|
} |
|
|
|
// The projections must have mutually exclusive clip regions on the sphere, |
|
// as this will avoid emitting interleaving lines and polygons. |
|
function multiplex$4(streams) { |
|
var n = streams.length; |
|
return { |
|
point: function(x, y) { var i = -1; while (++i < n) {streams[i].point(x, y); }}, |
|
sphere: function() { var i = -1; while (++i < n) {streams[i].sphere(); }}, |
|
lineStart: function() { var i = -1; while (++i < n) {streams[i].lineStart(); }}, |
|
lineEnd: function() { var i = -1; while (++i < n) {streams[i].lineEnd(); }}, |
|
polygonStart: function() { var i = -1; while (++i < n) {streams[i].polygonStart(); }}, |
|
polygonEnd: function() { var i = -1; while (++i < n) {streams[i].polygonEnd(); }} |
|
}; |
|
} |
|
|
|
// A composite projection for Ecuador, configured by default for 960×500. |
|
function mercatorEcuador() { |
|
var cache, |
|
cacheStream, |
|
|
|
mainland = d3Geo.geoMercator().rotate([80, 1.5]), mainlandPoint, |
|
galapagos = d3Geo.geoMercator().rotate([90.73, 1]), galapagosPoint, |
|
|
|
point, pointStream = {point: function(x, y) { point = [x, y]; }}; |
|
|
|
/* |
|
var mainlandBbox = [[-81.5, 2.7], [-70.0, -6.0]]; |
|
var galapagosBbox = [[-92.2, 0.58], [-88.8, -1.8]]; |
|
*/ |
|
|
|
function mercatorEcuador(coordinates) { |
|
var x = coordinates[0], y = coordinates[1]; |
|
return point = null, |
|
(mainlandPoint.point(x, y), point) || |
|
(galapagosPoint.point(x, y), point); |
|
} |
|
|
|
mercatorEcuador.invert = function(coordinates) { |
|
var k = mainland.scale(), |
|
t = mainland.translate(), |
|
x = (coordinates[0] - t[0]) / k, |
|
y = (coordinates[1] - t[1]) / k; |
|
/* |
|
//How are the return values calculated: |
|
var c0 = galapagos(galapagosBbox[0]); |
|
var x0 = (c0[0] - t[0]) / k; |
|
var y0 = (c0[1] - t[1]) / k; |
|
|
|
console.info("p0 galapagos", x0 + ' - ' + y0); |
|
|
|
|
|
var c1 = galapagos(galapagosBbox[1]); |
|
var x1 = (c1[0] - t[0]) / k; |
|
var y1 = (c1[1] - t[1]) / k; |
|
|
|
console.info("p1 galapagos", x1 + ' - ' + y1); |
|
*/ |
|
return (y >= -0.0676 && y< -0.026 && x >= -0.0857 && x < -0.0263 ? galapagos |
|
: mainland).invert(coordinates); |
|
}; |
|
|
|
mercatorEcuador.stream = function(stream) { |
|
return cache && cacheStream === stream ? cache : cache = multiplex$4([mainland.stream(cacheStream = stream), galapagos.stream(stream)]); |
|
}; |
|
|
|
mercatorEcuador.precision = function(_) { |
|
if (!arguments.length) {return mainland.precision();} |
|
mainland.precision(_); |
|
galapagos.precision(_); |
|
return mercatorEcuador; |
|
}; |
|
|
|
mercatorEcuador.scale = function(_) { |
|
if (!arguments.length) {return mainland.scale();} |
|
mainland.scale(_); |
|
galapagos.scale(_); |
|
return mercatorEcuador.translate(mainland.translate()); |
|
}; |
|
|
|
mercatorEcuador.translate = function(_) { |
|
if (!arguments.length) {return mainland.translate();} |
|
var k = mainland.scale(), x = +_[0], y = +_[1]; |
|
/* |
|
var c0 = mainland(mainlandBbox[0]); |
|
var x0 = (x - c0[0]) / k; |
|
var y0 = (y - c0[1]) / k; |
|
|
|
var c1 = mainland(mainlandBbox[1]); |
|
var x1 = (x - c1[0]) / k; |
|
var y1 = (y - c1[1]) / k; |
|
|
|
console.info('mainland: p0: ' + x0 + ', ' + y0 + ' , p1: ' + x1 + ' - ' + y1); |
|
console.info('.clipExtent([[x '+ |
|
(x0<0?'+ ':'- ') + Math.abs(x0.toFixed(4))+ |
|
' * k, y '+ |
|
(y0<0?'+ ':'- ') + Math.abs(y0.toFixed(4))+ |
|
' * k],[x '+ |
|
(x1<0?'+ ':'- ') + Math.abs(x1.toFixed(4))+ |
|
' * k, y '+ |
|
(y1<0?'+ ':'- ') + Math.abs(y1.toFixed(4))+ |
|
' * k]])'); |
|
|
|
c0 = galapagos.translate([x - 0.06 * k, y - 0.04 * k])(galapagosBbox[0]); |
|
x0 = (x - c0[0]) / k; |
|
y0 = (y - c0[1]) / k; |
|
|
|
c1 = galapagos.translate([x - 0.06 * k, y - 0.04 * k])(galapagosBbox[1]); |
|
x1 = (x - c1[0]) / k; |
|
y1 = (y - c1[1]) / k; |
|
|
|
console.info('galapagos: p0: ' + x0 + ', ' + y0 + ' , p1: ' + x1 + ' - ' + y1); |
|
console.info('.clipExtent([[x '+ |
|
(x0<0?'+ ':'- ') + Math.abs(x0.toFixed(4))+ |
|
' * k + epsilon, y '+ |
|
(y0<0?'+ ':'- ') + Math.abs(y0.toFixed(4))+ |
|
' * k + epsilon],[x '+ |
|
(x1<0?'+ ':'- ') + Math.abs(x1.toFixed(4))+ |
|
' * k - epsilon, y '+ |
|
(y1<0?'+ ':'- ') + Math.abs(y1.toFixed(4))+ |
|
' * k - epsilon]])');*/ |
|
|
|
mainlandPoint = mainland |
|
.translate(_) |
|
.clipExtent([[x - 0.0262 * k, y - 0.0734 * k],[x + 0.1741 * k, y + 0.079 * k]]) |
|
.stream(pointStream); |
|
|
|
galapagosPoint = galapagos |
|
.translate([x - 0.06 * k, y - 0.04 * k]) |
|
.clipExtent([[x - 0.0857 * k + epsilon, y - 0.0676 * k + epsilon],[x - 0.0263 * k - epsilon, y - 0.026 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
return mercatorEcuador; |
|
}; |
|
|
|
mercatorEcuador.drawCompositionBorders = function(context) { |
|
/* |
|
console.info("CLIP EXTENT: ", galapagos.clipExtent()); |
|
console.info("UL BBOX:", mainland.invert([galapagos.clipExtent()[0][0], galapagos.clipExtent()[0][1]])); |
|
console.info("UR BBOX:", mainland.invert([galapagos.clipExtent()[1][0], galapagos.clipExtent()[0][1]])); |
|
console.info("LD BBOX:", mainland.invert([galapagos.clipExtent()[1][0], galapagos.clipExtent()[1][1]])); |
|
console.info("LL BBOX:", mainland.invert([galapagos.clipExtent()[0][0], galapagos.clipExtent()[1][1]])); |
|
*/ |
|
|
|
var ulgalapagos = mainland([-84.9032, 2.3757]); |
|
var urgalapagos = mainland([-81.5047, 2.3708]); |
|
var ldgalapagos = mainland([-81.5063, -0.01]); |
|
var llgalapagos = mainland([-84.9086, -0.005]); |
|
|
|
context.moveTo(ulgalapagos[0], ulgalapagos[1]); |
|
context.lineTo(urgalapagos[0], urgalapagos[1]); |
|
context.lineTo(ldgalapagos[0], ldgalapagos[1]); |
|
context.lineTo(llgalapagos[0], llgalapagos[1]); |
|
context.closePath(); |
|
|
|
}; |
|
mercatorEcuador.getCompositionBorders = function() { |
|
var context = d3Path.path(); |
|
this.drawCompositionBorders(context); |
|
return context.toString(); |
|
}; |
|
|
|
return mercatorEcuador.scale(3500); |
|
} |
|
|
|
// The projections must have mutually exclusive clip regions on the sphere, |
|
// as this will avoid emitting interleaving lines and polygons. |
|
function multiplex$5(streams) { |
|
var n = streams.length; |
|
return { |
|
point: function(x, y) { var i = -1; while (++i < n) {streams[i].point(x, y); }}, |
|
sphere: function() { var i = -1; while (++i < n) {streams[i].sphere(); }}, |
|
lineStart: function() { var i = -1; while (++i < n) {streams[i].lineStart(); }}, |
|
lineEnd: function() { var i = -1; while (++i < n) {streams[i].lineEnd(); }}, |
|
polygonStart: function() { var i = -1; while (++i < n) {streams[i].polygonStart(); }}, |
|
polygonEnd: function() { var i = -1; while (++i < n) {streams[i].polygonEnd(); }} |
|
}; |
|
} |
|
|
|
// A composite projection for Chile, configured by default for 960×500. |
|
function transverseMercatorChile() { |
|
var cache, |
|
cacheStream, |
|
mainland = d3Geo.geoTransverseMercator().rotate([72, 37]), mainlandPoint, |
|
antarctic = d3Geo.geoStereographic().rotate([72, 0]), antarcticPoint, |
|
juanFernandez = d3Geo.geoMercator().rotate([80, 33.5]), juanFernandezPoint, |
|
pascua = d3Geo.geoMercator().rotate([110, 25]), pascuaPoint, |
|
|
|
point, pointStream = {point: function(x, y) { point = [x, y]; }}; |
|
|
|
/* |
|
var mainlandBbox = [[-75.5, -15.0], [-32, -49.0]]; |
|
var antarcticBbox = [[-91.0, -60.0], [-43.0, -90.0]]; |
|
var juanFernandezBbox = [[-81.0, -33.0], [-78.5, -34.0]]; |
|
var pascuaBbox = [[-110, -26.6], [-108.7, -27.5]]; |
|
*/ |
|
|
|
function transverseMercatorChile(coordinates) { |
|
var x = coordinates[0], y = coordinates[1]; |
|
return point = null, |
|
(mainlandPoint.point(x, y), point) || |
|
(antarcticPoint.point(x, y), point) || |
|
(juanFernandezPoint.point(x, y), point) || |
|
(pascuaPoint.point(x, y), point); |
|
} |
|
|
|
transverseMercatorChile.invert = function(coordinates) { |
|
var k = mainland.scale(), |
|
t = mainland.translate(), |
|
x = (coordinates[0] - t[0]) / k, |
|
y = (coordinates[1] - t[1]) / k; |
|
|
|
/* |
|
//How are the return values calculated: |
|
console.info("******"); |
|
var c0 = antarctic(antarcticBbox[0]); |
|
var x0 = (c0[0] - t[0]) / k; |
|
var y0 = (c0[1] - t[1]) / k; |
|
|
|
console.info("p0 antarctic", x0 + ' - ' + y0); |
|
|
|
var c1 = antarctic(antarcticBbox[1]); |
|
var x1 = (c1[0] - t[0]) / k; |
|
var y1 = (c1[1] - t[1]) / k; |
|
|
|
console.info("p1 antarctic", x1 + ' - ' + y1); |
|
|
|
c0 = juanFernandez(juanFernandezBbox[0]); |
|
x0 = (c0[0] - t[0]) / k; |
|
y0 = (c0[1] - t[1]) / k; |
|
|
|
console.info("p0 juanFernandez", x0 + ' - ' + y0); |
|
|
|
c1 = juanFernandez(juanFernandezBbox[1]); |
|
x1 = (c1[0] - t[0]) / k; |
|
y1 = (c1[1] - t[1]) / k; |
|
|
|
console.info("p1 juanFernandez", x1 + ' - ' + y1); |
|
|
|
c0 = pascua(pascuaBbox[0]); |
|
x0 = (c0[0] - t[0]) / k; |
|
y0 = (c0[1] - t[1]) / k; |
|
|
|
console.info("p0 pascua", x0 + ' - ' + y0); |
|
|
|
c1 = pascua(pascuaBbox[1]); |
|
x1 = (c1[0] - t[0]) / k; |
|
y1 = (c1[1] - t[1]) / k; |
|
|
|
console.info("p1 pascua", x1 + ' - ' + y1); |
|
*/ |
|
|
|
return (y >= 0.2582 && y< 0.32 && x >= -0.1036 && x < -0.087 ? antarctic |
|
: y >= -0.01298 && y< 0.0133 && x >= -0.11396 && x < -0.05944 ? juanFernandez |
|
: y >= 0.01539 && y< 0.03911 && x >= -0.089 && x < -0.0588 ? pascua |
|
: mainland).invert(coordinates); |
|
}; |
|
|
|
transverseMercatorChile.stream = function(stream) { |
|
return cache && cacheStream === stream ? cache : cache = multiplex$5([mainland.stream(cacheStream = stream), antarctic.stream(stream), juanFernandez.stream(stream), pascua.stream(stream)]); |
|
}; |
|
|
|
transverseMercatorChile.precision = function(_) { |
|
if (!arguments.length) {return mainland.precision();} |
|
mainland.precision(_); |
|
antarctic.precision(_); |
|
juanFernandez.precision(_); |
|
pascua.precision(_); |
|
return transverseMercatorChile; |
|
}; |
|
|
|
transverseMercatorChile.scale = function(_) { |
|
if (!arguments.length) {return mainland.scale();} |
|
mainland.scale(_); |
|
antarctic.scale(_ * 0.15); |
|
juanFernandez.scale(_ * 1.5); |
|
pascua.scale(_ * 1.5); |
|
return transverseMercatorChile.translate(mainland.translate()); |
|
}; |
|
|
|
transverseMercatorChile.translate = function(_) { |
|
if (!arguments.length) {return mainland.translate();} |
|
var k = mainland.scale(), x = +_[0], y = +_[1]; |
|
|
|
/* |
|
var c0 = mainland(mainlandBbox[0]); |
|
var x0 = (x - c0[0]) / k; |
|
var y0 = (y - c0[1]) / k; |
|
|
|
var c1 = mainland(mainlandBbox[1]); |
|
var x1 = (x - c1[0]) / k; |
|
var y1 = (y - c1[1]) / k; |
|
|
|
console.info('Mainland: p0: ' + x0 + ', ' + y0 + ' , p1: ' + x1 + ' - ' + y1); |
|
console.info('.clipExtent([[x '+ |
|
(x0<0?'+ ':'- ') + Math.abs(x0.toFixed(4))+ |
|
' * k, y '+ |
|
(y0<0?'+ ':'- ') + Math.abs(y0.toFixed(4))+ |
|
' * k],[x '+ |
|
(x1<0?'+ ':'- ') + Math.abs(x1.toFixed(4))+ |
|
' * k, y '+ |
|
(y1<0?'+ ':'- ') + Math.abs(y1.toFixed(4))+ |
|
' * k]])'); |
|
|
|
c0 = antarctic.translate([x - 0.1 * k, y + 0.17 * k])(antarcticBbox[0]); |
|
x0 = (x - c0[0]) / k; |
|
y0 = (y - c0[1]) / k; |
|
|
|
c1 = antarctic.translate([x - 0.1 * k, y + 0.17 * k])(antarcticBbox[1]); |
|
x1 = (x - c1[0]) / k; |
|
y1 = (y - c1[1]) / k; |
|
|
|
console.info('antarctic: p0: ' + x0 + ', ' + y0 + ' , p1: ' + x1 + ' - ' + y1); |
|
console.info('Doesn t work due to -90 latitude!' + '.clipExtent([[x '+ |
|
(x0<0?'+ ':'- ') + Math.abs(x0.toFixed(4))+ |
|
' * k + epsilon, y '+ |
|
(y0<0?'+ ':'- ') + Math.abs(y0.toFixed(4))+ |
|
' * k + epsilon],[x '+ |
|
(x1<0?'+ ':'- ') + Math.abs(x1.toFixed(4))+ |
|
' * k - epsilon, y '+ |
|
(y1<0?'+ ':'- ') + Math.abs(y1.toFixed(4))+ |
|
' * k - epsilon]])'); |
|
|
|
c0 = juanFernandez.translate([x - 0.092 * k, y -0 * k])(juanFernandezBbox[0]); |
|
x0 = (x - c0[0]) / k; |
|
y0 = (y - c0[1]) / k; |
|
|
|
c1 = juanFernandez.translate([x - 0.092 * k, y -0 * k])(juanFernandezBbox[1]); |
|
x1 = (x - c1[0]) / k; |
|
y1 = (y - c1[1]) / k; |
|
|
|
console.info('juanFernandez: p0: ' + x0 + ', ' + y0 + ' , p1: ' + x1 + ' - ' + y1); |
|
console.info('.clipExtent([[x '+ |
|
(x0<0?'+ ':'- ') + Math.abs(x0.toFixed(4))+ |
|
' * k + epsilon, y '+ |
|
(y0<0?'+ ':'- ') + Math.abs(y0.toFixed(4))+ |
|
' * k + epsilon],[x '+ |
|
(x1<0?'+ ':'- ') + Math.abs(x1.toFixed(4))+ |
|
' * k - epsilon, y '+ |
|
(y1<0?'+ ':'- ') + Math.abs(y1.toFixed(4))+ |
|
' * k - epsilon]])'); |
|
|
|
c0 = pascua.translate([x - 0.089 * k, y -0.0265 * k])(pascuaBbox[0]); |
|
x0 = (x - c0[0]) / k; |
|
y0 = (y - c0[1]) / k; |
|
|
|
c1 = pascua.translate([x - 0.089 * k, y -0.0265 * k])(pascuaBbox[1]); |
|
x1 = (x - c1[0]) / k; |
|
y1 = (y - c1[1]) / k; |
|
|
|
console.info('pascua: p0: ' + x0 + ', ' + y0 + ' , p1: ' + x1 + ' - ' + y1); |
|
console.info('.clipExtent([[x '+ |
|
(x0<0?'+ ':'- ') + Math.abs(x0.toFixed(4))+ |
|
' * k + epsilon, y '+ |
|
(y0<0?'+ ':'- ') + Math.abs(y0.toFixed(4))+ |
|
' * k + epsilon],[x '+ |
|
(x1<0?'+ ':'- ') + Math.abs(x1.toFixed(4))+ |
|
' * k - epsilon, y '+ |
|
(y1<0?'+ ':'- ') + Math.abs(y1.toFixed(4))+ |
|
' * k - epsilon]])'); |
|
*/ |
|
mainlandPoint = mainland |
|
.translate(_) |
|
.clipExtent([[x - 0.059 * k, y - 0.3835 * k],[x + 0.4498 * k, y + 0.3375 * k]]) |
|
.stream(pointStream); |
|
|
|
antarcticPoint = antarctic |
|
.translate([x - 0.087 * k, y + 0.17 * k]) |
|
.clipExtent([[x - 0.1166 * k + epsilon, y + 0.2582 * k + epsilon],[x - 0.06 * k - epsilon, y + 0.32 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
juanFernandezPoint = juanFernandez |
|
.translate([x - 0.092 * k, y - 0 * k]) |
|
.clipExtent([[x - 0.114 * k + epsilon, y - 0.013 * k + epsilon],[x - 0.0594 * k - epsilon, y + 0.0133 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
pascuaPoint = pascua |
|
.translate([x - 0.089 * k, y - 0.0265 * k]) |
|
.clipExtent([[x - 0.089 * k + epsilon, y + 0.0154 * k + epsilon],[x - 0.0588 * k - epsilon, y + 0.0391 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
return transverseMercatorChile; |
|
}; |
|
|
|
transverseMercatorChile.drawCompositionBorders = function(context) { |
|
/* |
|
console.info("CLIP EXTENT antarctic: ", antarctic.clipExtent()); |
|
console.info("UL BBOX:", mainland.invert([antarctic.clipExtent()[0][0], antarctic.clipExtent()[0][1]])); |
|
console.info("UR BBOX:", mainland.invert([antarctic.clipExtent()[1][0], antarctic.clipExtent()[0][1]])); |
|
console.info("LD BBOX:", mainland.invert([antarctic.clipExtent()[1][0], antarctic.clipExtent()[1][1]])); |
|
console.info("LL BBOX:", mainland.invert([antarctic.clipExtent()[0][0], antarctic.clipExtent()[1][1]])); |
|
|
|
console.info("CLIP EXTENT juanFernandez: ", juanFernandez.clipExtent()); |
|
console.info("UL BBOX:", mainland.invert([juanFernandez.clipExtent()[0][0], juanFernandez.clipExtent()[0][1]])); |
|
console.info("UR BBOX:", mainland.invert([juanFernandez.clipExtent()[1][0], juanFernandez.clipExtent()[0][1]])); |
|
console.info("LD BBOX:", mainland.invert([juanFernandez.clipExtent()[1][0], juanFernandez.clipExtent()[1][1]])); |
|
console.info("LL BBOX:", mainland.invert([juanFernandez.clipExtent()[0][0], juanFernandez.clipExtent()[1][1]])); |
|
|
|
console.info("CLIP EXTENT pascua: ", pascua.clipExtent()); |
|
console.info("UL BBOX:", mainland.invert([pascua.clipExtent()[0][0], pascua.clipExtent()[0][1]])); |
|
console.info("UR BBOX:", mainland.invert([pascua.clipExtent()[1][0], pascua.clipExtent()[0][1]])); |
|
console.info("LD BBOX:", mainland.invert([pascua.clipExtent()[1][0], pascua.clipExtent()[1][1]])); |
|
console.info("LL BBOX:", mainland.invert([pascua.clipExtent()[0][0], pascua.clipExtent()[1][1]])); |
|
*/ |
|
|
|
var ulantarctic = mainland([-82.6999, -51.3043]); |
|
var urantarctic = mainland([-77.5442, -51.6631]); |
|
var ldantarctic = mainland([-78.0254, -55.1860]); |
|
var llantarctic = mainland([-83.6106, -54.7785]); |
|
|
|
var uljuanFernandez = mainland([-80.0638, -35.9840]); |
|
var urjuanFernandez = mainland([-76.2153, -36.1811]); |
|
var ldjuanFernandez = mainland([-76.2994, -37.6839]); |
|
var lljuanFernandez = mainland([-80.2231, -37.4757]); |
|
|
|
var ulpascua = mainland([-78.442, -37.706]); |
|
var urpascua = mainland([-76.263, -37.8054]); |
|
var ldpascua = mainland([-76.344, -39.1595]); |
|
var llpascua = mainland([-78.5638, -39.0559]); |
|
|
|
context.moveTo(ulantarctic[0], ulantarctic[1]); |
|
context.lineTo(urantarctic[0], urantarctic[1]); |
|
context.lineTo(ldantarctic[0], ldantarctic[1]); |
|
context.lineTo(ldantarctic[0], ldantarctic[1]); |
|
context.lineTo(llantarctic[0], llantarctic[1]); |
|
context.closePath(); |
|
|
|
context.moveTo(uljuanFernandez[0], uljuanFernandez[1]); |
|
context.lineTo(urjuanFernandez[0], urjuanFernandez[1]); |
|
context.lineTo(ldjuanFernandez[0], ldjuanFernandez[1]); |
|
context.lineTo(ldjuanFernandez[0], ldjuanFernandez[1]); |
|
context.lineTo(lljuanFernandez[0], lljuanFernandez[1]); |
|
context.closePath(); |
|
|
|
context.moveTo(ulpascua[0], ulpascua[1]); |
|
context.lineTo(urpascua[0], urpascua[1]); |
|
context.lineTo(ldpascua[0], ldpascua[1]); |
|
context.lineTo(ldpascua[0], ldpascua[1]); |
|
context.lineTo(llpascua[0], llpascua[1]); |
|
context.closePath(); |
|
|
|
|
|
}; |
|
transverseMercatorChile.getCompositionBorders = function() { |
|
var context = d3Path.path(); |
|
this.drawCompositionBorders(context); |
|
return context.toString(); |
|
}; |
|
|
|
return transverseMercatorChile.scale(700); |
|
} |
|
|
|
// The projections must have mutually exclusive clip regions on the sphere, |
|
// as this will avoid emitting interleaving lines and polygons. |
|
function multiplex$6(streams) { |
|
var n = streams.length; |
|
return { |
|
point: function(x, y) { var i = -1; while (++i < n) {streams[i].point(x, y); }}, |
|
sphere: function() { var i = -1; while (++i < n) {streams[i].sphere(); }}, |
|
lineStart: function() { var i = -1; while (++i < n) {streams[i].lineStart(); }}, |
|
lineEnd: function() { var i = -1; while (++i < n) {streams[i].lineEnd(); }}, |
|
polygonStart: function() { var i = -1; while (++i < n) {streams[i].polygonStart(); }}, |
|
polygonEnd: function() { var i = -1; while (++i < n) {streams[i].polygonEnd(); }} |
|
}; |
|
} |
|
|
|
// A composite projection for Portugal, configured by default for 960×500. |
|
function conicEquidistantJapan() { |
|
var cache, |
|
cacheStream, |
|
mainland = d3Geo.geoConicEquidistant().rotate([-136, -22]).parallels([40, 34]), mainlandPoint, //gis.stackexchange.com/a/73135 |
|
hokkaido = d3Geo.geoConicEquidistant().rotate([-146, -26]).parallels([40, 34]), hokkaidoPoint, |
|
okinawa = d3Geo.geoConicEquidistant().rotate([-126, -19]).parallels([40, 34]), okinawaPoint, |
|
|
|
point, pointStream = {point: function(x, y) { point = [x, y]; }}; |
|
|
|
/* |
|
var mainlandBbox = [[126.0, 41.606], [142.97, 29.97]]; |
|
var hokkaidoBbox = [[138.7, 45.61], [146.2, 41.2]]; |
|
var okinawaBbox = [[122.6, 29.0], [130, 23.7]]; |
|
*/ |
|
|
|
|
|
function conicEquidistantJapan(coordinates) { |
|
var x = coordinates[0], y = coordinates[1]; |
|
return point = null, |
|
(mainlandPoint.point(x, y), point) || |
|
(hokkaidoPoint.point(x, y), point) || |
|
(okinawaPoint.point(x, y), point); |
|
} |
|
|
|
conicEquidistantJapan.invert = function(coordinates) { |
|
var k = mainland.scale(), |
|
t = mainland.translate(), |
|
x = (coordinates[0] - t[0]) / k, |
|
y = (coordinates[1] - t[1]) / k; |
|
|
|
/* |
|
//How are the return values calculated: |
|
console.info("******"); |
|
var c0 = hokkaido(hokkaidoBbox[0]); |
|
var x0 = (c0[0] - t[0]) / k; |
|
var y0 = (c0[1] - t[1]) / k; |
|
|
|
console.info("p0 hokkaido", x0 + ' - ' + y0); |
|
|
|
var c1 = hokkaido(hokkaidoBbox[1]); |
|
var x1 = (c1[0] - t[0]) / k; |
|
var y1 = (c1[1] - t[1]) / k; |
|
|
|
console.info("p1 hokkaido", x1 + ' - ' + y1); |
|
|
|
c0 = okinawa(okinawaBbox[0]); |
|
x0 = (c0[0] - t[0]) / k; |
|
y0 = (c0[1] - t[1]) / k; |
|
|
|
console.info("p0 okinawa", x0 + ' - ' + y0); |
|
|
|
c1 = okinawa(okinawaBbox[1]); |
|
x1 = (c1[0] - t[0]) / k; |
|
y1 = (c1[1] - t[1]) / k; |
|
|
|
console.info("p1 okinawa", x1 + ' - ' + y1); |
|
*/ |
|
|
|
return (y >= -0.10925 && y< -0.02701 && x >= -0.135 && x < -0.0397 ? hokkaido |
|
: y >= 0.04713 && y< 0.11138 && x >= -0.03986 && x < 0.051 ? okinawa |
|
: mainland).invert(coordinates); |
|
|
|
}; |
|
|
|
conicEquidistantJapan.stream = function(stream) { |
|
return cache && cacheStream === stream ? cache : cache = multiplex$6([mainland.stream(cacheStream = stream), hokkaido.stream(stream), okinawa.stream(stream)]); |
|
}; |
|
|
|
conicEquidistantJapan.precision = function(_) { |
|
if (!arguments.length) {return mainland.precision();} |
|
mainland.precision(_); |
|
hokkaido.precision(_); |
|
okinawa.precision(_); |
|
return conicEquidistantJapan; |
|
}; |
|
|
|
conicEquidistantJapan.scale = function(_) { |
|
if (!arguments.length) {return mainland.scale();} |
|
mainland.scale(_); |
|
hokkaido.scale(_); |
|
okinawa.scale(_ * 0.7); |
|
return conicEquidistantJapan.translate(mainland.translate()); |
|
}; |
|
|
|
conicEquidistantJapan.translate = function(_) { |
|
if (!arguments.length) {return mainland.translate();} |
|
var k = mainland.scale(), x = +_[0], y = +_[1]; |
|
|
|
/* |
|
var c0 = mainland(mainlandBbox[0]); |
|
var x0 = (x - c0[0]) / k; |
|
var y0 = (y - c0[1]) / k; |
|
|
|
var c1 = mainland(mainlandBbox[1]); |
|
var x1 = (x - c1[0]) / k; |
|
var y1 = (y - c1[1]) / k; |
|
|
|
console.info('Main: p0: ' + x0 + ', ' + y0 + ' , p1: ' + x1 + ' - ' + y1); |
|
console.info('.clipExtent([[x '+ |
|
(x0<0?'+ ':'- ') + Math.abs(x0.toFixed(4))+ |
|
' * k, y '+ |
|
(y0<0?'+ ':'- ') + Math.abs(y0.toFixed(4))+ |
|
' * k],[x '+ |
|
(x1<0?'+ ':'- ') + Math.abs(x1.toFixed(4))+ |
|
' * k, y '+ |
|
(y1<0?'+ ':'- ') + Math.abs(y1.toFixed(4))+ |
|
' * k]])'); |
|
|
|
c0 = hokkaido.translate([x - 0.0425 * k, y - 0.005 * k])(hokkaidoBbox[0]); |
|
x0 = (x - c0[0]) / k; |
|
y0 = (y - c0[1]) / k; |
|
|
|
c1 = hokkaido.translate([x - 0.0425 * k, y - 0.005 * k])(hokkaidoBbox[1]); |
|
x1 = (x - c1[0]) / k; |
|
y1 = (y - c1[1]) / k; |
|
|
|
console.info('hokkaido: p0: ' + x0 + ', ' + y0 + ' , p1: ' + x1 + ' - ' + y1); |
|
console.info('.clipExtent([[x '+ |
|
(x0<0?'+ ':'- ') + Math.abs(x0.toFixed(4))+ |
|
' * k + epsilon, y '+ |
|
(y0<0?'+ ':'- ') + Math.abs(y0.toFixed(4))+ |
|
' * k + epsilon],[x '+ |
|
(x1<0?'+ ':'- ') + Math.abs(x1.toFixed(4))+ |
|
' * k - epsilon, y '+ |
|
(y1<0?'+ ':'- ') + Math.abs(y1.toFixed(4))+ |
|
' * k - epsilon]])'); |
|
|
|
c0 = okinawa.translate([x - 0 * k, y + 0 * k])(okinawaBbox[0]); |
|
x0 = (x - c0[0]) / k; |
|
y0 = (y - c0[1]) / k; |
|
|
|
c1 = okinawa.translate([x - 0 * k, y + 0 * k])(okinawaBbox[1]); |
|
x1 = (x - c1[0]) / k; |
|
y1 = (y - c1[1]) / k; |
|
|
|
console.info('okinawa: p0: ' + x0 + ', ' + y0 + ' , p1: ' + x1 + ' - ' + y1); |
|
console.info('.clipExtent([[x '+ |
|
(x0<0?'+ ':'- ') + Math.abs(x0.toFixed(4))+ |
|
' * k + epsilon, y '+ |
|
(y0<0?'+ ':'- ') + Math.abs(y0.toFixed(4))+ |
|
' * k + epsilon],[x '+ |
|
(x1<0?'+ ':'- ') + Math.abs(x1.toFixed(4))+ |
|
' * k - epsilon, y '+ |
|
(y1<0?'+ ':'- ') + Math.abs(y1.toFixed(4))+ |
|
' * k - epsilon]])'); |
|
*/ |
|
|
|
mainlandPoint = mainland |
|
.translate(_) |
|
.clipExtent([[x - 0.1352 * k, y - 0.1091 * k],[x + 0.117 * k, y + 0.098 * k]]) |
|
.stream(pointStream); |
|
|
|
|
|
hokkaidoPoint = hokkaido |
|
.translate([x - 0.0425 * k, y - 0.005 * k]) |
|
.clipExtent([[x - 0.135 * k + epsilon, y - 0.1093 * k + epsilon],[x - 0.0397 * k - epsilon, y - 0.027 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
okinawaPoint = okinawa |
|
.translate(_) |
|
.clipExtent([[x - 0.0399 * k + epsilon, y + 0.0471 * k + epsilon],[x + 0.051 * k - epsilon, y + 0.1114 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
return conicEquidistantJapan; |
|
}; |
|
|
|
conicEquidistantJapan.drawCompositionBorders = function(context) { |
|
/* |
|
console.info("CLIP EXTENT hokkaido: ", hokkaido.clipExtent()); |
|
console.info("UL BBOX:", mainland.invert([hokkaido.clipExtent()[0][0], hokkaido.clipExtent()[0][1]])); |
|
console.info("UR BBOX:", mainland.invert([hokkaido.clipExtent()[1][0], hokkaido.clipExtent()[0][1]])); |
|
console.info("LD BBOX:", mainland.invert([hokkaido.clipExtent()[1][0], hokkaido.clipExtent()[1][1]])); |
|
console.info("LL BBOX:", mainland.invert([hokkaido.clipExtent()[0][0], hokkaido.clipExtent()[1][1]])); |
|
*/ |
|
|
|
var ulhokkaido = mainland([ 126.01320483689143, 41.621090310215585 ]); |
|
var urhokkaido = mainland([ 133.04304387025903, 42.15087523707186 ]); |
|
var ldhokkaido = mainland([ 133.3021766080688, 37.43975444725098 ]); |
|
var llhokkaido = mainland([ 126.87889168628224, 36.95488945159779 ]); |
|
|
|
var llokinawa = mainland([132.9, 29.8]); |
|
var lmokinawa = mainland([134, 33]); |
|
var lrokinawa = mainland([139.3, 33.2]); |
|
var llrokinawa = mainland([139.16, 30.5]); |
|
|
|
|
|
context.moveTo(ulhokkaido[0], ulhokkaido[1]); |
|
context.lineTo(urhokkaido[0], urhokkaido[1]); |
|
context.lineTo(ldhokkaido[0], ldhokkaido[1]); |
|
context.lineTo(llhokkaido[0], llhokkaido[1]); |
|
context.closePath(); |
|
|
|
context.moveTo(llokinawa[0], llokinawa[1]); |
|
context.lineTo(lmokinawa[0], lmokinawa[1]); |
|
context.lineTo(lrokinawa[0], lrokinawa[1]); |
|
context.lineTo(llrokinawa[0], llrokinawa[1]); |
|
|
|
}; |
|
conicEquidistantJapan.getCompositionBorders = function() { |
|
var context = d3Path.path(); |
|
this.drawCompositionBorders(context); |
|
return context.toString(); |
|
}; |
|
|
|
return conicEquidistantJapan.scale(2200); |
|
} |
|
|
|
// The projections must have mutually exclusive clip regions on the sphere, |
|
// as this will avoid emitting interleaving lines and polygons. |
|
function multiplex$7(streams) { |
|
var n = streams.length; |
|
return { |
|
point: function(x, y) { var i = -1; while (++i < n) {streams[i].point(x, y); }}, |
|
sphere: function() { var i = -1; while (++i < n) {streams[i].sphere(); }}, |
|
lineStart: function() { var i = -1; while (++i < n) {streams[i].lineStart(); }}, |
|
lineEnd: function() { var i = -1; while (++i < n) {streams[i].lineEnd(); }}, |
|
polygonStart: function() { var i = -1; while (++i < n) {streams[i].polygonStart(); }}, |
|
polygonEnd: function() { var i = -1; while (++i < n) {streams[i].polygonEnd(); }} |
|
}; |
|
} |
|
|
|
// A composite projection for Portugal, configured by default for 960×500. |
|
function conicConformalFrance() { |
|
var cache, |
|
cacheStream, |
|
europe = d3Geo.geoConicConformal().rotate([-3, -46.2]).parallels([0, 60]), europePoint, |
|
guyane = d3Geo.geoMercator().center([-53.2, 3.9]), guyanePoint, |
|
martinique = d3Geo.geoMercator().center([-61.03, 14.67]), martiniquePoint, |
|
guadeloupe = d3Geo.geoMercator().center([-61.46, 16.14]), guadeloupePoint, |
|
saintBarthlemy = d3Geo.geoMercator().center([-62.85, 17.92]), saintBarthlemyPoint, |
|
stPierreMichelon = d3Geo.geoMercator().center([-56.23, 46.93]), stPierreMichelonPoint, |
|
mayotte = d3Geo.geoMercator().center([45.16, -12.8]), mayottePoint, |
|
reunion = d3Geo.geoMercator().center([55.52, -21.13]), reunionPoint, |
|
nouvelleCaledonie = d3Geo.geoMercator().center([165.8, -21.07]), nouvelleCaledoniePoint, |
|
wallisFutuna = d3Geo.geoMercator().center([-178.1, -14.3]), wallisFutunaPoint, |
|
polynesie = d3Geo.geoMercator().center([-150.55, -17.11]), polynesiePoint, |
|
polynesie2 = d3Geo.geoMercator().center([-150.55, -17.11]), polynesie2Point, |
|
point, pointStream = {point: function(x, y) { point = [x, y]; }}; |
|
|
|
/* |
|
var europeBbox = [[-6.5, 51], [10, 41]]; |
|
var guyaneBbox = [[-54.5, 6.29], [-50.9, 1.48]]; |
|
*/ |
|
|
|
|
|
function conicConformalFrance(coordinates) { |
|
var x = coordinates[0], y = coordinates[1]; |
|
return point = null, |
|
(europePoint.point(x, y), point) || |
|
(guyanePoint.point(x, y), point) || |
|
(martiniquePoint.point(x, y), point) || |
|
(guadeloupePoint.point(x, y), point) || |
|
(saintBarthlemyPoint.point(x, y), point) || |
|
(stPierreMichelonPoint.point(x, y), point) || |
|
(mayottePoint.point(x, y), point) || |
|
(reunionPoint.point(x, y), point) || |
|
(nouvelleCaledoniePoint.point(x, y), point) || |
|
(wallisFutunaPoint.point(x, y), point) || |
|
(polynesiePoint.point(x, y), point) || |
|
(polynesie2Point.point(x, y), point); |
|
} |
|
|
|
conicConformalFrance.invert = function(coordinates) { |
|
var k = europe.scale(), |
|
t = europe.translate(), |
|
x = (coordinates[0] - t[0]) / k, |
|
y = (coordinates[1] - t[1]) / k; |
|
|
|
return (y >= 0.029 && y< 0.0864 && x >= -0.14 && x < -0.0996 ? guyane |
|
: y >= 0 && y< 0.029 && x >= -0.14 && x < -0.0996 ? martinique |
|
: y >= -0.032 && y< 0 && x >= -0.14 && x < -0.0996 ? guadeloupe |
|
: y >= -0.052 && y< -0.032 && x >= -0.14 && x < -0.0996 ? saintBarthlemy |
|
: y >= -0.076 && y< 0.052 && x >= -0.14 && x < -0.0996 ? stPierreMichelon |
|
: y >= -0.076 && y< -0.052 && x >= 0.0967 && x < 0.1371 ? mayotte |
|
: y >= -0.052 && y< -0.02 && x >= 0.0967 && x < 0.1371 ? reunion |
|
: y >= -0.02 && y< 0.012 && x >= 0.0967 && x < 0.1371 ? nouvelleCaledonie |
|
: y >= 0.012 && y< 0.033 && x >= 0.0967 && x < 0.1371 ? wallisFutuna |
|
: y >= 0.033 && y< 0.0864 && x >= 0.0967 && x < 0.1371 ? polynesie |
|
: europe).invert(coordinates); |
|
}; |
|
|
|
conicConformalFrance.stream = function(stream) { |
|
return cache && cacheStream === stream ? cache : cache = multiplex$7([europe.stream(cacheStream = stream), guyane.stream(stream), martinique.stream(stream), guadeloupe.stream(stream), saintBarthlemy.stream(stream), stPierreMichelon.stream(stream), mayotte.stream(stream), reunion.stream(stream), nouvelleCaledonie.stream(stream), wallisFutuna.stream(stream), polynesie.stream(stream), polynesie2.stream(stream)]); |
|
}; |
|
|
|
conicConformalFrance.precision = function(_) { |
|
if (!arguments.length) {return europe.precision();} |
|
europe.precision(_); |
|
guyane.precision(_); |
|
martinique.precision(_); |
|
guadeloupe.precision(_); |
|
saintBarthlemy.precision(_); |
|
stPierreMichelon.precision(_); |
|
mayotte.precision(_); |
|
reunion.precision(_); |
|
nouvelleCaledonie.precision(_); |
|
wallisFutuna.precision(_); |
|
polynesie.precision(_); |
|
polynesie2.precision(_); |
|
return conicConformalFrance; |
|
}; |
|
|
|
conicConformalFrance.scale = function(_) { |
|
if (!arguments.length) {return europe.scale();} |
|
europe.scale(_); |
|
guyane.scale(_ * 0.6); |
|
martinique.scale(_ * 1.6); |
|
guadeloupe.scale(_ * 1.4); |
|
saintBarthlemy.scale(_ * 5); |
|
stPierreMichelon.scale(_ * 1.3); |
|
mayotte.scale(_ * 1.6); |
|
reunion.scale(_ * 1.2); |
|
nouvelleCaledonie.scale(_ * 0.3); |
|
wallisFutuna.scale(_ * 2.7); |
|
polynesie.scale(_ * 0.5); |
|
polynesie2.scale(_ * 0.06); |
|
return conicConformalFrance.translate(europe.translate()); |
|
}; |
|
|
|
conicConformalFrance.translate = function(_) { |
|
if (!arguments.length) {return europe.translate();} |
|
var k = europe.scale(), x = +_[0], y = +_[1]; |
|
|
|
europePoint = europe |
|
.translate(_) |
|
.clipExtent([[x - 0.0996 * k, y - 0.0908 * k],[x + 0.0967 * k, y + 0.0864 * k]]) |
|
.stream(pointStream); |
|
|
|
|
|
guyanePoint = guyane |
|
.translate([x - 0.12 * k, y + 0.0575 * k]) |
|
.clipExtent([[x - 0.14 * k + epsilon, y + 0.029 * k + epsilon],[x - 0.0996 * k - epsilon, y + 0.0864 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
martiniquePoint = martinique |
|
.translate([x - 0.12 * k, y + 0.013 * k]) |
|
.clipExtent([[x - 0.14 * k + epsilon, y + 0 * k + epsilon],[x - 0.0996 * k - epsilon, y + 0.029 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
guadeloupePoint = guadeloupe |
|
.translate([x - 0.12 * k, y -0.014 * k]) |
|
.clipExtent([[x - 0.14 * k + epsilon, y - 0.032 * k + epsilon],[x - 0.0996 * k - epsilon, y + 0 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
saintBarthlemyPoint = saintBarthlemy |
|
.translate([x - 0.12 * k, y - 0.044 * k]) |
|
.clipExtent([[x - 0.14 * k + epsilon, y - 0.052 * k + epsilon],[x - 0.0996 * k - epsilon, y - 0.032 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
stPierreMichelonPoint = stPierreMichelon |
|
.translate([x - 0.12 * k, y - 0.065 * k]) |
|
.clipExtent([[x - 0.14 * k + epsilon, y - 0.076 * k + epsilon],[x - 0.0996 * k - epsilon, y - 0.052 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
mayottePoint = mayotte |
|
.translate([x + 0.117 * k, y - 0.064 * k]) |
|
.clipExtent([[x + 0.0967 * k + epsilon, y - 0.076 * k + epsilon],[x + 0.1371 * k - epsilon, y - 0.052 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
reunionPoint = reunion |
|
.translate([x + 0.116 * k, y - 0.0355 * k]) |
|
.clipExtent([[x + 0.0967 * k + epsilon, y - 0.052 * k + epsilon],[x + 0.1371 * k - epsilon, y - 0.02 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
nouvelleCaledoniePoint = nouvelleCaledonie |
|
.translate([x + 0.116 * k, y - 0.0048 * k]) |
|
.clipExtent([[x + 0.0967 * k + epsilon, y - 0.02 * k + epsilon],[x + 0.1371 * k - epsilon, y + 0.012 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
wallisFutunaPoint = wallisFutuna |
|
.translate([x + 0.116 * k, y + 0.022 * k]) |
|
.clipExtent([[x + 0.0967 * k + epsilon, y + 0.012 * k + epsilon],[x + 0.1371 * k - epsilon, y + 0.033 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
polynesie2Point = polynesie2 |
|
.translate([x + 0.11 * k, y + 0.045 * k]) |
|
.clipExtent([[x + 0.0967 * k + epsilon, y + 0.033 * k + epsilon],[x + 0.1371 * k - epsilon, y + 0.06 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
polynesiePoint = polynesie |
|
.translate([x + 0.115 * k, y + 0.075 * k]) |
|
.clipExtent([[x + 0.0967 * k + epsilon, y + 0.06 * k + epsilon],[x + 0.1371 * k - epsilon, y + 0.0864 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
|
|
|
|
return conicConformalFrance; |
|
}; |
|
|
|
conicConformalFrance.drawCompositionBorders = function(context) { |
|
|
|
/* |
|
console.log("var ul, ur, ld, ll;"); |
|
var projs = [guyane, martinique, guadeloupe, saintBarthlemy, stPierreMichelon, mayotte, reunion, nouvelleCaledonie, wallisFutuna, polynesie, polynesie2]; |
|
for (var i in projs){ |
|
var ul = europe.invert([projs[i].clipExtent()[0][0], projs[i].clipExtent()[0][1]]); |
|
var ur = europe.invert([projs[i].clipExtent()[1][0], projs[i].clipExtent()[0][1]]); |
|
var ld = europe.invert([projs[i].clipExtent()[1][0], projs[i].clipExtent()[1][1]]); |
|
var ll = europe.invert([projs[i].clipExtent()[0][0], projs[i].clipExtent()[1][1]]); |
|
|
|
console.log("ul = europe(["+ul+"]);"); |
|
console.log("ur = europe(["+ur+"]);"); |
|
console.log("ld = europe(["+ld+"]);"); |
|
console.log("ll = europe(["+ll+"]);"); |
|
|
|
console.log("context.moveTo(ul[0], ul[1]);"); |
|
console.log("context.lineTo(ur[0], ur[1]);"); |
|
console.log("context.lineTo(ld[0], ld[1]);"); |
|
console.log("context.lineTo(ll[0], ll[1]);"); |
|
console.log("context.closePath();"); |
|
|
|
}*/ |
|
|
|
var ul, ur, ld, ll; |
|
ul = europe([-7.938886725111036,43.7219460918835]); |
|
ur = europe([-4.832080896458295,44.12930268549372]); |
|
ld = europe([-4.205299743793263,40.98096346967365]); |
|
ll = europe([-7.071796453126152,40.610037319181444]); |
|
context.moveTo(ul[0], ul[1]); |
|
context.lineTo(ur[0], ur[1]); |
|
context.lineTo(ld[0], ld[1]); |
|
context.lineTo(ll[0], ll[1]); |
|
context.closePath(); |
|
ul = europe([-8.42751373617692,45.32889452553031]); |
|
ur = europe([-5.18599305777107,45.7566442062976]); |
|
ld = europe([-4.832080905154431,44.129302726751426]); |
|
ll = europe([-7.938886737126192,43.72194613263854]); |
|
context.moveTo(ul[0], ul[1]); |
|
context.lineTo(ur[0], ur[1]); |
|
context.lineTo(ld[0], ld[1]); |
|
context.lineTo(ll[0], ll[1]); |
|
context.closePath(); |
|
ul = europe([-9.012656899657046,47.127733821030176]); |
|
ur = europe([-5.6105244772793155,47.579777861410626]); |
|
ld = europe([-5.185993067168585,45.756644248170346]); |
|
ll = europe([-8.427513749141811,45.32889456686326]); |
|
context.moveTo(ul[0], ul[1]); |
|
context.lineTo(ur[0], ur[1]); |
|
context.lineTo(ld[0], ld[1]); |
|
context.lineTo(ll[0], ll[1]); |
|
context.closePath(); |
|
ul = europe([-9.405747558985553,48.26506375557457]); |
|
ur = europe([-5.896175018439575,48.733352850851624]); |
|
ld = europe([-5.610524487556043,47.57977790393761]); |
|
ll = europe([-9.012656913808351,47.127733862971255]); |
|
context.moveTo(ul[0], ul[1]); |
|
context.lineTo(ur[0], ur[1]); |
|
context.lineTo(ld[0], ld[1]); |
|
context.lineTo(ll[0], ll[1]); |
|
context.closePath(); |
|
ul = europe([-9.908436061346974,49.642448789505856]); |
|
ur = europe([-6.262026716233124,50.131426841787174]); |
|
ld = europe([-5.896175029331232,48.73335289377258]); |
|
ll = europe([-9.40574757396393,48.26506379787767]); |
|
context.moveTo(ul[0], ul[1]); |
|
context.lineTo(ur[0], ur[1]); |
|
context.lineTo(ld[0], ld[1]); |
|
context.lineTo(ll[0], ll[1]); |
|
context.closePath(); |
|
ul = europe([11.996907706504462,50.16039028163579]); |
|
ur = europe([15.649907879773343,49.68279246765253]); |
|
ld = europe([15.156712840526632,48.30371557625831]); |
|
ll = europe([11.64122661754411,48.761078240546816]); |
|
context.moveTo(ul[0], ul[1]); |
|
context.lineTo(ur[0], ur[1]); |
|
context.lineTo(ld[0], ld[1]); |
|
context.lineTo(ll[0], ll[1]); |
|
context.closePath(); |
|
ul = europe([11.641226606955788,48.7610781975889]); |
|
ur = europe([15.156712825832164,48.30371553390465]); |
|
ld = europe([14.549932166241172,46.4866532486199]); |
|
ll = europe([11.204443787952183,46.91899233914248]); |
|
context.moveTo(ul[0], ul[1]); |
|
context.lineTo(ur[0], ur[1]); |
|
context.lineTo(ld[0], ld[1]); |
|
context.lineTo(ll[0], ll[1]); |
|
context.closePath(); |
|
ul = europe([11.204443778297161,46.918992296823646]); |
|
ur = europe([14.549932152815039,46.486653206856396]); |
|
ld = europe([13.994409796764009,44.695833444323256]); |
|
ll = europe([10.805306599253848,45.105133870684924]); |
|
context.moveTo(ul[0], ul[1]); |
|
context.lineTo(ur[0], ur[1]); |
|
context.lineTo(ld[0], ld[1]); |
|
context.lineTo(ll[0], ll[1]); |
|
context.closePath(); |
|
ul = europe([10.805306590412085,45.10513382903308]); |
|
ur = europe([13.99440978444733,44.695833403183606]); |
|
ld = europe([13.654633799024392,43.53552468558152]); |
|
ll = europe([10.561516803980956,43.930671459798624]); |
|
context.moveTo(ul[0], ul[1]); |
|
context.lineTo(ur[0], ur[1]); |
|
context.lineTo(ld[0], ld[1]); |
|
context.lineTo(ll[0], ll[1]); |
|
context.closePath(); |
|
|
|
ul = europe([10.561516795617383,43.93067141859757]); |
|
ur = europe([13.654633787361952,43.5355246448671]); |
|
ld = europe([12.867691604239901,40.640701985019405]); |
|
ll = europe([9.997809515987688,41.00288343254471]); |
|
context.moveTo(ul[0], ul[1]); |
|
context.lineTo(ur[0], ur[1]); |
|
context.lineTo(ld[0], ld[1]); |
|
context.lineTo(ll[0], ll[1]); |
|
context.closePath(); |
|
|
|
ul = europe([10.8,42.4]); |
|
ur = europe([12.8,42.13]); |
|
context.moveTo(ul[0], ul[1]); |
|
context.lineTo(ur[0], ur[1]); |
|
|
|
}; |
|
conicConformalFrance.getCompositionBorders = function() { |
|
var context = d3Path.path(); |
|
this.drawCompositionBorders(context); |
|
return context.toString(); |
|
}; |
|
|
|
return conicConformalFrance.scale(2700); |
|
} |
|
|
|
// The projections must have mutually exclusive clip regions on the sphere, |
|
// as this will avoid emitting interleaving lines and polygons. |
|
function multiplex$8(streams) { |
|
var n = streams.length; |
|
return { |
|
point: function(x, y) { var i = -1; while (++i < n) {streams[i].point(x, y); }}, |
|
sphere: function() { var i = -1; while (++i < n) {streams[i].sphere(); }}, |
|
lineStart: function() { var i = -1; while (++i < n) {streams[i].lineStart(); }}, |
|
lineEnd: function() { var i = -1; while (++i < n) {streams[i].lineEnd(); }}, |
|
polygonStart: function() { var i = -1; while (++i < n) {streams[i].polygonStart(); }}, |
|
polygonEnd: function() { var i = -1; while (++i < n) {streams[i].polygonEnd(); }} |
|
}; |
|
} |
|
|
|
// A composite projection for Portugal, configured by default for 960×500. |
|
function conicConformalEurope() { |
|
var cache, |
|
cacheStream, |
|
europe = d3Geo.geoConicConformal().rotate([-10, -53]).parallels([0, 60]), europePoint, |
|
guadeloupe = d3Geo.geoMercator().center([-61.46, 16.14]), guadeloupePoint, |
|
guyane = d3Geo.geoMercator().center([-53.2, 3.9]), guyanePoint, |
|
azores = d3Geo.geoConicConformal().rotate([27.8, -38.9]).parallels([0, 60]), azoresPoint, |
|
azores2 = d3Geo.geoConicConformal().rotate([25.43, -37.398]).parallels([0, 60]), azores2Point, |
|
azores3 = d3Geo.geoConicConformal().rotate([31.17, -39.539]).parallels([0, 60]), azores3Point, |
|
madeira = d3Geo.geoConicConformal().rotate([17, -32.7]).parallels([0, 60]), madeiraPoint, |
|
canaryIslands = d3Geo.geoConicConformal().rotate([16, -28.5]).parallels([0,60]), canaryIslandsPoint, |
|
martinique = d3Geo.geoMercator().center([-61.03, 14.67]), martiniquePoint, |
|
mayotte = d3Geo.geoMercator().center([45.16, -12.8]), mayottePoint, |
|
reunion = d3Geo.geoMercator().center([55.52, -21.13]), reunionPoint, |
|
malta = d3Geo.geoConicConformal().rotate([-14.4, -35.95]).parallels([0, 60]), maltaPoint, |
|
|
|
|
|
|
|
|
|
|
|
point, pointStream = {point: function(x, y) { point = [x, y]; }}; |
|
|
|
/* |
|
var europeBbox = [[-6.5, 51], [10, 41]]; |
|
var guyaneBbox = [[-54.5, 6.29], [-50.9, 1.48]]; |
|
*/ |
|
|
|
|
|
function conicConformalEurope(coordinates) { |
|
var x = coordinates[0], y = coordinates[1]; |
|
return point = null, |
|
(europePoint.point(x, y), point) || |
|
(guyanePoint.point(x, y), point) || |
|
(martiniquePoint.point(x, y), point) || |
|
(guadeloupePoint.point(x, y), point) || |
|
(canaryIslandsPoint.point(x, y), point) || |
|
(madeiraPoint.point(x, y), point) || |
|
(mayottePoint.point(x, y), point) || |
|
(reunionPoint.point(x, y), point) || |
|
(maltaPoint.point(x, y), point) || |
|
(azoresPoint.point(x, y), point) || |
|
(azores2Point.point(x, y), point) || |
|
(azores3Point.point(x, y), point); |
|
} |
|
|
|
conicConformalEurope.invert = function(coordinates) { |
|
var k = europe.scale(), |
|
t = europe.translate(), |
|
x = (coordinates[0] - (t[0] + 0.08 * k)) / k, |
|
y = (coordinates[1] - t[1]) / k; |
|
|
|
return (y >= -0.31 && y< -0.24 && x >= 0.14 && x < 0.24 ? guadeloupe |
|
: y >= -0.24 && y< -0.17 && x >= 0.14 && x < 0.24 ? guyane |
|
: y >= -0.17 && y< -0.12 && x >= 0.21 && x < 0.24 ? azores2 |
|
: y >= -0.17 && y< -0.14 && x >= 0.14 && x < 0.165 ? azores3 |
|
: y >= -0.17 && y< -0.1 && x >= 0.14 && x < 0.24 ? azores |
|
: y >= -0.1 && y< -0.03 && x >= 0.14 && x < 0.24 ? madeira |
|
: y >= -0.03 && y< 0.04 && x >= 0.14 && x < 0.24 ? canaryIslands |
|
: y >= -0.31 && y< -0.24 && x >= 0.24 && x < 0.34 ? martinique |
|
: y >= -0.24 && y< -0.17 && x >= 0.24 && x < 0.34 ? mayotte |
|
: y >= -0.17 && y< -0.1 && x >= 0.24 && x < 0.34 ? reunion |
|
: y >= -0.1 && y< -0.03 && x >= 0.24 && x < 0.34 ? malta |
|
: europe).invert(coordinates); |
|
|
|
}; |
|
|
|
conicConformalEurope.stream = function(stream) { |
|
return cache && cacheStream === stream ? cache : cache = multiplex$8([europe.stream(cacheStream = stream), guyane.stream(stream), martinique.stream(stream), guadeloupe.stream(stream), canaryIslands.stream(stream), madeira.stream(stream), mayotte.stream(stream), reunion.stream(stream), malta.stream(stream), azores.stream(stream), azores2.stream(stream), azores3.stream(stream)]); |
|
}; |
|
|
|
conicConformalEurope.precision = function(_) { |
|
if (!arguments.length) {return europe.precision();} |
|
europe.precision(_); |
|
guyane.precision(_); |
|
martinique.precision(_); |
|
guadeloupe.precision(_); |
|
canaryIslands.precision(_); |
|
madeira.precision(_); |
|
mayotte.precision(_); |
|
reunion.precision(_); |
|
malta.precision(_); |
|
|
|
azores.precision(_); |
|
azores2.precision(_); |
|
azores3.precision(_); |
|
return conicConformalEurope; |
|
}; |
|
|
|
conicConformalEurope.scale = function(_) { |
|
if (!arguments.length) {return europe.scale();} |
|
europe.scale(_); |
|
guadeloupe.scale(_ * 3); |
|
guyane.scale(_ * 0.8); |
|
martinique.scale(_ * 3.5); |
|
reunion.scale(_ * 2.7); |
|
azores.scale(_ * 2); |
|
azores2.scale(_ * 2); |
|
azores3.scale(_ * 2); |
|
madeira.scale(_ * 3); |
|
canaryIslands.scale(_); |
|
|
|
mayotte.scale(_ * 5.5); |
|
malta.scale(_ * 6); |
|
|
|
|
|
|
|
return conicConformalEurope.translate(europe.translate()); |
|
}; |
|
|
|
conicConformalEurope.translate = function(_) { |
|
if (!arguments.length) {return europe.translate();} |
|
var k = europe.scale(), x = +_[0], y = +_[1]; |
|
|
|
europePoint = europe |
|
.translate([x - 0.08 * k, y]) |
|
.clipExtent([[x - 0.51 * k, y - 0.33 * k],[x + 0.5 * k, y + 0.33 * k]]) |
|
.stream(pointStream); |
|
|
|
guadeloupePoint = guadeloupe |
|
.translate([x + 0.19 * k, y - 0.275 * k]) |
|
.clipExtent([[x + 0.14 * k + epsilon, y - 0.31 * k + epsilon],[x + 0.24 * k - epsilon, y - 0.24 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
guyanePoint = guyane |
|
.translate([x + 0.19 * k, y - 0.205 * k]) |
|
.clipExtent([[x + 0.14 * k + epsilon, y - 0.24 * k + epsilon],[x + 0.24 * k - epsilon, y - 0.17 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
azoresPoint = azores |
|
.translate([x + 0.19 * k, y - 0.135 * k]) |
|
.clipExtent([[x + 0.14 * k + epsilon, y - 0.17 * k + epsilon],[x + 0.24 * k - epsilon, y - 0.1 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
azores2Point = azores2 |
|
.translate([x + 0.225 * k, y - 0.147 * k]) |
|
.clipExtent([[x + 0.21 * k + epsilon, y - 0.17 * k + epsilon],[x + 0.24 * k - epsilon, y - 0.12 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
azores3Point = azores3 |
|
.translate([x + 0.153 * k, y - 0.15 * k]) |
|
.clipExtent([[x + 0.14 * k + epsilon, y - 0.17 * k + epsilon],[x + 0.165 * k - epsilon, y - 0.14 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
madeiraPoint = madeira |
|
.translate([x + 0.19 * k, y - 0.065 * k]) |
|
.clipExtent([[x + 0.14 * k + epsilon, y - 0.1 * k + epsilon],[x + 0.24 * k - epsilon, y - 0.03 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
canaryIslandsPoint = canaryIslands |
|
.translate([x + 0.19 * k, y + 0.005 * k]) |
|
.clipExtent([[x + 0.14 * k + epsilon, y - 0.03 * k + epsilon],[x + 0.24 * k - epsilon, y + 0.04 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
martiniquePoint = martinique |
|
.translate([x + 0.29 * k, y - 0.275 * k]) |
|
.clipExtent([[x + 0.24 * k + epsilon, y - 0.31 * k + epsilon],[x + 0.34 * k - epsilon, y - 0.24 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
mayottePoint = mayotte |
|
.translate([x + 0.29 * k, y - 0.205 * k]) |
|
.clipExtent([[x + 0.24 * k + epsilon, y - 0.24 * k + epsilon],[x + 0.34 * k - epsilon, y - 0.17 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
reunionPoint = reunion |
|
.translate([x + 0.29 * k, y - 0.135 * k]) |
|
.clipExtent([[x + 0.24 * k + epsilon, y - 0.17 * k + epsilon],[x + 0.34 * k - epsilon, y - 0.1 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
maltaPoint = malta |
|
.translate([x + 0.29 * k, y - 0.065 * k]) |
|
.clipExtent([[x + 0.24 * k + epsilon, y - 0.1 * k + epsilon],[x + 0.34 * k - epsilon, y - 0.03 * k - epsilon]]) |
|
.stream(pointStream); |
|
|
|
|
|
|
|
return conicConformalEurope; |
|
}; |
|
|
|
conicConformalEurope.drawCompositionBorders = function(context) { |
|
|
|
/* |
|
console.log("var ul, ur, ld, ll;"); |
|
var projs = [guyane, martinique, guadeloupe, canaryIslands, madeira, mayotte, reunion, malta, azores, azores2, azores3]; |
|
for (var i in projs){ |
|
var ul = europe.invert([projs[i].clipExtent()[0][0], projs[i].clipExtent()[0][1]]); |
|
var ur = europe.invert([projs[i].clipExtent()[1][0], projs[i].clipExtent()[0][1]]); |
|
var ld = europe.invert([projs[i].clipExtent()[1][0], projs[i].clipExtent()[1][1]]); |
|
var ll = europe.invert([projs[i].clipExtent()[0][0], projs[i].clipExtent()[1][1]]); |
|
|
|
console.log("ul = europe(["+ul+"]);"); |
|
console.log("ur = europe(["+ur+"]);"); |
|
console.log("ld = europe(["+ld+"]);"); |
|
console.log("ll = europe(["+ll+"]);"); |
|
|
|
console.log("context.moveTo(ul[0], ul[1]);"); |
|
console.log("context.lineTo(ur[0], ur[1]);"); |
|
console.log("context.lineTo(ld[0], ld[1]);"); |
|
console.log("context.lineTo(ll[0], ll[1]);"); |
|
console.log("context.closePath();"); |
|
|
|
}*/ |
|
|
|
var ul, ur, ld, ll; |
|
ul = europe([42.45755610828648,63.343658547914934]); |
|
ur = europe([52.65837266667029,59.35045080290929]); |
|
ld = europe([47.19754502247785,56.12653496548117]); |
|
ll = europe([37.673034273363044,59.61638268506111]); |
|
context.moveTo(ul[0], ul[1]); |
|
context.lineTo(ur[0], ur[1]); |
|
context.lineTo(ld[0], ld[1]); |
|
context.lineTo(ll[0], ll[1]); |
|
context.closePath(); |
|
ul = europe([59.41110754003403,62.35069727399336]); |
|
ur = europe([66.75050228640794,57.11797303636038]); |
|
ld = europe([60.236065725110436,54.63331433818992]); |
|
ll = europe([52.65837313153311,59.350450804599355]); |
|
context.moveTo(ul[0], ul[1]); |
|
context.lineTo(ur[0], ur[1]); |
|
context.lineTo(ld[0], ld[1]); |
|
context.lineTo(ll[0], ll[1]); |
|
context.closePath(); |
|
ul = europe([48.81091130080243,66.93353402634641]); |
|
ur = europe([59.41110730654679,62.35069740653086]); |
|
ld = europe([52.6583728974441,59.3504509222445]); |
|
ll = europe([42.45755631675751,63.34365868805821]); |
|
context.moveTo(ul[0], ul[1]); |
|
context.lineTo(ur[0], ur[1]); |
|
context.lineTo(ld[0], ld[1]); |
|
context.lineTo(ll[0], ll[1]); |
|
context.closePath(); |
|
ul = europe([31.054198418446475,52.1080673766184]); |
|
ur = europe([39.09869284884117,49.400700047190554]); |
|
ld = europe([36.0580811499175,46.02944174908498]); |
|
ll = europe([28.690508588835726,48.433126979386415]); |
|
context.moveTo(ul[0], ul[1]); |
|
context.lineTo(ur[0], ur[1]); |
|
context.lineTo(ld[0], ld[1]); |
|
context.lineTo(ll[0], ll[1]); |
|
context.closePath(); |
|
ul = europe([33.977877745912025,55.849945501331]); |
|
ur = europe([42.75328432167726,52.78455122462353]); |
|
ld = europe([39.09869297540224,49.400700176148625]); |
|
ll = europe([31.05419851807008,52.10806751810923]); |
|
context.moveTo(ul[0], ul[1]); |
|
context.lineTo(ur[0], ur[1]); |
|
context.lineTo(ld[0], ld[1]); |
|
context.lineTo(ll[0], ll[1]); |
|
context.closePath(); |
|
ul = europe([52.658372900759296,59.35045068526415]); |
|
ur = europe([60.23606549583304,54.63331423800264]); |
|
ld = europe([54.6756370953122,51.892298789399455]); |
|
ll = europe([47.19754524788189,56.126534861222794]); |
|
context.moveTo(ul[0], ul[1]); |
|
context.lineTo(ur[0], ur[1]); |
|
context.lineTo(ld[0], ld[1]); |
|
context.lineTo(ll[0], ll[1]); |
|
context.closePath(); |
|
ul = europe([47.19754506082455,56.126534735591456]); |
|
ur = europe([54.675636900123514,51.892298681337095]); |
|
ld = europe([49.94448648951486,48.98775484983285]); |
|
ll = europe([42.75328468716108,52.78455126060818]); |
|
context.moveTo(ul[0], ul[1]); |
|
context.lineTo(ur[0], ur[1]); |
|
context.lineTo(ld[0], ld[1]); |
|
context.lineTo(ll[0], ll[1]); |
|
context.closePath(); |
|
ul = europe([42.75328453416769,52.78455113209101]); |
|
ur = europe([49.94448632339758,48.98775473706457]); |
|
ld = europe([45.912339990394315,45.99361784987003]); |
|
ll = europe([39.09869317356607,49.40070009378711]); |
|
context.moveTo(ul[0], ul[1]); |
|
context.lineTo(ur[0], ur[1]); |
|
context.lineTo(ld[0], ld[1]); |
|
context.lineTo(ll[0], ll[1]); |
|
context.closePath(); |
|
ul = europe([37.673034114296634,59.61638254183119]); |
|
ur = europe([47.197544835420544,56.126534839849846]); |
|
ld = europe([42.75328447467064,52.78455135314068]); |
|
ll = europe([33.977877870363905,55.849945644671145]); |
|
context.moveTo(ul[0], ul[1]); |
|
context.lineTo(ur[0], ur[1]); |
|
context.lineTo(ld[0], ld[1]); |
|
context.lineTo(ll[0], ll[1]); |
|
context.closePath(); |
|
ul = europe([44.56748486446032,57.26489367845818]); |
|
ld = europe([43.9335791193588,53.746540942601726]); |
|
ll = europe([43,56]); |
|
context.moveTo(ul[0], ul[1]); |
|
context.lineTo(ur[0], ur[1]); |
|
context.lineTo(ld[0], ld[1]); |
|
context.lineTo(ll[0], ll[1]); |
|
context.closePath(); |
|
ul = europe([37.673034114296634,59.61638254183119]); |
|
ur = europe([40.25902691953466,58.83002044222639]); |
|
ld = europe([38.458270492742024,57.26232178028002]); |
|
ll = europe([35.97754948030156,58.00266637992386]); |
|
context.moveTo(ul[0], ul[1]); |
|
context.lineTo(ur[0], ur[1]); |
|
context.lineTo(ld[0], ld[1]); |
|
context.lineTo(ll[0], ll[1]); |
|
context.closePath(); |
|
|
|
|
|
|
|
}; |
|
conicConformalEurope.getCompositionBorders = function() { |
|
var context = d3Path.path(); |
|
this.drawCompositionBorders(context); |
|
return context.toString(); |
|
}; |
|
|
|
return conicConformalEurope.scale(750); |
|
} |
|
|
|
exports.geoAlbersUsa = albersUsa; |
|
exports.geoAlbersUsaTerritories = albersUsaTerritories; |
|
exports.geoConicConformalSpain = conicConformalSpain; |
|
exports.geoConicConformalPortugal = conicConformalPortugal; |
|
exports.geoMercatorEcuador = mercatorEcuador; |
|
exports.geoTransverseMercatorChile = transverseMercatorChile; |
|
exports.geoConicEquidistantJapan = conicEquidistantJapan; |
|
exports.geoConicConformalFrance = conicConformalFrance; |
|
exports.geoConicConformalEurope = conicConformalEurope; |
|
|
|
Object.defineProperty(exports, '__esModule', { value: true }); |
|
|
|
})); |
|
},{"d3-geo":6,"d3-path":12}],6:[function(require,module,exports){ |
|
// https://d3js.org/d3-geo/ Version 1.2.4. Copyright 2016 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) : |
|
(factory((global.d3 = global.d3 || {}),global.d3)); |
|
}(this, (function (exports,d3Array) { 'use strict'; |
|
|
|
// Adds floating point numbers with twice the normal precision. |
|
// Reference: J. R. Shewchuk, Adaptive Precision Floating-Point Arithmetic and |
|
// Fast Robust Geometric Predicates, Discrete & Computational Geometry 18(3) |
|
// 305–363 (1997). |
|
// Code adapted from GeographicLib by Charles F. F. Karney, |
|
// http://geographiclib.sourceforge.net/ |
|
|
|
function adder() { |
|
return new Adder; |
|
} |
|
|
|
function Adder() { |
|
this.reset(); |
|
} |
|
|
|
Adder.prototype = { |
|
constructor: Adder, |
|
reset: function() { |
|
this.s = // rounded value |
|
this.t = 0; // exact error |
|
}, |
|
add: function(y) { |
|
add(temp, y, this.t); |
|
add(this, temp.s, this.s); |
|
if (this.s) this.t += temp.t; |
|
else this.s = temp.t; |
|
}, |
|
valueOf: function() { |
|
return this.s; |
|
} |
|
}; |
|
|
|
var temp = new Adder; |
|
|
|
function add(adder, a, b) { |
|
var x = adder.s = a + b, |
|
bv = x - a, |
|
av = x - bv; |
|
adder.t = (a - av) + (b - bv); |
|
} |
|
|
|
var epsilon = 1e-6; |
|
var epsilon2 = 1e-12; |
|
var pi = Math.PI; |
|
var halfPi = pi / 2; |
|
var quarterPi = pi / 4; |
|
var tau = pi * 2; |
|
|
|
var degrees = 180 / pi; |
|
var radians = pi / 180; |
|
|
|
var abs = Math.abs; |
|
var atan = Math.atan; |
|
var atan2 = Math.atan2; |
|
var cos = Math.cos; |
|
var ceil = Math.ceil; |
|
var exp = Math.exp; |
|
var log = Math.log; |
|
var pow = Math.pow; |
|
var sin = Math.sin; |
|
var sign = Math.sign || function(x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }; |
|
var sqrt = Math.sqrt; |
|
var tan = Math.tan; |
|
|
|
function acos(x) { |
|
return x > 1 ? 0 : x < -1 ? pi : Math.acos(x); |
|
} |
|
|
|
function asin(x) { |
|
return x > 1 ? halfPi : x < -1 ? -halfPi : Math.asin(x); |
|
} |
|
|
|
function haversin(x) { |
|
return (x = sin(x / 2)) * x; |
|
} |
|
|
|
function noop() {} |
|
|
|
function streamGeometry(geometry, stream) { |
|
if (geometry && streamGeometryType.hasOwnProperty(geometry.type)) { |
|
streamGeometryType[geometry.type](geometry, stream); |
|
} |
|
} |
|
|
|
var streamObjectType = { |
|
Feature: function(feature, stream) { |
|
streamGeometry(feature.geometry, stream); |
|
}, |
|
FeatureCollection: function(object, stream) { |
|
var features = object.features, i = -1, n = features.length; |
|
while (++i < n) streamGeometry(features[i].geometry, stream); |
|
} |
|
}; |
|
|
|
var streamGeometryType = { |
|
Sphere: function(object, stream) { |
|
stream.sphere(); |
|
}, |
|
Point: function(object, stream) { |
|
object = object.coordinates; |
|
stream.point(object[0], object[1], object[2]); |
|
}, |
|
MultiPoint: function(object, stream) { |
|
var coordinates = object.coordinates, i = -1, n = coordinates.length; |
|
while (++i < n) object = coordinates[i], stream.point(object[0], object[1], object[2]); |
|
}, |
|
LineString: function(object, stream) { |
|
streamLine(object.coordinates, stream, 0); |
|
}, |
|
MultiLineString: function(object, stream) { |
|
var coordinates = object.coordinates, i = -1, n = coordinates.length; |
|
while (++i < n) streamLine(coordinates[i], stream, 0); |
|
}, |
|
Polygon: function(object, stream) { |
|
streamPolygon(object.coordinates, stream); |
|
}, |
|
MultiPolygon: function(object, stream) { |
|
var coordinates = object.coordinates, i = -1, n = coordinates.length; |
|