@loaders.gl/tile-converter 3.0.13 → 3.0.14

package/dist/es5/3d-tiles-converter/3d-tiles-converter.js

@@ -7,6 +7,16 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+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 _path = require("path");
@@ -37,10 +47,21 @@ var _b3dmConverter = _interopRequireDefault(require("./helpers/b3dm-converter"))
 
 var _coordinateConverter = require("../i3s-converter/helpers/coordinate-converter");
 
-const I3S = 'I3S';
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+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; } } }; }
 
-class Tiles3DConverter {
-  constructor() {
+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 I3S = 'I3S';
+
+var Tiles3DConverter = function () {
+  function Tiles3DConverter() {
+    (0, _classCallCheck2.default)(this, Tiles3DConverter);
     (0, _defineProperty2.default)(this, "options", void 0);
     (0, _defineProperty2.default)(this, "tilesetPath", void 0);
     (0, _defineProperty2.default)(this, "vertexCounter", void 0);
@@ -57,205 +78,422 @@ class Tiles3DConverter {
     this.attributeStorageInfo = null;
   }
 
-  async convert(options) {
-    const {
-      inputUrl,
-      outputPath,
-      tilesetName,
-      maxDepth,
-      egmFilePath
-    } = options;
-    this.conversionStartTime = _process.default.hrtime();
-    this.options = {
-      maxDepth
-    };
-    console.log('Loading egm file...');
-    this.geoidHeightModel = await (0, _core.load)(egmFilePath, _pgmLoader.PGMLoader);
-    console.log('Loading egm file completed!');
-    const sourceTilesetJson = await (0, _core.load)(inputUrl, _i3s.I3SLoader, {});
-    this.sourceTileset = new _tiles.Tileset3D(sourceTilesetJson, {});
-
-    if (!this.sourceTileset.root.header.obb) {
-      this.sourceTileset.root.header.obb = (0, _coordinateConverter.createObbFromMbs)(this.sourceTileset.root.header.mbs);
-    }
-
-    this.tilesetPath = (0, _path.join)("".concat(outputPath), "".concat(tilesetName));
-    this.attributeStorageInfo = sourceTilesetJson.attributeStorageInfo;
-
-    try {
-      await (0, _fileUtils.removeDir)(this.tilesetPath);
-    } catch (e) {}
-
-    const rootTile = {
-      boundingVolume: {
-        box: (0, _i3sObbTo3dTilesObb.i3sObbTo3dTilesObb)(this.sourceTileset.root.header.obb, this.geoidHeightModel)
-      },
-      geometricError: (0, _lodConversionUtils.convertScreenThresholdToGeometricError)(this.sourceTileset.root),
-      children: []
-    };
-    await this._addChildren(this.sourceTileset.root, rootTile, 1);
-    const tileset = (0, _jsonMapTransform.default)({
-      root: rootTile
-    }, _tileset.TILESET);
-    await (0, _fileUtils.writeFile)(this.tilesetPath, JSON.stringify(tileset), 'tileset.json');
-
-    this._finishConversion({
-      slpk: false,
-      outputPath,
-      tilesetName
-    });
-  }
-
-  async _addChildren(parentSourceNode, parentNode, level) {
-    if (this.options.maxDepth && level > this.options.maxDepth) {
-      return;
-    }
-
-    for (const childNodeInfo of parentSourceNode.header.children || []) {
-      const sourceChild = await this._loadChildNode(parentSourceNode, childNodeInfo);
-      parentSourceNode.children.push(sourceChild);
-
-      if (sourceChild.contentUrl) {
-        await this.sourceTileset._loadTile(sourceChild);
-        this.vertexCounter += sourceChild.content.vertexCount;
-        let attributes = null;
-
-        if (this.attributeStorageInfo) {
-          attributes = await this._loadChildAttributes(sourceChild, this.attributeStorageInfo);
-        }
-
-        if (!sourceChild.header.obb) {
-          sourceChild.header.obb = (0, _coordinateConverter.createObbFromMbs)(sourceChild.header.mbs);
-        }
-
-        const boundingVolume = {
-          box: (0, _i3sObbTo3dTilesObb.i3sObbTo3dTilesObb)(sourceChild.header.obb, this.geoidHeightModel)
-        };
-        const child = {
-          boundingVolume,
-          geometricError: (0, _lodConversionUtils.convertScreenThresholdToGeometricError)(sourceChild),
-          children: []
-        };
-        const b3dm = await new _b3dmConverter.default().convert(sourceChild, attributes);
-        child.content = {
-          uri: "".concat(sourceChild.id, ".b3dm"),
-          boundingVolume
-        };
-        await (0, _fileUtils.writeFile)(this.tilesetPath, new Uint8Array(b3dm), "".concat(sourceChild.id, ".b3dm"));
-        parentNode.children.push(child);
-        sourceChild.unloadContent();
-        await this._addChildren(sourceChild, child, level + 1);
-      } else {
-        await this._addChildren(sourceChild, parentNode, level + 1);
+  (0, _createClass2.default)(Tiles3DConverter, [{
+    key: "convert",
+    value: function () {
+      var _convert = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(options) {
+        var inputUrl, outputPath, tilesetName, maxDepth, egmFilePath, sourceTilesetJson, rootTile, tileset;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                inputUrl = options.inputUrl, outputPath = options.outputPath, tilesetName = options.tilesetName, maxDepth = options.maxDepth, egmFilePath = options.egmFilePath;
+                this.conversionStartTime = _process.default.hrtime();
+                this.options = {
+                  maxDepth: maxDepth
+                };
+                console.log('Loading egm file...');
+                _context.next = 6;
+                return (0, _core.load)(egmFilePath, _pgmLoader.PGMLoader);
+
+              case 6:
+                this.geoidHeightModel = _context.sent;
+                console.log('Loading egm file completed!');
+                _context.next = 10;
+                return (0, _core.load)(inputUrl, _i3s.I3SLoader, {});
+
+              case 10:
+                sourceTilesetJson = _context.sent;
+                this.sourceTileset = new _tiles.Tileset3D(sourceTilesetJson, {});
+
+                if (!this.sourceTileset.root.header.obb) {
+                  this.sourceTileset.root.header.obb = (0, _coordinateConverter.createObbFromMbs)(this.sourceTileset.root.header.mbs);
+                }
+
+                this.tilesetPath = (0, _path.join)("".concat(outputPath), "".concat(tilesetName));
+                this.attributeStorageInfo = sourceTilesetJson.attributeStorageInfo;
+                _context.prev = 15;
+                _context.next = 18;
+                return (0, _fileUtils.removeDir)(this.tilesetPath);
+
+              case 18:
+                _context.next = 22;
+                break;
+
+              case 20:
+                _context.prev = 20;
+                _context.t0 = _context["catch"](15);
+
+              case 22:
+                rootTile = {
+                  boundingVolume: {
+                    box: (0, _i3sObbTo3dTilesObb.i3sObbTo3dTilesObb)(this.sourceTileset.root.header.obb, this.geoidHeightModel)
+                  },
+                  geometricError: (0, _lodConversionUtils.convertScreenThresholdToGeometricError)(this.sourceTileset.root),
+                  children: []
+                };
+                _context.next = 25;
+                return this._addChildren(this.sourceTileset.root, rootTile, 1);
+
+              case 25:
+                tileset = (0, _jsonMapTransform.default)({
+                  root: rootTile
+                }, _tileset.TILESET);
+                _context.next = 28;
+                return (0, _fileUtils.writeFile)(this.tilesetPath, JSON.stringify(tileset), 'tileset.json');
+
+              case 28:
+                this._finishConversion({
+                  slpk: false,
+                  outputPath: outputPath,
+                  tilesetName: tilesetName
+                });
+
+              case 29:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this, [[15, 20]]);
+      }));
+
+      function convert(_x) {
+        return _convert.apply(this, arguments);
       }
-    }
-  }
-
-  async _loadChildNode(parentNode, childNodeInfo) {
-    let header;
 
-    if (this.sourceTileset.tileset.nodePages) {
-      console.log("Node conversion: ".concat(childNodeInfo.id));
-      header = await this.sourceTileset.tileset.nodePagesTile.formTileFromNodePages(childNodeInfo.id);
-    } else {
-      const {
-        loader
-      } = this.sourceTileset;
+      return convert;
+    }()
+  }, {
+    key: "_addChildren",
+    value: function () {
+      var _addChildren2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(parentSourceNode, parentNode, level) {
+        var _iterator, _step, childNodeInfo, sourceChild, attributes, boundingVolume, child, b3dm;
+
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                if (!(this.options.maxDepth && level > this.options.maxDepth)) {
+                  _context2.next = 2;
+                  break;
+                }
+
+                return _context2.abrupt("return");
+
+              case 2:
+                _iterator = _createForOfIteratorHelper(parentSourceNode.header.children || []);
+                _context2.prev = 3;
+
+                _iterator.s();
+
+              case 5:
+                if ((_step = _iterator.n()).done) {
+                  _context2.next = 39;
+                  break;
+                }
+
+                childNodeInfo = _step.value;
+                _context2.next = 9;
+                return this._loadChildNode(parentSourceNode, childNodeInfo);
+
+              case 9:
+                sourceChild = _context2.sent;
+                parentSourceNode.children.push(sourceChild);
+
+                if (!sourceChild.contentUrl) {
+                  _context2.next = 35;
+                  break;
+                }
+
+                _context2.next = 14;
+                return this.sourceTileset._loadTile(sourceChild);
+
+              case 14:
+                this.vertexCounter += sourceChild.content.vertexCount;
+                attributes = null;
+
+                if (!this.attributeStorageInfo) {
+                  _context2.next = 20;
+                  break;
+                }
+
+                _context2.next = 19;
+                return this._loadChildAttributes(sourceChild, this.attributeStorageInfo);
+
+              case 19:
+                attributes = _context2.sent;
+
+              case 20:
+                if (!sourceChild.header.obb) {
+                  sourceChild.header.obb = (0, _coordinateConverter.createObbFromMbs)(sourceChild.header.mbs);
+                }
+
+                boundingVolume = {
+                  box: (0, _i3sObbTo3dTilesObb.i3sObbTo3dTilesObb)(sourceChild.header.obb, this.geoidHeightModel)
+                };
+                child = {
+                  boundingVolume: boundingVolume,
+                  geometricError: (0, _lodConversionUtils.convertScreenThresholdToGeometricError)(sourceChild),
+                  children: []
+                };
+                _context2.next = 25;
+                return new _b3dmConverter.default().convert(sourceChild, attributes);
+
+              case 25:
+                b3dm = _context2.sent;
+                child.content = {
+                  uri: "".concat(sourceChild.id, ".b3dm"),
+                  boundingVolume: boundingVolume
+                };
+                _context2.next = 29;
+                return (0, _fileUtils.writeFile)(this.tilesetPath, new Uint8Array(b3dm), "".concat(sourceChild.id, ".b3dm"));
+
+              case 29:
+                parentNode.children.push(child);
+                sourceChild.unloadContent();
+                _context2.next = 33;
+                return this._addChildren(sourceChild, child, level + 1);
+
+              case 33:
+                _context2.next = 37;
+                break;
+
+              case 35:
+                _context2.next = 37;
+                return this._addChildren(sourceChild, parentNode, level + 1);
+
+              case 37:
+                _context2.next = 5;
+                break;
+
+              case 39:
+                _context2.next = 44;
+                break;
+
+              case 41:
+                _context2.prev = 41;
+                _context2.t0 = _context2["catch"](3);
+
+                _iterator.e(_context2.t0);
+
+              case 44:
+                _context2.prev = 44;
+
+                _iterator.f();
+
+                return _context2.finish(44);
+
+              case 47:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this, [[3, 41, 44, 47]]);
+      }));
+
+      function _addChildren(_x2, _x3, _x4) {
+        return _addChildren2.apply(this, arguments);
+      }
 
-      const nodeUrl = this._relativeUrlToFullUrl(parentNode.url, childNodeInfo.href);
+      return _addChildren;
+    }()
+  }, {
+    key: "_loadChildNode",
+    value: function () {
+      var _loadChildNode2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee3(parentNode, childNodeInfo) {
+        var header, loader, nodeUrl, options;
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                if (!this.sourceTileset.tileset.nodePages) {
+                  _context3.next = 7;
+                  break;
+                }
+
+                console.log("Node conversion: ".concat(childNodeInfo.id));
+                _context3.next = 4;
+                return this.sourceTileset.tileset.nodePagesTile.formTileFromNodePages(childNodeInfo.id);
+
+              case 4:
+                header = _context3.sent;
+                _context3.next = 14;
+                break;
+
+              case 7:
+                loader = this.sourceTileset.loader;
+                nodeUrl = this._relativeUrlToFullUrl(parentNode.url, childNodeInfo.href);
+                options = {
+                  i3s: _objectSpread(_objectSpread({}, this.sourceTileset.loadOptions), {}, {
+                    isTileHeader: true,
+                    loadContent: false
+                  })
+                };
+                console.log("Node conversion: ".concat(nodeUrl));
+                _context3.next = 13;
+                return (0, _core.load)(nodeUrl, loader, options);
+
+              case 13:
+                header = _context3.sent;
+
+              case 14:
+                return _context3.abrupt("return", new _tiles.Tile3D(this.sourceTileset, header, parentNode));
+
+              case 15:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      function _loadChildNode(_x5, _x6) {
+        return _loadChildNode2.apply(this, arguments);
+      }
 
-      const options = {
-        i3s: { ...this.sourceTileset.loadOptions,
-          isTileHeader: true,
-          loadContent: false
-        }
-      };
-      console.log("Node conversion: ".concat(nodeUrl));
-      header = await (0, _core.load)(nodeUrl, loader, options);
-    }
+      return _loadChildNode;
+    }()
+  }, {
+    key: "_relativeUrlToFullUrl",
+    value: function _relativeUrlToFullUrl(baseUrl, relativeUrl) {
+      var resultArray = baseUrl.split('/');
+      var relativeUrlArray = relativeUrl.split('/');
 
-    return new _tiles.Tile3D(this.sourceTileset, header, parentNode);
-  }
+      var _iterator2 = _createForOfIteratorHelper(relativeUrlArray),
+          _step2;
 
-  _relativeUrlToFullUrl(baseUrl, relativeUrl) {
-    let resultArray = baseUrl.split('/');
-    const relativeUrlArray = relativeUrl.split('/');
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var folder = _step2.value;
 
-    for (const folder of relativeUrlArray) {
-      switch (folder) {
-        case '.':
-          continue;
+          switch (folder) {
+            case '.':
+              continue;
 
-        case '..':
-          resultArray = resultArray.slice(0, -1);
-          break;
+            case '..':
+              resultArray = resultArray.slice(0, -1);
+              break;
 
-        default:
-          resultArray.push(folder);
+            default:
+              resultArray.push(folder);
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
       }
-    }
 
-    return resultArray.join('/');
-  }
-
-  async _loadChildAttributes(sourceChild, attributeStorageInfo) {
-    const promises = [];
-    const {
-      attributeUrls
-    } = sourceChild.header;
-
-    for (let index = 0; index < attributeUrls.length; index++) {
-      const inputUrl = attributeUrls[index];
-      const attribute = attributeStorageInfo[index];
-      const options = {
-        attributeName: attribute.name,
-        attributeType: this._getAttributeType(attribute)
-      };
-      promises.push((0, _core.load)(inputUrl, _i3s.I3SAttributeLoader, options));
+      return resultArray.join('/');
     }
+  }, {
+    key: "_loadChildAttributes",
+    value: function () {
+      var _loadChildAttributes2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee4(sourceChild, attributeStorageInfo) {
+        var promises, attributeUrls, index, inputUrl, attribute, options, attributesList;
+        return _regenerator.default.wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                promises = [];
+                attributeUrls = sourceChild.header.attributeUrls;
+
+                for (index = 0; index < attributeUrls.length; index++) {
+                  inputUrl = attributeUrls[index];
+                  attribute = attributeStorageInfo[index];
+                  options = {
+                    attributeName: attribute.name,
+                    attributeType: this._getAttributeType(attribute)
+                  };
+                  promises.push((0, _core.load)(inputUrl, _i3s.I3SAttributeLoader, options));
+                }
+
+                _context4.next = 5;
+                return Promise.all(promises);
+
+              case 5:
+                attributesList = _context4.sent;
+
+                this._replaceNestedArrays(attributesList);
+
+                return _context4.abrupt("return", Object.assign.apply(Object, [{}].concat((0, _toConsumableArray2.default)(attributesList))));
+
+              case 8:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this);
+      }));
+
+      function _loadChildAttributes(_x7, _x8) {
+        return _loadChildAttributes2.apply(this, arguments);
+      }
 
-    const attributesList = await Promise.all(promises);
-
-    this._replaceNestedArrays(attributesList);
-
-    return Object.assign({}, ...attributesList);
-  }
+      return _loadChildAttributes;
+    }()
+  }, {
+    key: "_getAttributeType",
+    value: function _getAttributeType(attribute) {
+      if (attribute.attributeValues) {
+        return attribute.attributeValues.valueType;
+      } else if (attribute.objectIds) {
+        return 'Oid32';
+      }
 
-  _getAttributeType(attribute) {
-    if (attribute.attributeValues) {
-      return attribute.attributeValues.valueType;
-    } else if (attribute.objectIds) {
-      return 'Oid32';
+      return '';
     }
-
-    return '';
-  }
-
-  _replaceNestedArrays(attributesList) {
-    for (let index = 0; index < attributesList.length; index++) {
-      const attributeObject = attributesList[index];
-
-      for (const key in attributeObject) {
-        attributeObject[key] = Array.from(attributeObject[key]);
+  }, {
+    key: "_replaceNestedArrays",
+    value: function _replaceNestedArrays(attributesList) {
+      for (var index = 0; index < attributesList.length; index++) {
+        var attributeObject = attributesList[index];
+
+        for (var key in attributeObject) {
+          attributeObject[key] = Array.from(attributeObject[key]);
+        }
       }
     }
-  }
-
-  async _finishConversion(params) {
-    const filesSize = await (0, _statisticUtills.calculateFilesSize)(params);
-
-    const diff = _process.default.hrtime(this.conversionStartTime);
-
-    const conversionTime = (0, _statisticUtills.timeConverter)(diff);
-    console.log("------------------------------------------------");
-    console.log("Finish conversion of ".concat(I3S));
-    console.log("Total conversion time: ".concat(conversionTime));
-    console.log("Vertex count: ", this.vertexCounter);
-    console.log("File(s) size: ", filesSize, ' bytes');
-    console.log("------------------------------------------------");
-  }
+  }, {
+    key: "_finishConversion",
+    value: function () {
+      var _finishConversion2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee5(params) {
+        var filesSize, diff, conversionTime;
+        return _regenerator.default.wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                _context5.next = 2;
+                return (0, _statisticUtills.calculateFilesSize)(params);
+
+              case 2:
+                filesSize = _context5.sent;
+                diff = _process.default.hrtime(this.conversionStartTime);
+                conversionTime = (0, _statisticUtills.timeConverter)(diff);
+                console.log("------------------------------------------------");
+                console.log("Finish conversion of ".concat(I3S));
+                console.log("Total conversion time: ".concat(conversionTime));
+                console.log("Vertex count: ", this.vertexCounter);
+                console.log("File(s) size: ", filesSize, ' bytes');
+                console.log("------------------------------------------------");
+
+              case 11:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5, this);
+      }));
+
+      function _finishConversion(_x9) {
+        return _finishConversion2.apply(this, arguments);
+      }
 
-}
+      return _finishConversion;
+    }()
+  }]);
+  return Tiles3DConverter;
+}();
 
 exports.default = Tiles3DConverter;
 //# sourceMappingURL=3d-tiles-converter.js.map