@deck.gl/geo-layers/dist/es5/tile-layer/tileset-2d.js

deck.gl layers supporting geospatial use cases and GIS formats

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = exports.STRATEGY_DEFAULT = exports.STRATEGY_REPLACE = exports.STRATEGY_NEVER = void 0;

var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _tile2dHeader = _interopRequireDefault(require("./tile-2d-header"));

var _utils = require("./utils");

var _loaderUtils = require("@loaders.gl/loader-utils");

var _core = require("@math.gl/core");

var _STRATEGIES;

function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var TILE_STATE_VISITED = 1;
var TILE_STATE_VISIBLE = 2;
var STRATEGY_NEVER = 'never';
exports.STRATEGY_NEVER = STRATEGY_NEVER;
var STRATEGY_REPLACE = 'no-overlap';
exports.STRATEGY_REPLACE = STRATEGY_REPLACE;
var STRATEGY_DEFAULT = 'best-available';
exports.STRATEGY_DEFAULT = STRATEGY_DEFAULT;
var DEFAULT_CACHE_SCALE = 5;
var STRATEGIES = (_STRATEGIES = {}, (0, _defineProperty2.default)(_STRATEGIES, STRATEGY_DEFAULT, updateTileStateDefault), (0, _defineProperty2.default)(_STRATEGIES, STRATEGY_REPLACE, updateTileStateReplace), (0, _defineProperty2.default)(_STRATEGIES, STRATEGY_NEVER, function () {}), _STRATEGIES);

