@loaders.gl/tile-converter 3.1.0-alpha.3 → 3.1.0-beta.2

package/dist/es5/i3s-converter/i3s-converter.js

@@ -0,0 +1,915 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _core = require("@loaders.gl/core");
+
+var _tiles = require("@loaders.gl/tiles");
+
+var _dTiles = require("@loaders.gl/3d-tiles");
+
+var _path = require("path");
+
+var _uuid = require("uuid");
+
+var _process = _interopRequireDefault(require("process"));
+
+var _jsonMapTransform = _interopRequireDefault(require("json-map-transform"));
+
+var _md = _interopRequireDefault(require("md5"));
+
+var _nodePages = _interopRequireDefault(require("./helpers/node-pages"));
+
+var _fileUtils = require("../lib/utils/file-utils");
+
+var _compressUtil = require("../lib/utils/compress-util");
+
+var _statisticUtills = require("../lib/utils/statistic-utills");
+
+var _geometryConverter = _interopRequireDefault(require("./helpers/geometry-converter"));
+
+var _coordinateConverter = require("./helpers/coordinate-converter");
+
+var _createSceneServerPath = require("./helpers/create-scene-server-path");
+
+var _lodConversionUtils = require("../lib/utils/lod-conversion-utils");
+
+var _pgmLoader = require("../pgm-loader");
+
+var _layers = require("./json-templates/layers");
+
+var _node = require("./json-templates/node");
+
+var _sharedResources = require("./json-templates/shared-resources");
+
+var _nodeDebug = require("./helpers/node-debug");
+
+var _textures = require("@loaders.gl/textures");
+
+const ION_DEFAULT_TOKEN = _process.default.env.IonToken || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJlYWMxMzcyYy0zZjJkLTQwODctODNlNi01MDRkZmMzMjIxOWIiLCJpZCI6OTYyMCwic2NvcGVzIjpbImFzbCIsImFzciIsImdjIl0sImlhdCI6MTU2Mjg2NjI3M30.1FNiClUyk00YH_nWfSGpiQAjR5V2OvREDq1PJ5QMjWQ';
+const HARDCODED_NODES_PER_PAGE = 64;
+const _3D_TILES = '3DTILES';
+const _3D_OBJECT_LAYER_TYPE = '3DObject';
+const STRING_TYPE = 'string';
+const SHORT_INT_TYPE = 'Int32';
+const DOUBLE_TYPE = 'double';
+const OBJECT_ID_TYPE = 'OBJECTID';
+const REFRESH_TOKEN_TIMEOUT = 1800;
+const CESIUM_DATASET_PREFIX = 'https://';
+
+class I3SConverter {
+  constructor() {
+    (0, _defineProperty2.default)(this, "nodePages", void 0);
+    (0, _defineProperty2.default)(this, "fileMap", void 0);
+    (0, _defineProperty2.default)(this, "options", void 0);
+    (0, _defineProperty2.default)(this, "layers0Path", void 0);
+    (0, _defineProperty2.default)(this, "materialMap", void 0);
+    (0, _defineProperty2.default)(this, "materialDefinitions", void 0);
+    (0, _defineProperty2.default)(this, "vertexCounter", void 0);
+    (0, _defineProperty2.default)(this, "layers0", void 0);
+    (0, _defineProperty2.default)(this, "featuresHashArray", void 0);
+    (0, _defineProperty2.default)(this, "refinementCounter", void 0);
+    (0, _defineProperty2.default)(this, "validate", void 0);
+    (0, _defineProperty2.default)(this, "boundingVolumeWarnings", void 0);
+    (0, _defineProperty2.default)(this, "conversionStartTime", void 0);
+    (0, _defineProperty2.default)(this, "refreshTokenTime", void 0);
+    (0, _defineProperty2.default)(this, "sourceTileset", void 0);
+    (0, _defineProperty2.default)(this, "geoidHeightModel", void 0);
+    (0, _defineProperty2.default)(this, "Loader", _dTiles.Tiles3DLoader);
+    this.nodePages = new _nodePages.default(_fileUtils.writeFile, HARDCODED_NODES_PER_PAGE);
+    this.fileMap = {};
+    this.options = {};
+    this.layers0Path = '';
+    this.materialMap = new Map();
+    this.materialDefinitions = [];
+    this.vertexCounter = 0;
+    this.layers0 = null;
+    this.featuresHashArray = [];
+    this.refinementCounter = {
+      tilesCount: 0,
+      tilesWithAddRefineCount: 0
+    };
+    this.validate = false;
+    this.boundingVolumeWarnings = null;
+  }
+
+  async convert(options) {
+    this.conversionStartTime = _process.default.hrtime();
+    const {
+      tilesetName,
+      slpk,
+      egmFilePath,
+      inputUrl,
+      validate,
+      outputPath,
+      draco,
+      sevenZipExe,
+      maxDepth,
+      token
+    } = options;
+    this.options = {
+      maxDepth,
+      slpk,
+      sevenZipExe,
+      egmFilePath,
+      draco,
+      token,
+      inputUrl
+    };
+    this.validate = validate;
+    this.Loader = inputUrl.indexOf(CESIUM_DATASET_PREFIX) !== -1 ? _dTiles.CesiumIonLoader : _dTiles.Tiles3DLoader;
+    console.log('Loading egm file...');
+    this.geoidHeightModel = await (0, _core.load)(egmFilePath, _pgmLoader.PGMLoader);
+    console.log('Loading egm file completed!');
+
+    if (slpk) {
+      this.nodePages.useWriteFunction(_fileUtils.writeFileForSlpk);
+    }
+
+    const preloadOptions = await this._fetchPreloadOptions();
+    const tilesetOptions = {
+      loadOptions: {}
+    };
+
+    if (preloadOptions.headers) {
+      tilesetOptions.loadOptions.fetch = {
+        headers: preloadOptions.headers
+      };
+    }
+
+    Object.assign(tilesetOptions, preloadOptions);
+    const sourceTilesetJson = await (0, _core.load)(inputUrl, this.Loader, tilesetOptions.loadOptions);
+    this.sourceTileset = new _tiles.Tileset3D(sourceTilesetJson, tilesetOptions);
+    await this._createAndSaveTileset(outputPath, tilesetName);
+    await this._finishConversion({
+      slpk,
+      outputPath,
+      tilesetName
+    });
+    return sourceTilesetJson;
+  }
+
+  async _createAndSaveTileset(outputPath, tilesetName) {
+    const tilesetPath = (0, _path.join)("".concat(outputPath), "".concat(tilesetName));
+
+    try {
+      await (0, _fileUtils.removeDir)(tilesetPath);
+    } catch (e) {}
+
+    this.layers0Path = (0, _path.join)(tilesetPath, 'SceneServer', 'layers', '0');
+
+    this._formLayers0(tilesetName);
+
+    this.materialDefinitions = [];
+    this.materialMap = new Map();
+    const sourceRootTile = this.sourceTileset.root;
+    const boundingVolumes = (0, _coordinateConverter.createBoundingVolumes)(sourceRootTile, this.geoidHeightModel);
+    const parentId = this.nodePages.push({
+      lodThreshold: 0,
+      obb: boundingVolumes.obb,
+      children: []
+    });
+    const isCreateSlpk = this.options.slpk;
+
+    const root0 = this._formRootNodeIndexDocument(boundingVolumes);
+
+    await this._convertNodesTree(root0, sourceRootTile, parentId, boundingVolumes);
+    this.layers0.materialDefinitions = this.materialDefinitions;
+    await this._writeLayers0();
+    (0, _createSceneServerPath.createSceneServerPath)(tilesetName, this.layers0, tilesetPath);
+    await this._writeNodeIndexDocument(root0, 'root', (0, _path.join)(this.layers0Path, 'nodes', 'root'));
+    await this.nodePages.save(this.layers0Path, this.fileMap, isCreateSlpk);
+    await this._createSlpk(tilesetPath);
+  }
+
+  _formLayers0(tilesetName) {
+    const extent = (0, _coordinateConverter.convertCommonToI3SExtentCoordinate)(this.sourceTileset);
+    const layers0data = {
+      version: "{".concat((0, _uuid.v4)().toUpperCase(), "}"),
+      id: 0,
+      name: tilesetName,
+      href: './layers/0',
+      store: {
+        id: "{".concat((0, _uuid.v4)().toUpperCase(), "}"),
+        extent
+      },
+      nodePages: {
+        nodesPerPage: HARDCODED_NODES_PER_PAGE
+      },
+      compressGeometry: this.options.draco
+    };
+    this.layers0 = (0, _jsonMapTransform.default)(layers0data, _layers.LAYERS);
+  }
+
+  _formRootNodeIndexDocument(boundingVolumes) {
+    const root0data = {
+      version: "{".concat((0, _uuid.v4)().toUpperCase(), "}"),
+      id: 'root',
+      level: 0,
+      lodSelection: [{
+        metricType: 'maxScreenThresholdSQ',
+        maxError: 0
+      }, {
+        metricType: 'maxScreenThreshold',
+        maxError: 0
+      }],
+      ...boundingVolumes,
+      children: []
+    };
+    return (0, _jsonMapTransform.default)(root0data, _node.NODE);
+  }
+
+  async _convertNodesTree(root0, sourceRootTile, parentId, boundingVolumes) {
+    await this.sourceTileset._loadTile(sourceRootTile);
+
+    if (sourceRootTile.content && sourceRootTile.content.type === 'b3dm') {
+      root0.children.push({
+        id: '1',
+        href: './1',
+        ...boundingVolumes
+      });
+      const [child] = await this._createNode(root0, sourceRootTile, parentId, 0);
+      const childPath = (0, _path.join)(this.layers0Path, 'nodes', child.path);
+
+      if (this.options.slpk) {
+        this.fileMap['nodes/1/3dNodeIndexDocument.json.gz'] = await (0, _fileUtils.writeFileForSlpk)(childPath, JSON.stringify(child), '3dNodeIndexDocument.json');
+      } else {
+        await (0, _fileUtils.writeFile)(childPath, JSON.stringify(child));
+      }
+    } else {
+      await this._addChildrenWithNeighborsAndWriteFile({
+        parentNode: root0,
+        sourceTiles: sourceRootTile.children,
+        parentId,
+        level: 1
+      });
+    }
+
+    await sourceRootTile.unloadContent();
+  }
+
+  async _writeLayers0() {
+    if (this.options.slpk) {
+      this.fileMap['3dSceneLayer.json.gz'] = await (0, _fileUtils.writeFileForSlpk)(this.layers0Path, JSON.stringify(this.layers0), '3dSceneLayer.json');
+    } else {
+      await (0, _fileUtils.writeFile)(this.layers0Path, JSON.stringify(this.layers0));
+    }
+  }
+
+  async _writeNodeIndexDocument(root0, nodePath, rootPath) {
+    if (this.options.slpk) {
+      this.fileMap["nodes/".concat(nodePath, "/3dNodeIndexDocument.json.gz")] = await (0, _fileUtils.writeFileForSlpk)(rootPath, JSON.stringify(root0), '3dNodeIndexDocument.json');
+    } else {
+      await (0, _fileUtils.writeFile)(rootPath, JSON.stringify(root0));
+    }
+  }
+
+  async _createSlpk(tilesetPath) {
+    if (this.options.slpk) {
+      const slpkTilesetPath = (0, _path.join)(tilesetPath, 'SceneServer', 'layers', '0');
+      const slpkFileName = "".concat(tilesetPath, ".slpk");
+      await (0, _compressUtil.compressWithChildProcess)(slpkTilesetPath, slpkFileName, 0, '.', this.options.sevenZipExe);
+
+      try {
+        await (0, _fileUtils.removeDir)(tilesetPath);
+      } catch (e) {}
+    }
+  }
+
+  async _addChildrenWithNeighborsAndWriteFile(data) {
+    const childNodes = [];
+    await this._addChildren({ ...data,
+      childNodes
+    });
+    await this._addNeighborsAndWriteFile(data.parentNode, childNodes);
+  }
+
+  async _addChildren(data) {
+    const {
+      childNodes,
+      sourceTiles,
+      parentNode,
+      parentId,
+      level
+    } = data;
+
+    if (this.options.maxDepth && level > this.options.maxDepth) {
+      return;
+    }
+
+    for (const sourceTile of sourceTiles) {
+      if (sourceTile.type === 'json') {
+        await this.sourceTileset._loadTile(sourceTile);
+        await this._addChildren({
+          parentNode,
+          sourceTiles: sourceTile.children,
+          childNodes,
+          parentId,
+          level: level + 1
+        });
+        await sourceTile.unloadContent();
+      } else {
+        const boundingVolumes = (0, _coordinateConverter.createBoundingVolumes)(sourceTile, this.geoidHeightModel);
+        const children = await this._createNode(parentNode, sourceTile, parentId, level);
+
+        for (const child of children) {
+          parentNode.children.push({
+            id: child.id,
+            href: "../".concat(child.path),
+            ...boundingVolumes
+          });
+          childNodes.push(child);
+        }
+      }
+
+      if (sourceTile.id) {
+        console.log(sourceTile.id);
+      }
+    }
+  }
+
+  async _addNeighborsAndWriteFile(parentNode, childNodes) {
+    for (const node of childNodes) {
+      const childPath = (0, _path.join)(this.layers0Path, 'nodes', node.path);
+      const nodePath = node.path;
+      delete node.path;
+
+      if (parentNode.children.length < 1000) {
+        for (const neighbor of parentNode.children) {
+          if (node.id === neighbor.id) {
+            continue;
+          }
+
+          node.neighbors.push({ ...neighbor
+          });
+        }
+      } else {
+        console.warn("Node ".concat(node.id, ": neighbors attribute is omited because of large number of neigbors"));
+        delete node.neighbors;
+      }
+
+      await this._writeNodeIndexDocument(node, nodePath, childPath);
+      node.neighbors = [];
+    }
+  }
+
+  async _createNode(parentTile, sourceTile, parentId, level) {
+    var _sourceTile$content;
+
+    if (this.validate) {
+      this._checkAddRefinementTypeForTile(sourceTile);
+    }
+
+    await this._updateTilesetOptions();
+    await this.sourceTileset._loadTile(sourceTile);
+    const boundingVolumes = (0, _coordinateConverter.createBoundingVolumes)(sourceTile, this.geoidHeightModel);
+    const lodSelection = (0, _lodConversionUtils.convertGeometricErrorToScreenThreshold)(sourceTile, boundingVolumes);
+    const maxScreenThresholdSQ = lodSelection.find(val => val.metricType === 'maxScreenThresholdSQ') || {
+      maxError: 0
+    };
+    const batchTable = sourceTile === null || sourceTile === void 0 ? void 0 : (_sourceTile$content = sourceTile.content) === null || _sourceTile$content === void 0 ? void 0 : _sourceTile$content.batchTableJson;
+
+    if (batchTable) {
+      this._convertAttributeStorageInfo(sourceTile.content);
+    }
+
+    const resourcesData = await this._convertResources(sourceTile);
+    const nodes = [];
+    const emptyResources = {
+      geometry: null,
+      compressedGeometry: null,
+      texture: null,
+      sharedResources: null,
+      meshMaterial: null,
+      vertexCount: null,
+      attributes: null,
+      featureCount: null
+    };
+
+    for (const resources of resourcesData || [emptyResources]) {
+      const nodeInPage = this._createNodeInNodePages(maxScreenThresholdSQ, boundingVolumes, sourceTile, parentId, resources);
+
+      const node = this._createNodeIndexDocument(parentTile, boundingVolumes, lodSelection, nodeInPage, resources);
+
+      if (nodeInPage.mesh) {
+        await this._writeResources(resources, node.path);
+      }
+
+      if (this.validate) {
+        this.boundingVolumeWarnings = (0, _nodeDebug.validateNodeBoundingVolumes)(node);
+
+        if (this.boundingVolumeWarnings && this.boundingVolumeWarnings.length) {
+          console.warn('Bounding Volume Warnings: ', ...this.boundingVolumeWarnings);
+        }
+      }
+
+      nodes.push(node);
+    }
+
+    sourceTile.unloadContent();
+    const firstNode = nodes[0];
+    await this._addChildrenWithNeighborsAndWriteFile({
+      parentNode: firstNode,
+      sourceTiles: sourceTile.children,
+      parentId: firstNode.id,
+      level: level + 1
+    });
+    return nodes;
+  }
+
+  _convertAttributeStorageInfo(sourceTileContent) {
+    const batchTable = sourceTileContent && sourceTileContent.batchTableJson;
+
+    if (batchTable && !this.layers0.attributeStorageInfo.length) {
+      this._convertBatchTableInfoToNodeAttributes(batchTable);
+    }
+  }
+
+  async _convertResources(sourceTile) {
+    if (!sourceTile.content || sourceTile.content.type !== 'b3dm') {
+      return null;
+    }
+
+    const resourcesData = await (0, _geometryConverter.default)(sourceTile.content, Number(this.nodePages.nodesCounter), this.featuresHashArray, this.layers0.attributeStorageInfo, this.options.draco);
+    return resourcesData;
+  }
+
+  _createNodeInNodePages(maxScreenThresholdSQ, boundingVolumes, sourceTile, parentId, resources) {
+    const {
+      meshMaterial,
+      texture,
+      vertexCount,
+      featureCount,
+      geometry
+    } = resources;
+    const nodeInPage = {
+      lodThreshold: maxScreenThresholdSQ.maxError,
+      obb: boundingVolumes.obb,
+      children: [],
+      mesh: null
+    };
+
+    if (geometry && sourceTile.content && sourceTile.content.type === 'b3dm') {
+      nodeInPage.mesh = {
+        geometry: {
+          definition: texture ? 0 : 1
+        },
+        attribute: {}
+      };
+    }
+
+    const nodeId = this.nodePages.push(nodeInPage, parentId);
+
+    if (meshMaterial) {
+      this.nodePages.updateMaterialByNodeId(nodeId, this._findOrCreateMaterial(meshMaterial));
+    }
+
+    if (texture) {
+      const texelCountHint = texture.image.height * texture.image.width;
+      this.nodePages.updateTexelCountHintByNodeId(nodeId, texelCountHint);
+    }
+
+    if (vertexCount) {
+      this.vertexCounter += vertexCount;
+      this.nodePages.updateVertexCountByNodeId(nodeId, vertexCount);
+    }
+
+    this.nodePages.updateNodeAttributeByNodeId(nodeId);
+
+    if (featureCount) {
+      this.nodePages.updateFeatureCountByNodeId(nodeId, featureCount);
+    }
+
+    return nodeInPage;
+  }
+
+  _createNodeIndexDocument(parentNode, boundingVolumes, lodSelection, nodeInPage, resources) {
+    const {
+      texture,
+      attributes
+    } = resources;
+    const nodeId = nodeInPage.index;
+    const nodeData = {
+      version: parentNode.version,
+      id: nodeId.toString(),
+      path: nodeId.toString(),
+      level: parentNode.level + 1,
+      ...boundingVolumes,
+      lodSelection,
+      parentNode: {
+        id: parentNode.id,
+        href: "../".concat(parentNode.id),
+        mbs: parentNode.mbs,
+        obb: parentNode.obb
+      },
+      children: [],
+      neighbors: []
+    };
+    const node = (0, _jsonMapTransform.default)(nodeData, _node.NODE);
+
+    if (nodeInPage.mesh) {
+      node.geometryData = [{
+        href: './geometries/0'
+      }];
+      node.sharedResource = {
+        href: './shared'
+      };
+
+      if (texture) {
+        node.textureData = [{
+          href: './textures/0'
+        }, {
+          href: './textures/1'
+        }];
+      }
+
+      if (attributes && attributes.length && this.layers0.attributeStorageInfo && this.layers0.attributeStorageInfo.length) {
+        node.attributeData = [];
+
+        for (let index = 0; index < attributes.length; index++) {
+          const folderName = this.layers0.attributeStorageInfo[index].key;
+          node.attributeData.push({
+            href: "./attributes/".concat(folderName, "/0")
+          });
+        }
+      }
+    }
+
+    return node;
+  }
+
+  async _writeResources(resources, nodePath) {
+    const {
+      geometry: geometryBuffer,
+      compressedGeometry,
+      texture,
+      sharedResources,
+      attributes
+    } = resources;
+    const childPath = (0, _path.join)(this.layers0Path, 'nodes', nodePath);
+    const slpkChildPath = (0, _path.join)('nodes', nodePath);
+    await this._writeGeometries(geometryBuffer, compressedGeometry, childPath, slpkChildPath);
+    await this._writeShared(sharedResources, childPath, slpkChildPath, nodePath);
+    await this._writeTexture(texture, childPath, slpkChildPath);
+    await this._writeAttributes(attributes, childPath, slpkChildPath);
+  }
+
+  async _writeGeometries(geometryBuffer, compressedGeometry, childPath, slpkChildPath) {
+    if (this.options.slpk) {
+      const slpkGeometryPath = (0, _path.join)(childPath, 'geometries');
+      this.fileMap["".concat(slpkChildPath, "/geometries/0.bin.gz")] = await (0, _fileUtils.writeFileForSlpk)(slpkGeometryPath, geometryBuffer, '0.bin');
+    } else {
+      const geometryPath = (0, _path.join)(childPath, 'geometries/0/');
+      await (0, _fileUtils.writeFile)(geometryPath, geometryBuffer, 'index.bin');
+    }
+
+    if (this.options.draco) {
+      if (this.options.slpk) {
+        const slpkCompressedGeometryPath = (0, _path.join)(childPath, 'geometries');
+        this.fileMap["".concat(slpkChildPath, "/geometries/1.bin.gz")] = await (0, _fileUtils.writeFileForSlpk)(slpkCompressedGeometryPath, compressedGeometry, '1.bin');
+      } else {
+        const compressedGeometryPath = (0, _path.join)(childPath, 'geometries/1/');
+        await (0, _fileUtils.writeFile)(compressedGeometryPath, compressedGeometry, 'index.bin');
+      }
+    }
+  }
+
+  async _writeShared(sharedResources, childPath, slpkChildPath, nodePath) {
+    sharedResources.nodePath = nodePath;
+    const sharedData = (0, _jsonMapTransform.default)(sharedResources, _sharedResources.SHARED_RESOURCES_TEMPLATE);
+    const sharedDataStr = JSON.stringify(sharedData);
+
+    if (this.options.slpk) {
+      const slpkSharedPath = (0, _path.join)(childPath, 'shared');
+      this.fileMap["".concat(slpkChildPath, "/shared/sharedResource.json.gz")] = await (0, _fileUtils.writeFileForSlpk)(slpkSharedPath, sharedDataStr, 'sharedResource.json');
+    } else {
+      const sharedPath = (0, _path.join)(childPath, 'shared/');
+      await (0, _fileUtils.writeFile)(sharedPath, sharedDataStr);
+    }
+  }
+
+  async _writeTexture(texture, childPath, slpkChildPath) {
+    if (texture) {
+      const format = this._getFormatByMimeType(texture.mimeType);
+
+      if (!this.layers0.textureSetDefinitions.length) {
+        this.layers0.textureSetDefinitions.push({
+          formats: [{
+            name: '0',
+            format
+          }, {
+            name: '1',
+            format: 'ktx2'
+          }]
+        });
+      }
+
+      const textureData = texture.bufferView.data;
+      const ktx2TextureData = await (0, _core.encode)(texture.image, _textures.KTX2BasisUniversalTextureWriter);
+
+      if (this.options.slpk) {
+        const slpkTexturePath = (0, _path.join)(childPath, 'textures');
+        const compress = false;
+        this.fileMap["".concat(slpkChildPath, "/textures/0.").concat(format)] = await (0, _fileUtils.writeFileForSlpk)(slpkTexturePath, textureData, "0.".concat(format), compress);
+        this.fileMap["".concat(slpkChildPath, "/textures/1.ktx2")] = await (0, _fileUtils.writeFileForSlpk)(slpkTexturePath, ktx2TextureData, "1.ktx2", compress);
+      } else {
+        const texturePath = (0, _path.join)(childPath, 'textures/0/');
+        await (0, _fileUtils.writeFile)(texturePath, textureData, "index.".concat(format));
+        const ktx2TexturePath = (0, _path.join)(childPath, 'textures/1/');
+        await (0, _fileUtils.writeFile)(ktx2TexturePath, ktx2TextureData, "index.ktx2");
+      }
+    }
+  }
+
+  async _writeAttributes(attributes, childPath, slpkChildPath) {
+    if (attributes.length && this.layers0.attributeStorageInfo && this.layers0.attributeStorageInfo.length) {
+      for (let index = 0; index < attributes.length; index++) {
+        const folderName = this.layers0.attributeStorageInfo[index].key;
+        const fileBuffer = new Uint8Array(attributes[index]);
+
+        if (this.options.slpk) {
+          const slpkAttributesPath = (0, _path.join)(childPath, 'attributes', folderName);
+          this.fileMap["".concat(slpkChildPath, "/attributes/").concat(folderName, ".bin.gz")] = await (0, _fileUtils.writeFileForSlpk)(slpkAttributesPath, fileBuffer, '0.bin');
+        } else {
+          const attributesPath = (0, _path.join)(childPath, "attributes/".concat(folderName, "/0"));
+          await (0, _fileUtils.writeFile)(attributesPath, fileBuffer, 'index.bin');
+        }
+      }
+    }
+  }
+
+  _getFormatByMimeType(mimeType) {
+    switch (mimeType) {
+      case 'image/jpeg':
+        return 'jpg';
+
+      case 'image/png':
+        return 'png';
+
+      default:
+        return 'jpg';
+    }
+  }
+
+  _findOrCreateMaterial(material) {
+    const hash = (0, _md.default)(JSON.stringify(material));
+
+    if (this.materialMap.has(hash)) {
+      return this.materialMap.get(hash);
+    }
+
+    const newMaterialId = this.materialDefinitions.push(material) - 1;
+    this.materialMap.set(hash, newMaterialId);
+    return newMaterialId;
+  }
+
+  _createdStorageAttribute(attributeIndex, key, attributeType) {
+    const storageAttribute = {
+      key: "f_".concat(attributeIndex),
+      name: key,
+      ordering: ['attributeValues'],
+      header: [{
+        property: 'count',
+        valueType: 'UInt32'
+      }],
+      attributeValues: {
+        valueType: 'Int32',
+        valuesPerElement: 1
+      }
+    };
+
+    switch (attributeType) {
+      case OBJECT_ID_TYPE:
+        this._setupIdAttribute(storageAttribute);
+
+        break;
+
+      case STRING_TYPE:
+        this._setupStringAttribute(storageAttribute);
+
+        break;
+
+      case DOUBLE_TYPE:
+        this._setupDoubleAttribute(storageAttribute);
+
+        break;
+
+      case SHORT_INT_TYPE:
+        break;
+
+      default:
+        this._setupStringAttribute(storageAttribute);
+
+    }
+
+    return storageAttribute;
+  }
+
+  getAttributeType(key, attribute) {
+    if (key === OBJECT_ID_TYPE) {
+      return OBJECT_ID_TYPE;
+    }
+
+    if (typeof attribute === STRING_TYPE) {
+      return STRING_TYPE;
+    } else if (typeof attribute === 'number') {
+      return Number.isInteger(attribute) ? SHORT_INT_TYPE : DOUBLE_TYPE;
+    }
+
+    return STRING_TYPE;
+  }
+
+  _setupStringAttribute(storageAttribute) {
+    storageAttribute.ordering.unshift('attributeByteCounts');
+    storageAttribute.header.push({
+      property: 'attributeValuesByteCount',
+      valueType: 'UInt32'
+    });
+    storageAttribute.attributeValues = {
+      valueType: 'String',
+      encoding: 'UTF-8',
+      valuesPerElement: 1
+    };
+    storageAttribute.attributeByteCounts = {
+      valueType: 'UInt32',
+      valuesPerElement: 1
+    };
+  }
+
+  _setupIdAttribute(storageAttribute) {
+    storageAttribute.attributeValues = {
+      valueType: 'Oid32',
+      valuesPerElement: 1
+    };
+  }
+
+  _setupDoubleAttribute(storageAttribute) {
+    storageAttribute.attributeValues = {
+      valueType: 'Float64',
+      valuesPerElement: 1
+    };
+  }
+
+  _createFieldAttribute(key, fieldAttributeType) {
+    return {
+      name: key,
+      type: fieldAttributeType,
+      alias: key
+    };
+  }
+
+  _convertBatchTableInfoToNodeAttributes(batchTable) {
+    let attributeIndex = 0;
+    const batchTableWithObjectId = {
+      OBJECTID: [0],
+      ...batchTable
+    };
+
+    for (const key in batchTableWithObjectId) {
+      const firstAttribute = batchTableWithObjectId[key][0];
+      const attributeType = this.getAttributeType(key, firstAttribute);
+
+      const storageAttribute = this._createdStorageAttribute(attributeIndex, key, attributeType);
+
+      const fieldAttributeType = this._getFieldAttributeType(attributeType);
+
+      const fieldAttribute = this._createFieldAttribute(key, fieldAttributeType);
+
+      const popupInfo = this._createPopupInfo(batchTableWithObjectId);
+
+      this.layers0.attributeStorageInfo.push(storageAttribute);
+      this.layers0.fields.push(fieldAttribute);
+      this.layers0.popupInfo = popupInfo;
+      this.layers0.layerType = _3D_OBJECT_LAYER_TYPE;
+      attributeIndex += 1;
+    }
+  }
+
+  _getFieldAttributeType(attributeType) {
+    switch (attributeType) {
+      case OBJECT_ID_TYPE:
+        return 'esriFieldTypeOID';
+
+      case STRING_TYPE:
+        return 'esriFieldTypeString';
+
+      case SHORT_INT_TYPE:
+        return 'esriFieldTypeInteger';
+
+      case DOUBLE_TYPE:
+        return 'esriFieldTypeDouble';
+
+      default:
+        return 'esriFieldTypeString';
+    }
+  }
+
+  _createPopupInfo(batchTable) {
+    const title = '{OBJECTID}';
+    const mediaInfos = [];
+    const fieldInfos = [];
+    const popupElements = [];
+    const expressionInfos = [];
+
+    for (const key in batchTable) {
+      fieldInfos.push({
+        fieldName: key,
+        visible: true,
+        isEditable: false,
+        label: key
+      });
+    }
+
+    popupElements.push({
+      fieldInfos,
+      type: 'fields'
+    });
+    return {
+      title,
+      mediaInfos,
+      popupElements,
+      fieldInfos,
+      expressionInfos
+    };
+  }
+
+  async _finishConversion(params) {
+    const {
+      tilesCount,
+      tilesWithAddRefineCount
+    } = this.refinementCounter;
+    const addRefinementPercentage = tilesWithAddRefineCount ? tilesWithAddRefineCount / tilesCount * 100 : 0;
+    const filesSize = await (0, _statisticUtills.calculateFilesSize)(params);
+
+    const diff = _process.default.hrtime(this.conversionStartTime);
+
+    const conversionTime = (0, _statisticUtills.timeConverter)(diff);
+    console.log("------------------------------------------------");
+    console.log("Finishing conversion of ".concat(_3D_TILES));
+    console.log("Total conversion time: ".concat(conversionTime));
+    console.log("Vertex count: ", this.vertexCounter);
+    console.log("File(s) size: ", filesSize, ' bytes');
+    console.log("Percentage of tiles with \"ADD\" refinement type:", addRefinementPercentage, '%');
+    console.log("------------------------------------------------");
+  }
+
+  async _fetchPreloadOptions() {
+    if (!this.Loader.preload) {
+      return {};
+    }
+
+    const options = {
+      'cesium-ion': {
+        accessToken: this.options.token || ION_DEFAULT_TOKEN
+      }
+    };
+    const preloadOptions = await this.Loader.preload(this.options.inputUrl, options);
+    this.refreshTokenTime = _process.default.hrtime();
+    return { ...options,
+      ...preloadOptions
+    };
+  }
+
+  async _updateTilesetOptions() {
+    const diff = _process.default.hrtime(this.refreshTokenTime);
+
+    if (diff[0] < REFRESH_TOKEN_TIMEOUT) {
+      return;
+    }
+
+    this.refreshTokenTime = _process.default.hrtime();
+    const preloadOptions = await this._fetchPreloadOptions();
+    this.sourceTileset.options = { ...this.sourceTileset.options,
+      ...preloadOptions
+    };
+
+    if (preloadOptions.headers) {
+      this.sourceTileset.loadOptions.fetch = { ...this.sourceTileset.loadOptions.fetch,
+        headers: preloadOptions.headers
+      };
+      console.log('Authorization Bearer token has been updated');
+    }
+  }
+
+  _checkAddRefinementTypeForTile(tile) {
+    const ADD_TILE_REFINEMENT = 1;
+
+    if (tile.refine === ADD_TILE_REFINEMENT) {
+      this.refinementCounter.tilesWithAddRefineCount += 1;
+      console.warn('This tile uses "ADD" type of refinement');
+    }
+
+    this.refinementCounter.tilesCount += 1;
+  }
+
+}
+
+exports.default = I3SConverter;
+//# sourceMappingURL=i3s-converter.js.map