covutils
Version:
Utilities for creating, transforming, and handling Coverage Data objects.
302 lines (266 loc) • 8.73 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
exports.fromDomain = fromDomain;
exports.fromXndarray = fromXndarray;
exports.addSubsetFunctions = addSubsetFunctions;
exports.addLoadRangesFunction = addLoadRangesFunction;
var _constants = require('../constants.js');
var _validate = require('../validate.js');
var _subset = require('./subset.js');
function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
/**
* Wraps a Domain into a Coverage object by adding dummy parameter and range data.
*
* @param {Domain} domain the Domain object
* @param {array} [options.gridAxes] The horizontal grid axis names, used for checkerboard pattern.
* @return {Coverage}
*/
function fromDomain(domain) {
var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
(0, _validate.checkDomain)(domain);
var _options$gridAxes = options.gridAxes;
_options$gridAxes = _options$gridAxes === undefined ? ['x', 'y'] : _options$gridAxes;
var _options$gridAxes2 = _slicedToArray(_options$gridAxes, 2);
var x = _options$gridAxes2[0];
var y = _options$gridAxes2[1];
var dummyKey = 'domain';
var dummyLabel = 'Domain';
var assumeGrid = domain.axes.has(x) && domain.axes.has(y) && (domain.axes.get(x).values.length > 1 || domain.axes.get(y).values.length > 1);
var categories = void 0;
var categoryEncoding = void 0;
var a = 'a';
var av = 0;
var b = 'b';
var bv = 1;
if (assumeGrid) {
categories = [{
id: a,
label: { en: 'A' }
}, {
id: b,
label: { en: 'B' }
}];
categoryEncoding = new Map([[a, [av]], [b, [bv]]]);
} else {
categories = [{
id: a,
label: { en: 'X' }
}];
categoryEncoding = new Map([[a, [av]]]);
}
var parameters = new Map();
parameters.set(dummyKey, {
key: dummyKey,
observedProperty: {
label: { en: dummyLabel },
categories: categories
},
categoryEncoding: categoryEncoding
});
var shape = new Map([].concat(_toConsumableArray(domain.axes)).map(function (_ref) {
var _ref2 = _slicedToArray(_ref, 2);
var name = _ref2[0];
var axis = _ref2[1];
return [name, axis.values.length];
}));
var get = void 0;
if (assumeGrid) {
(function () {
// checkerboard pattern to see grid cells
var isOdd = function isOdd(n) {
return n % 2;
};
get = function get(_ref3) {
var _ref3$x = _ref3.x;
var x = _ref3$x === undefined ? 0 : _ref3$x;
var _ref3$y = _ref3.y;
var y = _ref3$y === undefined ? 0 : _ref3$y;
return isOdd(x + y) ? av : bv;
};
})();
} else {
get = function get() {
return av;
};
}
var loadRange = function loadRange() {
return Promise.resolve({
shape: shape,
dataType: 'integer',
get: get
});
};
var cov = {
type: _constants.COVERAGE,
domainType: domain.domainType,
parameters: parameters,
loadDomain: function loadDomain() {
return Promise.resolve(domain);
},
loadRange: loadRange
};
addLoadRangesFunction(cov);
addSubsetFunctions(cov);
return cov;
}
/**
* Creates a Coverage with a single parameter from an xndarray object.
*
* @example
* var arr = xndarray(new Float64Array(
* [ 1,2,3,
* 4,5,6 ]), {
* shape: [2,3],
* names: ['y','x'],
* coords: {
* y: [10,12,14],
* x: [100,101,102],
* t: [new Date('2001-01-01')]
* }
* })
* var cov = CovUtils.fromXndarray(arr, {
* parameter: {
* key: 'temperature',
* observedProperty: {
* label: {en: 'Air temperature'}
* },
* unit: { symbol: '°C' }
* }
* })
* let param = cov.parameters.get('temperature')
* let unit = param.unit.symbol // °C
* cov.loadRange('temperature').then(temps => {
* let val = temps.get({x:0, y:1}) // val == 4
* })
*
* @param {xndarray} xndarr - Coordinates must be primitive, not tuples etc.
* @param {object} [options] Options object.
* @param {Parameter} [options.parameter] Specifies the parameter, default parameter has a key of 'p1'.
* @param {string} [options.domainType] A domain type URI.
* @param {Array<object>} [options.referencing] Optional referencing system info,
* defaults to longitude/latitude in WGS84 for x/y axes and ISO8601 time strings for t axis.
* @return {Coverage}
*/
function fromXndarray(xndarr) {
var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
var _options$parameter = options.parameter;
var parameter = _options$parameter === undefined ? {
key: 'p1',
observedProperty: {
label: { en: 'Parameter 1' }
}
} : _options$parameter;
var referencing = options.referencing;
var domainType = options.domainType;
var parameters = new Map();
parameters.set(parameter.key, parameter);
// assume lon/lat/ISO time for x/y/t by default, for convenience
if (!referencing) {
referencing = [];
if (xndarr.coords.has('x') && xndarr.coords.has('y')) {
referencing.push({
coordinates: ['x', 'y'],
system: {
type: 'GeographicCRS',
id: 'http://www.opengis.net/def/crs/OGC/1.3/CRS84'
}
});
}
if (xndarr.coords.has('t')) {
referencing.push({
coordinates: ['t'],
system: {
type: 'TemporalRS',
calendar: 'Gregorian'
}
});
}
}
var axes = new Map();
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = xndarr.coords[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var _step$value = _slicedToArray(_step.value, 2);
var axisName = _step$value[0];
var vals1Dnd = _step$value[1];
var values = new Array(vals1Dnd.size);
for (var i = 0; i < vals1Dnd.size; i++) {
values[i] = vals1Dnd.get(i);
}
axes.set(axisName, {
key: axisName,
coordinates: [axisName],
values: values
});
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
var domain = {
type: _constants.DOMAIN,
domainType: domainType,
referencing: referencing,
axes: axes
};
var shape = new Map([].concat(_toConsumableArray(domain.axes)).map(function (_ref4) {
var _ref5 = _slicedToArray(_ref4, 2);
var name = _ref5[0];
var axis = _ref5[1];
return [name, axis.values.length];
}));
var dataType = xndarr.dtype.indexOf('int') !== -1 ? 'integer' : 'float';
var loadRange = function loadRange() {
return Promise.resolve({
shape: shape,
dataType: dataType,
get: xndarr.xget.bind(xndarr)
});
};
var cov = {
type: _constants.COVERAGE,
domainType: domainType,
parameters: parameters,
loadDomain: function loadDomain() {
return Promise.resolve(domain);
},
loadRange: loadRange
};
addLoadRangesFunction(cov);
addSubsetFunctions(cov);
return cov;
}
function addSubsetFunctions(cov) {
(0, _validate.checkCoverage)(cov);
cov.subsetByIndex = _subset.subsetByIndex.bind(null, cov);
cov.subsetByValue = _subset.subsetByValue.bind(null, cov);
}
function addLoadRangesFunction(cov) {
(0, _validate.checkCoverage)(cov);
function loadRanges(keys) {
if (!keys) {
keys = cov.parameters.keys();
}
return Promise.all([].concat(_toConsumableArray(keys)).map(cov.loadRange)).then(function (ranges) {
return new Map(keys.map(function (key, i) {
return [key, ranges[i]];
}));
});
}
cov.loadRanges = loadRanges;
}