var Tileset2D = function () {
  function Tileset2D(opts) {
    var _this = this;

    (0, _classCallCheck2.default)(this, Tileset2D);
    this.opts = opts;

    this.onTileLoad = function (tile) {
      _this.opts.onTileLoad(tile);

      if (_this.opts.maxCacheByteSize) {
        _this._cacheByteSize += tile.byteLength;

        _this._resizeCache();
      }
    };

    this._requestScheduler = new _loaderUtils.RequestScheduler({
      maxRequests: opts.maxRequests,
      throttleRequests: opts.maxRequests > 0
    });
    this._cache = new Map();
    this._tiles = [];
    this._dirty = false;
    this._cacheByteSize = 0;
    this._viewport = null;
    this._selectedTiles = null;
    this._frameNumber = 0;
    this._modelMatrix = new _core.Matrix4();
    this._modelMatrixInverse = new _core.Matrix4();
    this.setOptions(opts);
  }

  (0, _createClass2.default)(Tileset2D, [{
    key: "tiles",
    get: function get() {
      return this._tiles;
    }
  }, {
    key: "selectedTiles",
    get: function get() {
      return this._selectedTiles;
    }
  }, {
    key: "isLoaded",
    get: function get() {
      return this._selectedTiles.every(function (tile) {
        return tile.isLoaded;
      });
    }
  }, {
    key: "needsReload",
    get: function get() {
      return this._selectedTiles.some(function (tile) {
        return tile.needsReload;
      });
    }
  }, {
    key: "setOptions",
    value: function setOptions(opts) {
      Object.assign(this.opts, opts);

      if (Number.isFinite(opts.maxZoom)) {
        this._maxZoom = Math.floor(opts.maxZoom);
      }

      if (Number.isFinite(opts.minZoom)) {
        this._minZoom = Math.ceil(opts.minZoom);
      }
    }
  }, {
    key: "finalize",
    value: function finalize() {
      var _iterator = _createForOfIteratorHelper(this._cache.values()),
          _step;

      try {
        for (_iterator.s(); !(_step = _iterator.n()).done;) {
          var tile = _step.value;

          if (tile.isLoading) {
            tile.abort();
          }
        }
      } catch (err) {
        _iterator.e(err);
      } finally {
        _iterator.f();
      }

      this._cache.clear();

      this._tiles = [];
      this._selectedTiles = null;
    }
  }, {
    key: "reloadAll",
    value: function reloadAll() {
      var _iterator2 = _createForOfIteratorHelper(this._cache.keys()),
          _step2;

      try {
        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
          var tileId = _step2.value;

          var tile = this._cache.get(tileId);

          if (!this._selectedTiles.includes(tile)) {
            this._cache.delete(tileId);
          } else {
            tile.setNeedsReload();
          }
        }
      } catch (err) {
        _iterator2.e(err);
      } finally {
        _iterator2.f();
      }
    }
  }, {
    key: "update",
    value: function update(viewport) {
      var _this2 = this;

      var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
          zRange = _ref.zRange,
          modelMatrix = _ref.modelMatrix;

      var modelMatrixAsMatrix4 = new _core.Matrix4(modelMatrix);
      var isModelMatrixNew = !modelMatrixAsMatrix4.equals(this._modelMatrix);

      if (!viewport.equals(this._viewport) || isModelMatrixNew) {
        if (isModelMatrixNew) {
          this._modelMatrixInverse = modelMatrixAsMatrix4.clone().invert();
          this._modelMatrix = modelMatrixAsMatrix4;
        }

        this._viewport = viewport;
        var tileIndices = this.getTileIndices({
          viewport: viewport,
          maxZoom: this._maxZoom,
          minZoom: this._minZoom,
          zRange: zRange,
          modelMatrix: this._modelMatrix,
          modelMatrixInverse: this._modelMatrixInverse
        });
        this._selectedTiles = tileIndices.map(function (index) {
          return _this2._getTile(index, true);
        });

        if (this._dirty) {
          this._rebuildTree();
        }
      } else if (this.needsReload) {
        this._selectedTiles = this._selectedTiles.map(function (tile) {
          return _this2._getTile({
            x: tile.x,
            y: tile.y,
            z: tile.z
          });
        });
      }

      var changed = this.updateTileStates();

      this._pruneRequests();

      if (this._dirty) {
        this._resizeCache();
      }

      if (changed) {
        this._frameNumber++;
      }

      return this._frameNumber;
    }
  }, {
    key: "getTileIndices",
    value: function getTileIndices(_ref2) {
      var viewport = _ref2.viewport,
          maxZoom = _ref2.maxZoom,
          minZoom = _ref2.minZoom,
          zRange = _ref2.zRange,
          modelMatrix = _ref2.modelMatrix,
          modelMatrixInverse = _ref2.modelMatrixInverse;
      var _this$opts = this.opts,
          tileSize = _this$opts.tileSize,
          extent = _this$opts.extent,
          zoomOffset = _this$opts.zoomOffset;
      return (0, _utils.getTileIndices)({
        viewport: viewport,
        maxZoom: maxZoom,
        minZoom: minZoom,
        zRange: zRange,
        tileSize: tileSize,
        extent: extent,
        modelMatrix: modelMatrix,
        modelMatrixInverse: modelMatrixInverse,
        zoomOffset: zoomOffset
      });
    }
  }, {
    key: "getTileMetadata",
    value: function getTileMetadata(_ref3) {
      var x = _ref3.x,
          y = _ref3.y,
          z = _ref3.z;
      var tileSize = this.opts.tileSize;
      return {
        bbox: (0, _utils.tileToBoundingBox)(this._viewport, x, y, z, tileSize)
      };
    }
  }, {
    key: "getParentIndex",
    value: function getParentIndex(tileIndex) {
      tileIndex.x = Math.floor(tileIndex.x / 2);
      tileIndex.y = Math.floor(tileIndex.y / 2);
      tileIndex.z -= 1;
      return tileIndex;
    }
  }, {
    key: "updateTileStates",
    value: function updateTileStates() {
      var refinementStrategy = this.opts.refinementStrategy || STRATEGY_DEFAULT;
      var visibilities = new Array(this._cache.size);
      var i = 0;

      var _iterator3 = _createForOfIteratorHelper(this._cache.values()),
          _step3;

      try {
        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
          var tile = _step3.value;
          visibilities[i++] = tile.isVisible;
          tile.isSelected = false;
          tile.isVisible = false;
        }
      } catch (err) {
        _iterator3.e(err);
      } finally {
        _iterator3.f();
      }

      var _iterator4 = _createForOfIteratorHelper(this._selectedTiles),
          _step4;

      try {
        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
          var _tile = _step4.value;
          _tile.isSelected = true;
          _tile.isVisible = true;
        }
      } catch (err) {
        _iterator4.e(err);
      } finally {
        _iterator4.f();
      }

      (typeof refinementStrategy === 'function' ? refinementStrategy : STRATEGIES[refinementStrategy])(Array.from(this._cache.values()));
      i = 0;

      var _iterator5 = _createForOfIteratorHelper(this._cache.values()),
          _step5;

      try {
        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
          var _tile2 = _step5.value;

          if (visibilities[i++] !== _tile2.isVisible) {
            return true;
          }
        }
      } catch (err) {
        _iterator5.e(err);
      } finally {
        _iterator5.f();
      }

      return false;
    }
  }, {
    key: "_pruneRequests",
    value: function _pruneRequests() {
      var maxRequests = this.opts.maxRequests;
      var abortCandidates = [];
      var ongoingRequestCount = 0;

      var _iterator6 = _createForOfIteratorHelper(this._cache.values()),
          _step6;

      try {
        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
          var _tile3 = _step6.value;

          if (_tile3.isLoading) {
            ongoingRequestCount++;

            if (!_tile3.isSelected && !_tile3.isVisible) {
              abortCandidates.push(_tile3);
            }
          }
        }
      } catch (err) {
        _iterator6.e(err);
      } finally {
        _iterator6.f();
      }

      while (maxRequests > 0 && ongoingRequestCount > maxRequests && abortCandidates.length > 0) {
        var tile = abortCandidates.shift();
        tile.abort();
        ongoingRequestCount--;
      }
    }
  }, {
    key: "_rebuildTree",
    value: function _rebuildTree() {
      var _cache = this._cache;

      var _iterator7 = _createForOfIteratorHelper(_cache.values()),
          _step7;

      try {
        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
          var tile = _step7.value;
          tile.parent = null;
          tile.children.length = 0;
        }
      } catch (err) {
        _iterator7.e(err);
      } finally {
        _iterator7.f();
      }

      var _iterator8 = _createForOfIteratorHelper(_cache.values()),
          _step8;

      try {
        for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
          var _tile4 = _step8.value;

          var parent = this._getNearestAncestor(_tile4.x, _tile4.y, _tile4.z);

          _tile4.parent = parent;

          if (parent) {
            parent.children.push(_tile4);
          }
        }
      } catch (err) {
        _iterator8.e(err);
      } finally {
        _iterator8.f();
      }
    }
  }, {
    key: "_resizeCache",
    value: function _resizeCache() {
      var _cache = this._cache,
          opts = this.opts;
      var maxCacheSize = opts.maxCacheSize || (opts.maxCacheByteSize ? Infinity : DEFAULT_CACHE_SCALE * this.selectedTiles.length);
      var maxCacheByteSize = opts.maxCacheByteSize || Infinity;
      var overflown = _cache.size > maxCacheSize || this._cacheByteSize > maxCacheByteSize;

      if (overflown) {
        var _iterator9 = _createForOfIteratorHelper(_cache),
            _step9;

        try {
          for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
            var _step9$value = (0, _slicedToArray2.default)(_step9.value, 2),
                tileId = _step9$value[0],
                tile = _step9$value[1];

            if (!tile.isVisible) {
              this._cacheByteSize -= opts.maxCacheByteSize ? tile.byteLength : 0;

              _cache.delete(tileId);

              this.opts.onTileUnload(tile);
            }

            if (_cache.size <= maxCacheSize && this._cacheByteSize <= maxCacheByteSize) {
              break;
            }
          }
        } catch (err) {
          _iterator9.e(err);
        } finally {
          _iterator9.f();
        }

        this._rebuildTree();

        this._dirty = true;
      }

      if (this._dirty) {
        this._tiles = Array.from(this._cache.values()).sort(function (t1, t2) {
          return t1.z - t2.z;
        });
        this._dirty = false;
      }
    }
  }, {
    key: "_getTile",
    value: function _getTile(_ref4, create) {
      var x = _ref4.x,
          y = _ref4.y,
          z = _ref4.z;
      var tileId = "".concat(x, ",").concat(y, ",").concat(z);

      var tile = this._cache.get(tileId);

      var needsReload = false;

      if (!tile && create) {
        tile = new _tile2dHeader.default({
          x: x,
          y: y,
          z: z
        });
        Object.assign(tile, this.getTileMetadata(tile));
        needsReload = true;

        this._cache.set(tileId, tile);

        this._dirty = true;
      } else if (tile && tile.needsReload) {
        needsReload = true;
      }

      if (needsReload) {
        tile.loadData({
          getData: this.opts.getTileData,
          requestScheduler: this._requestScheduler,
          onLoad: this.onTileLoad,
          onError: this.opts.onTileError
        });
      }

      return tile;
    }
  }, {
    key: "_getNearestAncestor",
    value: function _getNearestAncestor(x, y, z) {
      var _this$_minZoom = this._minZoom,
          _minZoom = _this$_minZoom === void 0 ? 0 : _this$_minZoom;

      var index = {
        x: x,
        y: y,
        z: z
      };

      while (index.z > _minZoom) {
        index = this.getParentIndex(index);

        var parent = this._getTile(index);

        if (parent) {
          return parent;
        }
      }

      return null;
    }
  }]);
  return Tileset2D;
}();

