covutils/lib/coverage/transform-polygon.js

'use strict';

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.maskByPolygon = maskByPolygon;

var _ndarray = require('ndarray');

var _ndarray2 = _interopRequireDefault(_ndarray);

var _transform = require('./transform.js');

var _validate = require('../validate.js');

var _polygon = require('../domain/polygon.js');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Returns a copy of the given Coverage object where the
 * range values which belong to domain areas outside the
 * given polygon are returned as null (no data).
 *
 * @param {Coverage} cov A Coverage object.
 * @param {Object} polygon A GeoJSON Polygon or MultiPolygon object.
 * @param {array} [axes=['x','y']] The grid axes corresponding to the polygon coordinates.
 * @returns {Promise<Coverage>}
 */
function maskByPolygon(cov, polygon) {
  var axes = arguments.length <= 2 || arguments[2] === undefined ? ['x', 'y'] : arguments[2];

  (0, _validate.checkCoverage)(cov);

  if (polygon.type === 'Polygon') {
    polygon = {
      type: 'MultiPolygon',
      coordinates: [polygon.coordinates]
    };
  }
  // prepare polygon coordinates for point-in-big-polygon algorithm
  var polygons = polygon.coordinates; // .map(poly => poly.map(loop => loop.slice(0, loop.length - 1)))
  polygons.forEach(function (p) {
    return (0, _polygon.ensureClockwisePolygon)(p);
  });

  var pip = (0, _polygon.getPointInPolygonsFn)(polygons);

  var _axes = _slicedToArray(axes, 2);

  var X = _axes[0];
  var Y = _axes[1];


  return cov.loadDomain().then(function (domain) {
    var x = domain.axes.get(X).values;
    var y = domain.axes.get(Y).values;
    var pnpolyCache = (0, _ndarray2.default)(new Uint8Array(x.length * y.length), [x.length, y.length]);

    for (var i = 0; i < x.length; i++) {
      for (var j = 0; j < y.length; j++) {
        var inside = pip([x[i], y[j]]) >= 0;
        pnpolyCache.set(i, j, inside);
      }
    }

    var fn = function fn(obj, range) {
      if (pnpolyCache.get(obj[X] || 0, obj[Y] || 0)) {
        return range.get(obj);
      } else {
        return null;
      }
    };

    var newcov = cov;
    var _iteratorNormalCompletion = true;
    var _didIteratorError = false;
    var _iteratorError = undefined;

    try {
      for (var _iterator = cov.parameters.keys()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
        var key = _step.value;

        newcov = (0, _transform.mapRange)(newcov, key, fn);
      }
    } catch (err) {
      _didIteratorError = true;
      _iteratorError = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion && _iterator.return) {
          _iterator.return();
        }
      } finally {
        if (_didIteratorError) {
          throw _iteratorError;
        }
      }
    }

    return newcov;
  });
}