exports.default = Tileset2D;

function updateTileStateDefault(allTiles) {
  var _iterator10 = _createForOfIteratorHelper(allTiles),
      _step10;

  try {
    for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
      var tile = _step10.value;
      tile.state = 0;
    }
  } catch (err) {
    _iterator10.e(err);
  } finally {
    _iterator10.f();
  }

  var _iterator11 = _createForOfIteratorHelper(allTiles),
      _step11;

  try {
    for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
      var _tile5 = _step11.value;

      if (_tile5.isSelected && !getPlaceholderInAncestors(_tile5)) {
        getPlaceholderInChildren(_tile5);
      }
    }
  } catch (err) {
    _iterator11.e(err);
  } finally {
    _iterator11.f();
  }

  var _iterator12 = _createForOfIteratorHelper(allTiles),
      _step12;

  try {
    for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
      var _tile6 = _step12.value;
      _tile6.isVisible = Boolean(_tile6.state & TILE_STATE_VISIBLE);
    }
  } catch (err) {
    _iterator12.e(err);
  } finally {
    _iterator12.f();
  }
}

function updateTileStateReplace(allTiles) {
  var _iterator13 = _createForOfIteratorHelper(allTiles),
      _step13;

  try {
    for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
      var tile = _step13.value;
      tile.state = 0;
    }
  } catch (err) {
    _iterator13.e(err);
  } finally {
    _iterator13.f();
  }

  var _iterator14 = _createForOfIteratorHelper(allTiles),
      _step14;

  try {
    for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
      var _tile7 = _step14.value;

      if (_tile7.isSelected) {
        getPlaceholderInAncestors(_tile7);
      }
    }
  } catch (err) {
    _iterator14.e(err);
  } finally {
    _iterator14.f();
  }

  var sortedTiles = Array.from(allTiles).sort(function (t1, t2) {
    return t1.z - t2.z;
  });

  var _iterator15 = _createForOfIteratorHelper(sortedTiles),
      _step15;

  try {
    for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {
      var _tile8 = _step15.value;
      _tile8.isVisible = Boolean(_tile8.state & TILE_STATE_VISIBLE);

      if (_tile8.isVisible || _tile8.state & TILE_STATE_VISITED) {
        var _iterator16 = _createForOfIteratorHelper(_tile8.children),
            _step16;

        try {
          for (_iterator16.s(); !(_step16 = _iterator16.n()).done;) {
            var child = _step16.value;
            child.state = TILE_STATE_VISITED;
          }
        } catch (err) {
          _iterator16.e(err);
        } finally {
          _iterator16.f();
        }
      } else if (_tile8.isSelected) {
        getPlaceholderInChildren(_tile8);
      }
    }
  } catch (err) {
    _iterator15.e(err);
  } finally {
    _iterator15.f();
  }
}

function getPlaceholderInAncestors(tile) {
  while (tile) {
    if (tile.isLoaded || tile.content) {
      tile.state |= TILE_STATE_VISIBLE;
      return true;
    }

    tile = tile.parent;
  }

  return false;
}

function getPlaceholderInChildren(tile) {
  var _iterator17 = _createForOfIteratorHelper(tile.children),
      _step17;

  try {
    for (_iterator17.s(); !(_step17 = _iterator17.n()).done;) {
      var child = _step17.value;

      if (child.isLoaded || child.content) {
        child.state |= TILE_STATE_VISIBLE;
      } else {
        getPlaceholderInChildren(child);
      }
    }
  } catch (err) {
    _iterator17.e(err);
  } finally {
    _iterator17.f();
  }
}
//# sourceMappingURL=tileset-2d.js.map