@loaders.gl/tile-converter 4.0.0-alpha.1 → 4.0.0-alpha.11

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

@@ -1,887 +1,911 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { load, encode } from '@loaders.gl/core';
-import { Tileset3D } from '@loaders.gl/tiles';
-import { CesiumIonLoader } from '@loaders.gl/3d-tiles';
-import { join } from 'path';
-import { v4 as uuidv4 } from 'uuid';
-import process from 'process';
-import transform from 'json-map-transform';
-import md5 from 'md5';
-import NodePages from './helpers/node-pages';
-import { writeFile, removeDir, writeFileForSlpk } from '../lib/utils/file-utils';
-import { compressWithChildProcess } from '../lib/utils/compress-util';
-import { calculateFilesSize, timeConverter } from '../lib/utils/statistic-utills';
-import convertB3dmToI3sGeometry from './helpers/geometry-converter';
-import { createBoundingVolumes, convertCommonToI3SExtentCoordinate } from './helpers/coordinate-converter';
-import { createSceneServerPath } from './helpers/create-scene-server-path';
-import { convertGeometricErrorToScreenThreshold } from '../lib/utils/lod-conversion-utils';
-import { PGMLoader } from '../pgm-loader';
-import { LAYERS as layersTemplate } from './json-templates/layers';
-import { NODE as nodeTemplate } from './json-templates/node';
-import { SHARED_RESOURCES_TEMPLATE } from './json-templates/shared-resources';
-import { validateNodeBoundingVolumes } from './helpers/node-debug';
-import { KTX2BasisUniversalTextureWriter } from '@loaders.gl/textures';
-const ION_DEFAULT_TOKEN = process.env.IonToken || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJlYWMxMzcyYy0zZjJkLTQwODctODNlNi01MDRkZmMzMjIxOWIiLCJpZCI6OTYyMCwic2NvcGVzIjpbImFzbCIsImFzciIsImdjIl0sImlhdCI6MTU2Mjg2NjI3M30.1FNiClUyk00YH_nWfSGpiQAjR5V2OvREDq1PJ5QMjWQ';
+"use strict";
+// loaders.gl, MIT license
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@loaders.gl/core");
+const _3d_tiles_1 = require("@loaders.gl/3d-tiles");
+const path_1 = require("path");
+const uuid_1 = require("uuid");
+const process_1 = __importDefault(require("process"));
+const json_map_transform_1 = __importDefault(require("json-map-transform"));
+const md5_1 = __importDefault(require("md5"));
+const node_pages_1 = __importDefault(require("./helpers/node-pages"));
+const file_utils_1 = require("../lib/utils/file-utils");
+const compress_util_1 = require("../lib/utils/compress-util");
+const statistic_utills_1 = require("../lib/utils/statistic-utills");
+const geometry_converter_1 = __importStar(require("./helpers/geometry-converter"));
+const coordinate_converter_1 = require("./helpers/coordinate-converter");
+const create_scene_server_path_1 = require("./helpers/create-scene-server-path");
+const lod_conversion_utils_1 = require("../lib/utils/lod-conversion-utils");
+const pgm_loader_1 = require("../pgm-loader");
+const layers_1 = require("./json-templates/layers");
+const geometry_definitions_1 = require("./json-templates/geometry-definitions");
+const shared_resources_1 = require("./json-templates/shared-resources");
+const node_debug_1 = require("./helpers/node-debug");
+const textures_1 = require("@loaders.gl/textures");
+const images_1 = require("@loaders.gl/images");
+const types_1 = require("./types");
+const worker_utils_1 = require("@loaders.gl/worker-utils");
+const draco_1 = require("@loaders.gl/draco");
+const write_queue_1 = __importDefault(require("../lib/utils/write-queue"));
+const i3s_attributes_worker_1 = require("../i3s-attributes-worker");
+const constants_1 = require("../constants");
+const feature_attributes_1 = require("./helpers/feature-attributes");
+const node_index_document_1 = require("./helpers/node-index-document");
+const load_3d_tiles_1 = require("./helpers/load-3d-tiles");
+const core_2 = require("@math.gl/core");
+const tiles_1 = require("@loaders.gl/tiles");
+const tileset_traversal_1 = require("./helpers/tileset-traversal");
+const preprocess_3d_tiles_1 = require("./helpers/preprocess-3d-tiles");
+const ION_DEFAULT_TOKEN = process_1.default.env?.IonToken || // eslint-disable-line
+    'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJlYWMxMzcyYy0zZjJkLTQwODctODNlNi01MDRkZmMzMjIxOWIiLCJpZCI6OTYyMCwic2NvcGVzIjpbImFzbCIsImFzciIsImdjIl0sImlhdCI6MTU2Mjg2NjI3M30.1FNiClUyk00YH_nWfSGpiQAjR5V2OvREDq1PJ5QMjWQ'; // eslint-disable-line
 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;
-export default class I3SConverter {
-  constructor() {
-    _defineProperty(this, "nodePages", void 0);
-
-    _defineProperty(this, "fileMap", void 0);
-
-    _defineProperty(this, "options", void 0);
-
-    _defineProperty(this, "layers0Path", void 0);
-
-    _defineProperty(this, "materialMap", void 0);
-
-    _defineProperty(this, "materialDefinitions", void 0);
-
-    _defineProperty(this, "vertexCounter", void 0);
-
-    _defineProperty(this, "layers0", void 0);
-
-    _defineProperty(this, "featuresHashArray", void 0);
-
-    _defineProperty(this, "refinementCounter", void 0);
-
-    _defineProperty(this, "validate", void 0);
-
-    _defineProperty(this, "boundingVolumeWarnings", void 0);
-
-    _defineProperty(this, "conversionStartTime", void 0);
-
-    _defineProperty(this, "refreshTokenTime", void 0);
-
-    _defineProperty(this, "sourceTileset", void 0);
-
-    _defineProperty(this, "geoidHeightModel", void 0);
-
-    this.nodePages = new NodePages(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.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;
-    console.log('Loading egm file...');
-    this.geoidHeightModel = await load(egmFilePath, PGMLoader);
-    console.log('Loading egm file completed!');
-
-    if (slpk) {
-      this.nodePages.useWriteFunction(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 load(inputUrl, CesiumIonLoader, tilesetOptions.loadOptions);
-    this.sourceTileset = new Tileset3D(sourceTilesetJson, tilesetOptions);
-    await this._createAndSaveTileset(outputPath, tilesetName);
-    await this._finishConversion({
-      slpk,
-      outputPath,
-      tilesetName
-    });
-    return sourceTilesetJson;
-  }
-
-  async _createAndSaveTileset(outputPath, tilesetName) {
-    const tilesetPath = join("".concat(outputPath), "".concat(tilesetName));
-
-    try {
-      await removeDir(tilesetPath);
-    } catch (e) {}
-
-    this.layers0Path = join(tilesetPath, 'SceneServer', 'layers', '0');
-
-    this._formLayers0(tilesetName);
-
-    this.materialDefinitions = [];
-    this.materialMap = new Map();
-    const sourceRootTile = this.sourceTileset.root;
-    const boundingVolumes = 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();
-    createSceneServerPath(tilesetName, this.layers0, tilesetPath);
-    await this._writeNodeIndexDocument(root0, 'root', join(this.layers0Path, 'nodes', 'root'));
-    await this.nodePages.save(this.layers0Path, this.fileMap, isCreateSlpk);
-    await this._createSlpk(tilesetPath);
-  }
-
-  _formLayers0(tilesetName) {
-    const extent = convertCommonToI3SExtentCoordinate(this.sourceTileset);
-    const layers0data = {
-      version: "{".concat(uuidv4().toUpperCase(), "}"),
-      id: 0,
-      name: tilesetName,
-      href: './layers/0',
-      store: {
-        id: "{".concat(uuidv4().toUpperCase(), "}"),
-        extent
-      },
-      nodePages: {
-        nodesPerPage: HARDCODED_NODES_PER_PAGE
-      },
-      compressGeometry: this.options.draco
-    };
-    this.layers0 = transform(layers0data, layersTemplate);
-  }
-
-  _formRootNodeIndexDocument(boundingVolumes) {
-    const root0data = {
-      version: "{".concat(uuidv4().toUpperCase(), "}"),
-      id: 'root',
-      level: 0,
-      lodSelection: [{
-        metricType: 'maxScreenThresholdSQ',
-        maxError: 0
-      }, {
-        metricType: 'maxScreenThreshold',
-        maxError: 0
-      }],
-      ...boundingVolumes,
-      children: []
-    };
-    return transform(root0data, nodeTemplate);
-  }
-
-  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 = join(this.layers0Path, 'nodes', child.path);
-
-      if (this.options.slpk) {
-        this.fileMap['nodes/1/3dNodeIndexDocument.json.gz'] = await writeFileForSlpk(childPath, JSON.stringify(child), '3dNodeIndexDocument.json');
-      } else {
-        await 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 writeFileForSlpk(this.layers0Path, JSON.stringify(this.layers0), '3dSceneLayer.json');
-    } else {
-      await 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 writeFileForSlpk(rootPath, JSON.stringify(root0), '3dNodeIndexDocument.json');
-    } else {
-      await writeFile(rootPath, JSON.stringify(root0));
-    }
-  }
-
-  async _createSlpk(tilesetPath) {
-    if (this.options.slpk) {
-      const slpkTilesetPath = join(tilesetPath, 'SceneServer', 'layers', '0');
-      const slpkFileName = "".concat(tilesetPath, ".slpk");
-      await compressWithChildProcess(slpkTilesetPath, slpkFileName, 0, '.', this.options.sevenZipExe);
-
-      try {
-        await 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
+const REFRESH_TOKEN_TIMEOUT = 1800; // 30 minutes in seconds
+const CESIUM_DATASET_PREFIX = 'https://';
+// const FS_FILE_TOO_LARGE = 'ERR_FS_FILE_TOO_LARGE';
+/**
+ * Converter from 3d-tiles tileset to i3s layer
+ */
+class I3SConverter {
+    constructor() {
+        this.boundingVolumeWarnings = [];
+        this.conversionStartTime = [0, 0];
+        this.refreshTokenTime = [0, 0];
+        this.sourceTileset = null;
+        this.loadOptions = {
+            _nodeWorkers: true,
+            reuseWorkers: true,
+            basis: {
+                format: 'rgba32',
+                // We need to load local fs workers because nodejs can't load workers from the Internet
+                workerUrl: './modules/textures/dist/basis-worker-node.js'
+            },
+            // We need to load local fs workers because nodejs can't load workers from the Internet
+            draco: { workerUrl: './modules/draco/dist/draco-worker-node.js' },
+            fetch: {}
+        };
+        this.geoidHeightModel = null;
+        this.Loader = _3d_tiles_1.Tiles3DLoader;
+        this.workerSource = {};
+        this.writeQueue = new write_queue_1.default();
+        this.compressList = null;
+        this.preprocessData = {
+            meshTopologyTypes: new Set()
+        };
+        this.nodePages = new node_pages_1.default(file_utils_1.writeFile, HARDCODED_NODES_PER_PAGE, this);
+        this.options = {};
+        this.layers0Path = '';
+        this.materialMap = new Map();
+        this.materialDefinitions = [];
+        this.geometryMap = new Map();
+        this.geometryConfigs = [];
+        this.vertexCounter = 0;
+        this.layers0 = null;
+        this.featuresHashArray = [];
+        this.refinementCounter = {
+            tilesCount: 0,
+            tilesWithAddRefineCount: 0
+        };
+        this.validate = false;
+        this.generateTextures = false;
+        this.generateBoundingVolumes = false;
+        this.layersHasTexture = false;
+        this.compressList = null;
+    }
+    /**
+     * Convert a 3d tileset
+     * @param options
+     * @param options.inputUrl the url to read the tileset from
+     * @param options.outputPath the output filename
+     * @param options.tilesetName the output name of the tileset
+     * @param options.maxDepth The max tree depth of conversion
+     * @param options.slpk Generate slpk (Scene Layer Packages) output file
+     * @param options.sevenZipExe Location of 7z.exe archiver to create slpk on Windows
+     * @param options.egmFilePath location of *.pgm file to convert heights from ellipsoidal to gravity-related format
+     * @param options.token Token for Cesium ION tilesets authentication
+     * @param options.draco Generate I3S 1.7 draco compressed geometries
+     * @param options.validate -enable validation
+     * @param options.generateTextures - generate alternative type of textures (to have non-compressed jpeg/png and compressed ktx2)
+     * @param options.generateBoundingVolumes - generate bounding volumes from vertices coordinates instead of source tiles bounding volumes
+     * @param options.instantNodeWriting - Keep created 3DNodeIndexDocument files on disk instead of memory. This option reduce memory usage but decelerates conversion speed
+     */
+    async convert(options) {
+        if (core_1.isBrowser) {
+            console.log(constants_1.BROWSER_ERROR_MESSAGE);
+            return constants_1.BROWSER_ERROR_MESSAGE;
+        }
+        this.conversionStartTime = process_1.default.hrtime();
+        const { tilesetName, slpk, egmFilePath, inputUrl, validate, outputPath, draco = true, sevenZipExe, maxDepth, token, generateTextures, generateBoundingVolumes, instantNodeWriting = false, mergeMaterials = true } = options;
+        this.options = {
+            maxDepth,
+            slpk,
+            sevenZipExe,
+            egmFilePath,
+            draco,
+            token,
+            inputUrl,
+            instantNodeWriting,
+            mergeMaterials
+        };
+        this.compressList = (this.options.instantNodeWriting && []) || null;
+        this.validate = Boolean(validate);
+        this.Loader = inputUrl.indexOf(CESIUM_DATASET_PREFIX) !== -1 ? _3d_tiles_1.CesiumIonLoader : _3d_tiles_1.Tiles3DLoader;
+        this.generateTextures = Boolean(generateTextures);
+        this.generateBoundingVolumes = Boolean(generateBoundingVolumes);
+        this.writeQueue = new write_queue_1.default();
+        this.writeQueue.startListening();
+        console.log('Loading egm file...'); // eslint-disable-line
+        this.geoidHeightModel = await (0, core_1.load)(egmFilePath, pgm_loader_1.PGMLoader);
+        console.log('Loading egm file completed!'); // eslint-disable-line
+        if (slpk) {
+            this.nodePages.useWriteFunction(file_utils_1.writeFileForSlpk);
+        }
+        await this.loadWorkers();
+        try {
+            const preloadOptions = await this._fetchPreloadOptions();
+            if (preloadOptions.headers) {
+                this.loadOptions.fetch = { headers: preloadOptions.headers };
+            }
+            this.sourceTileset = await (0, core_1.load)(inputUrl, this.Loader, this.loadOptions);
+            const preprocessResult = await this.preprocessConversion();
+            if (preprocessResult) {
+                await this._createAndSaveTileset(outputPath, tilesetName);
+                await this._finishConversion({ slpk: Boolean(slpk), outputPath, tilesetName });
+            }
+        }
+        catch (error) {
+            throw error;
+        }
+        finally {
+            await this.writeQueue.finalize();
+            // Clean up worker pools
+            const workerFarm = worker_utils_1.WorkerFarm.getWorkerFarm({});
+            workerFarm.destroy();
+        }
+        return 'success';
+    }
+    /**
+     * Preprocess stage of the tile converter. Traverse all the tiles tree and
+     * check a tile content to be sure that the data is supported
+     * @returns true - the conversion is possible, false - the tileset's content is not supported
+     */
+    async preprocessConversion() {
+        console.log(`Analyze source tileset`);
+        const sourceRootTile = this.sourceTileset.root;
+        await (0, tileset_traversal_1.traverseDatasetWith)(sourceRootTile, null, this.analyzeTile.bind(this), undefined, this.options.maxDepth);
+        const { meshTopologyTypes } = this.preprocessData;
+        console.log(`------------------------------------------------`);
+        console.log(`Preprocess results:`);
+        console.log(`glTF mesh topology types: ${Array.from(meshTopologyTypes).join(', ')}`);
+        console.log(`------------------------------------------------`);
+        if (!meshTopologyTypes.has(types_1.GltfPrimitiveModeString.TRIANGLES) &&
+            !meshTopologyTypes.has(types_1.GltfPrimitiveModeString.TRIANGLE_STRIP)) {
+            console.log('The tileset is of unsupported mesh topology types. The conversion will be interrupted.');
+            console.log(`------------------------------------------------`);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Analyze a tile content. The callback for preprocess stage.
+     * @param sourceTile - 3DTiles tile JSON metadata
+     * @param traversalProps - mandatory argument but it is not used for the preprocess stage
+     * @returns - nothing
+     */
+    async analyzeTile(sourceTile, traversalProps) {
+        if (sourceTile.type === 'json') {
+            await (0, load_3d_tiles_1.loadNestedTileset)(this.sourceTileset, sourceTile, this.loadOptions);
+            return null;
+        }
+        if (sourceTile.id) {
+            console.log(`[analyze]: ${sourceTile.id}`); // eslint-disable-line
+        }
+        const tileContent = await (0, load_3d_tiles_1.loadTile3DContent)(this.sourceTileset, sourceTile, {
+            ...this.loadOptions,
+            '3d-tiles': { ...this.loadOptions['3d-tiles'], loadGLTF: false }
         });
-        await sourceTile.unloadContent();
-      } else {
-        const boundingVolumes = 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 = 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 = createBoundingVolumes(sourceTile, this.geoidHeightModel);
-    const lodSelection = 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 = 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 convertB3dmToI3sGeometry(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 = transform(nodeData, nodeTemplate);
-
-    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 = join(this.layers0Path, 'nodes', nodePath);
-    const slpkChildPath = 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 = join(childPath, 'geometries');
-      this.fileMap["".concat(slpkChildPath, "/geometries/0.bin.gz")] = await writeFileForSlpk(slpkGeometryPath, geometryBuffer, '0.bin');
-    } else {
-      const geometryPath = join(childPath, 'geometries/0/');
-      await writeFile(geometryPath, geometryBuffer, 'index.bin');
-    }
-
-    if (this.options.draco) {
-      if (this.options.slpk) {
-        const slpkCompressedGeometryPath = join(childPath, 'geometries');
-        this.fileMap["".concat(slpkChildPath, "/geometries/1.bin.gz")] = await writeFileForSlpk(slpkCompressedGeometryPath, compressedGeometry, '1.bin');
-      } else {
-        const compressedGeometryPath = join(childPath, 'geometries/1/');
-        await writeFile(compressedGeometryPath, compressedGeometry, 'index.bin');
-      }
-    }
-  }
-
-  async _writeShared(sharedResources, childPath, slpkChildPath, nodePath) {
-    sharedResources.nodePath = nodePath;
-    const sharedData = transform(sharedResources, SHARED_RESOURCES_TEMPLATE);
-    const sharedDataStr = JSON.stringify(sharedData);
-
-    if (this.options.slpk) {
-      const slpkSharedPath = join(childPath, 'shared');
-      this.fileMap["".concat(slpkChildPath, "/shared/sharedResource.json.gz")] = await writeFileForSlpk(slpkSharedPath, sharedDataStr, 'sharedResource.json');
-    } else {
-      const sharedPath = join(childPath, 'shared/');
-      await 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 tilePreprocessData = await (0, preprocess_3d_tiles_1.analyzeTileContent)(tileContent);
+        (0, preprocess_3d_tiles_1.mergePreprocessData)(this.preprocessData, tilePreprocessData);
+        return null;
+    }
+    /**
+     * Convert and save the layer and embedded tiles
+     * @param outputPath - path to save output data
+     * @param tilesetName - new tileset path
+     */
+    async _createAndSaveTileset(outputPath, tilesetName) {
+        const tilesetPath = (0, path_1.join)(`${outputPath}`, `${tilesetName}`);
+        // Removing the tilesetPath needed to exclude erroneous files after conversion
+        try {
+            await (0, file_utils_1.removeDir)(tilesetPath);
+        }
+        catch (e) {
+            // do nothing
+        }
+        this.layers0Path = (0, path_1.join)(tilesetPath, 'SceneServer', 'layers', '0');
+        this.materialDefinitions = [];
+        this.materialMap = new Map();
+        const sourceRootTile = this.sourceTileset.root;
+        const sourceBoundingVolume = (0, tiles_1.createBoundingVolume)(sourceRootTile.boundingVolume, new core_2.Matrix4(sourceRootTile.transform), null);
+        this._formLayers0(tilesetName, sourceBoundingVolume, this.sourceTileset?.root?.boundingVolume?.region);
+        const boundingVolumes = (0, coordinate_converter_1.createBoundingVolumes)(sourceBoundingVolume, this.geoidHeightModel);
+        await this.nodePages.push({
+            index: 0,
+            lodThreshold: 0,
+            obb: boundingVolumes.obb,
+            children: []
         });
-      }
-
-      const textureData = texture.bufferView.data;
-      const ktx2TextureData = await encode(texture.image, KTX2BasisUniversalTextureWriter);
-
-      if (this.options.slpk) {
-        const slpkTexturePath = join(childPath, 'textures');
-        const compress = false;
-        this.fileMap["".concat(slpkChildPath, "/textures/0.").concat(format)] = await writeFileForSlpk(slpkTexturePath, textureData, "0.".concat(format), compress);
-        this.fileMap["".concat(slpkChildPath, "/textures/1.ktx2")] = await writeFileForSlpk(slpkTexturePath, ktx2TextureData, "1.ktx2", compress);
-      } else {
-        const texturePath = join(childPath, 'textures/0/');
-        await writeFile(texturePath, textureData, "index.".concat(format));
-        const ktx2TexturePath = join(childPath, 'textures/1/');
-        await 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]);
-
+        const rootNode = await node_index_document_1.NodeIndexDocument.createRootNode(boundingVolumes, this);
+        await (0, tileset_traversal_1.traverseDatasetWith)(sourceRootTile, {
+            transform: new core_2.Matrix4(sourceRootTile.transform),
+            parentNodes: [rootNode]
+        }, this.convertTile.bind(this), this.finalizeTile.bind(this), this.options.maxDepth);
+        this.layers0.materialDefinitions = this.materialDefinitions;
+        // @ts-ignore
+        this.layers0.geometryDefinitions = (0, json_map_transform_1.default)(this.geometryConfigs.map((config) => ({
+            geometryConfig: { ...config, draco: this.options.draco }
+        })), (0, geometry_definitions_1.GEOMETRY_DEFINITION)());
+        if (this.layersHasTexture === false) {
+            this.layers0.store.defaultGeometrySchema.ordering =
+                this.layers0.store.defaultGeometrySchema.ordering.filter((attribute) => attribute !== 'uv0');
+        }
+        await this._writeLayers0();
+        (0, create_scene_server_path_1.createSceneServerPath)(tilesetName, this.layers0, tilesetPath);
+        for (const filePath of this.compressList || []) {
+            await (0, compress_util_1.compressFileWithGzip)(filePath);
+            await (0, file_utils_1.removeFile)(filePath);
+        }
+        await this.nodePages.save();
+        await this.writeQueue.finalize();
+        await this._createSlpk(tilesetPath);
+    }
+    /**
+     * Form object of 3DSceneLayer https://github.com/Esri/i3s-spec/blob/master/docs/1.7/3DSceneLayer.cmn.md
+     * @param tilesetName - Name of layer
+     * @param sourceBoundingVolume - initialized bounding volume of the source root tile
+     * @param boundingVolumeRegion - region bounding volume of the source root tile
+     */
+    _formLayers0(tilesetName, sourceBoundingVolume, boundingVolumeRegion) {
+        if (!this.sourceTileset?.root) {
+            return;
+        }
+        const fullExtent = (0, coordinate_converter_1.convertBoundingVolumeToI3SFullExtent)(sourceBoundingVolume);
+        if (boundingVolumeRegion) {
+            fullExtent.zmin = boundingVolumeRegion[4];
+            fullExtent.zmax = boundingVolumeRegion[5];
+        }
+        const extent = [fullExtent.xmin, fullExtent.ymin, fullExtent.xmax, fullExtent.ymax];
+        const layers0data = {
+            version: `{${(0, uuid_1.v4)().toUpperCase()}}`,
+            id: 0,
+            name: tilesetName,
+            href: './layers/0',
+            store: {
+                id: `{${(0, uuid_1.v4)().toUpperCase()}}`,
+                extent
+            },
+            nodePages: {
+                nodesPerPage: HARDCODED_NODES_PER_PAGE
+            },
+            compressGeometry: this.options.draco,
+            fullExtent
+        };
+        this.layers0 = (0, json_map_transform_1.default)(layers0data, (0, layers_1.LAYERS)());
+    }
+    /**
+     * Write 3DSceneLayer https://github.com/Esri/i3s-spec/blob/master/docs/1.7/3DSceneLayer.cmn.md in file
+     */
+    async _writeLayers0() {
         if (this.options.slpk) {
-          const slpkAttributesPath = join(childPath, 'attributes', folderName);
-          this.fileMap["".concat(slpkChildPath, "/attributes/").concat(folderName, ".bin.gz")] = await writeFileForSlpk(slpkAttributesPath, fileBuffer, '0.bin');
-        } else {
-          const attributesPath = join(childPath, "attributes/".concat(folderName, "/0"));
-          await writeFile(attributesPath, fileBuffer, 'index.bin');
+            await this.writeQueue.enqueue({
+                archiveKey: '3dSceneLayer.json.gz',
+                writePromise: () => (0, file_utils_1.writeFileForSlpk)(this.layers0Path, JSON.stringify(this.layers0), '3dSceneLayer.json')
+            });
+        }
+        else {
+            await this.writeQueue.enqueue({
+                writePromise: () => (0, file_utils_1.writeFile)(this.layers0Path, JSON.stringify(this.layers0))
+            });
         }
-      }
     }
-  }
-
-  _getFormatByMimeType(mimeType) {
-    switch (mimeType) {
-      case 'image/jpeg':
-        return 'jpg';
-
-      case 'image/png':
-        return 'png';
-
-      default:
-        return 'jpg';
+    /**
+     * Pack files into *.slpk archive
+     * @param tilesetPath - Path to save file
+     */
+    async _createSlpk(tilesetPath) {
+        if (this.options.slpk) {
+            const slpkTilesetPath = (0, path_1.join)(tilesetPath, 'SceneServer', 'layers', '0');
+            const slpkFileName = `${tilesetPath}.slpk`;
+            await (0, compress_util_1.compressWithChildProcess)(slpkTilesetPath, slpkFileName, 0, '.', this.options.sevenZipExe);
+            // TODO: `addFileToZip` corrupts archive so it can't be validated with windows i3s_converter.exe
+            // const fileHash128Path = `${tilesetPath}/@specialIndexFileHASH128@`;
+            // try {
+            //   await generateHash128FromZip(slpkFileName, fileHash128Path);
+            //   await addFileToZip(
+            //     tilesetPath,
+            //     '@specialIndexFileHASH128@',
+            //     slpkFileName,
+            //     this.options.sevenZipExe
+            //   );
+            // } catch (error) {
+            //   if (error.code === FS_FILE_TOO_LARGE) {
+            //     console.warn(`${slpkFileName} file is too big to generate a hash`); // eslint-disable-line
+            //   } else {
+            //     console.error(error); // eslint-disable-line
+            //   }
+            // }
+            // All converted files are contained in slpk now they can be deleted
+            try {
+                await (0, file_utils_1.removeDir)(tilesetPath);
+            }
+            catch (e) {
+                // do nothing
+            }
+        }
     }
-  }
-
-  _findOrCreateMaterial(material) {
-    const hash = md5(JSON.stringify(material));
-
-    if (this.materialMap.has(hash)) {
-      return this.materialMap.get(hash);
+    /**
+     * Convert the specific 3DTiles tile to I3S nodes.
+     * This is callback function for the traversal generic function
+     * @param sourceTile - current 3DTiles tile JSON metadata
+     * @param traversalProps - traversal properties calculated recursively
+     * @returns - traversal properties for the child tiles
+     */
+    async convertTile(sourceTile, traversalProps) {
+        if (sourceTile.type === 'json' || sourceTile.type === 'empty') {
+            if (sourceTile.type === 'json') {
+                if (sourceTile.id) {
+                    console.log(`[load]: ${sourceTile.id}`); // eslint-disable-line
+                }
+                await (0, load_3d_tiles_1.loadNestedTileset)(this.sourceTileset, sourceTile, this.loadOptions);
+            }
+            return traversalProps;
+        }
+        if (sourceTile.id) {
+            console.log(`[convert]: ${sourceTile.id}`); // eslint-disable-line
+        }
+        const { parentNodes, transform } = traversalProps;
+        let transformationMatrix = transform.clone();
+        if (sourceTile.transform) {
+            transformationMatrix = transformationMatrix.multiplyRight(sourceTile.transform);
+        }
+        const parentNode = parentNodes[0];
+        const childNodes = await this._createNode(parentNode, sourceTile, transformationMatrix);
+        await parentNode.addChildren(childNodes);
+        const newTraversalProps = {
+            transform: transformationMatrix,
+            parentNodes: childNodes
+        };
+        return newTraversalProps;
+    }
+    /**
+     * Do final action with nodes after the current node and all child nodes been converted.
+     * @param conversionResults - array of conversion results of the current node
+     * @param currentTraversalProps - traversal properties of the current node
+     */
+    async finalizeTile(conversionResults, currentTraversalProps) {
+        for (const result of conversionResults) {
+            for (const node of result.parentNodes) {
+                await node.addNeighbors();
+            }
+        }
+        for (const node of currentTraversalProps.parentNodes) {
+            await node.save();
+        }
     }
-
-    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);
-
+    /**
+     * Convert tile to one or more I3S nodes
+     * @param parentNode - 3DNodeIndexDocument of parent node
+     * @param sourceTile - source 3DTile data
+     * @param transformationMatrix - transformation matrix of the current tile, calculated recursively multiplying
+     *                               transform of all parent tiles and transform of the current tile
+     * @param level - tree level
+     */
+    async _createNode(parentNode, sourceTile, transformationMatrix) {
+        this._checkAddRefinementTypeForTile(sourceTile);
+        await this._updateTilesetOptions();
+        const tileContent = await (0, load_3d_tiles_1.loadTile3DContent)(this.sourceTileset, sourceTile, this.loadOptions);
+        const sourceBoundingVolume = (0, tiles_1.createBoundingVolume)(sourceTile.boundingVolume, transformationMatrix, null);
+        let boundingVolumes = (0, coordinate_converter_1.createBoundingVolumes)(sourceBoundingVolume, this.geoidHeightModel);
+        const propertyTable = (0, geometry_converter_1.getPropertyTable)(tileContent);
+        if (propertyTable && !this.layers0?.attributeStorageInfo?.length) {
+            this._convertPropertyTableToNodeAttributes(propertyTable);
+        }
+        const resourcesData = await this._convertResources(sourceTile, transformationMatrix, sourceBoundingVolume, tileContent, parentNode.inPageId, propertyTable);
+        const nodes = [];
+        const nodeIds = [];
+        const nodesInPage = [];
+        const emptyResources = {
+            geometry: null,
+            compressedGeometry: null,
+            texture: null,
+            hasUvRegions: false,
+            sharedResources: null,
+            meshMaterial: null,
+            vertexCount: null,
+            attributes: null,
+            featureCount: null,
+            boundingVolumes: null
+        };
+        for (const resources of resourcesData || [emptyResources]) {
+            this.layersHasTexture = this.layersHasTexture || Boolean(resources.texture);
+            if (this.generateBoundingVolumes && resources.boundingVolumes) {
+                boundingVolumes = resources.boundingVolumes;
+            }
+            const lodSelection = (0, lod_conversion_utils_1.convertGeometricErrorToScreenThreshold)(sourceTile, boundingVolumes);
+            const maxScreenThresholdSQ = lodSelection.find((val) => val.metricType === 'maxScreenThresholdSQ') || { maxError: 0 };
+            const nodeInPage = await this._updateNodeInNodePages(maxScreenThresholdSQ, boundingVolumes, sourceTile, parentNode.inPageId, resources);
+            const nodeData = await node_index_document_1.NodeIndexDocument.createNodeIndexDocument(parentNode, boundingVolumes, lodSelection, nodeInPage, resources);
+            const node = await new node_index_document_1.NodeIndexDocument(nodeInPage.index, this).addData(nodeData);
+            nodes.push(node);
+            if (nodeInPage.mesh) {
+                await this._writeResources(resources, node.id);
+            }
+            if (this.validate) {
+                this.boundingVolumeWarnings = (0, node_debug_1.validateNodeBoundingVolumes)(nodeData);
+                if (this.boundingVolumeWarnings && this.boundingVolumeWarnings.length) {
+                    console.warn('Bounding Volume Warnings: ', ...this.boundingVolumeWarnings); //eslint-disable-line
+                }
+            }
+            nodeIds.push(nodeInPage.index);
+            nodesInPage.push(nodeInPage);
+        }
+        return nodes;
+    }
+    /**
+     * Convert tile to one or more I3S nodes
+     * @param sourceTile - source tile (3DTile)
+     * @param transformationMatrix - transformation matrix of the current tile, calculated recursively multiplying
+     *                               transform of all parent tiles and transform of the current tile
+     * @param boundingVolume - initialized bounding volume of the source tile
+     * @param tileContent - content of the source tile
+     * @param parentId - id of parent node in node pages
+     * @param propertyTable - batch table from b3dm / feature properties from EXT_FEATURE_METADATA
+     * @returns - converted node resources
+     */
+    async _convertResources(sourceTile, transformationMatrix, boundingVolume, tileContent, parentId, propertyTable) {
+        if (!this.isContentSupported(sourceTile) || !tileContent) {
+            return null;
+        }
+        const draftObb = {
+            center: [],
+            halfSize: [],
+            quaternion: []
+        };
+        const resourcesData = await (0, geometry_converter_1.default)(tileContent, transformationMatrix, boundingVolume, async () => (await this.nodePages.push({ index: 0, obb: draftObb }, parentId)).index, propertyTable, this.featuresHashArray, this.layers0?.attributeStorageInfo, this.options.draco, this.generateBoundingVolumes, this.options.mergeMaterials, this.geoidHeightModel, this.workerSource);
+        return resourcesData;
+    }
+    /**
+     * Update node object (https://github.com/Esri/i3s-spec/blob/master/docs/1.7/node.cmn.md)
+     * in node pages (https://github.com/Esri/i3s-spec/blob/master/docs/1.7/nodePage.cmn.md)
+     * @param maxScreenThresholdSQ - Level of Details (LOD) metric
+     * @param boundingVolumes - Bounding volumes
+     * @param sourceTile - source tile (3DTile)
+     * @param parentId - id of parent node in node pages
+     * @param resources - the node resources data
+     * @param resources.meshMaterial - PBR-like material object
+     * @param resources.texture - texture image
+     * @param resources.vertexCount - number of vertices in geometry
+     * @param resources.featureCount - number of features
+     * @param resources.geometry - Uint8Array with geometry attributes
+     * @return the node object in node pages
+     */
+    async _updateNodeInNodePages(maxScreenThresholdSQ, boundingVolumes, sourceTile, parentId, resources) {
+        const { meshMaterial, texture, vertexCount, featureCount, geometry, hasUvRegions } = resources;
+        const nodeInPage = {
+            index: 0,
+            lodThreshold: maxScreenThresholdSQ.maxError,
+            obb: boundingVolumes.obb,
+            children: []
+        };
+        if (geometry && this.isContentSupported(sourceTile)) {
+            nodeInPage.mesh = {
+                geometry: {
+                    definition: this.findOrCreateGeometryDefinition(Boolean(texture), hasUvRegions),
+                    resource: 0
+                },
+                attribute: {
+                    resource: 0
+                },
+                material: {
+                    definition: 0
+                }
+            };
+        }
+        let nodeId = resources.nodeId;
+        let node;
+        if (!nodeId) {
+            node = await this.nodePages.push(nodeInPage, parentId);
+        }
+        else {
+            node = await this.nodePages.getNodeById(nodeId);
+        }
+        node_pages_1.default.updateAll(node, nodeInPage);
+        if (meshMaterial) {
+            node_pages_1.default.updateMaterialByNodeId(node, this._findOrCreateMaterial(meshMaterial));
+        }
+        if (texture) {
+            const texelCountHint = texture.image.height * texture.image.width;
+            node_pages_1.default.updateTexelCountHintByNodeId(node, texelCountHint);
+        }
+        if (vertexCount) {
+            this.vertexCounter += vertexCount;
+            node_pages_1.default.updateVertexCountByNodeId(node, vertexCount);
+        }
+        node_pages_1.default.updateNodeAttributeByNodeId(node);
+        if (featureCount) {
+            node_pages_1.default.updateFeatureCountByNodeId(node, featureCount);
+        }
+        this.nodePages.saveNode(node);
+        return node;
+    }
+    /**
+     * Write node resources in files
+     * @param resources - source tile (3DTile)
+     * @param resources.geometry - Uint8Array with geometry attributes
+     * @param resources.compressedGeometry - Uint8Array with compressed (draco) geometry
+     * @param resources.texture - texture image
+     * @param resources.sharedResources - shared resource data object
+     * @param resources.attributes - feature attributes
+     * @return {Promise<void>}
+     */
+    async _writeResources(resources, nodePath) {
+        const { geometry: geometryBuffer, compressedGeometry, texture, sharedResources, attributes } = resources;
+        const childPath = (0, path_1.join)(this.layers0Path, 'nodes', nodePath);
+        const slpkChildPath = (0, path_1.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);
+    }
+    /**
+     * Write non-compressed and compressed geometries in files
+     * @param geometryBuffer - Uint8Array with geometry attributes
+     * @param compressedGeometry - Uint8Array with compressed (draco) geometry
+     * @param childPath - a child path to write resources
+     * @param slpkChildPath - resource path inside *slpk file
+     */
+    async _writeGeometries(geometryBuffer, compressedGeometry, childPath, slpkChildPath) {
+        if (this.options.slpk) {
+            const slpkGeometryPath = (0, path_1.join)(childPath, 'geometries');
+            await this.writeQueue.enqueue({
+                archiveKey: `${slpkChildPath}/geometries/0.bin.gz`,
+                writePromise: () => (0, file_utils_1.writeFileForSlpk)(slpkGeometryPath, geometryBuffer, '0.bin')
+            });
+        }
+        else {
+            const geometryPath = (0, path_1.join)(childPath, 'geometries/0/');
+            await this.writeQueue.enqueue({
+                writePromise: () => (0, file_utils_1.writeFile)(geometryPath, geometryBuffer, 'index.bin')
+            });
+        }
+        if (this.options.draco) {
+            if (this.options.slpk) {
+                const slpkCompressedGeometryPath = (0, path_1.join)(childPath, 'geometries');
+                await this.writeQueue.enqueue({
+                    archiveKey: `${slpkChildPath}/geometries/1.bin.gz`,
+                    writePromise: () => (0, file_utils_1.writeFileForSlpk)(slpkCompressedGeometryPath, compressedGeometry, '1.bin')
+                });
+            }
+            else {
+                const compressedGeometryPath = (0, path_1.join)(childPath, 'geometries/1/');
+                await this.writeQueue.enqueue({
+                    writePromise: () => (0, file_utils_1.writeFile)(compressedGeometryPath, compressedGeometry, 'index.bin')
+                });
+            }
+        }
     }
-
-    return storageAttribute;
-  }
-
-  getAttributeType(key, attribute) {
-    if (key === OBJECT_ID_TYPE) {
-      return OBJECT_ID_TYPE;
+    /**
+     * Write shared resources in a file
+     * @param sharedResources - shared resource data object
+     * @param childPath - a child path to write resources
+     * @param slpkChildPath - resource path inside *slpk file
+     * @param nodePath - a node path
+     */
+    async _writeShared(sharedResources, childPath, slpkChildPath, nodePath) {
+        if (!sharedResources) {
+            return;
+        }
+        sharedResources.nodePath = nodePath;
+        const sharedData = (0, json_map_transform_1.default)(sharedResources, (0, shared_resources_1.SHARED_RESOURCES)());
+        const sharedDataStr = JSON.stringify(sharedData);
+        if (this.options.slpk) {
+            const slpkSharedPath = (0, path_1.join)(childPath, 'shared');
+            await this.writeQueue.enqueue({
+                archiveKey: `${slpkChildPath}/shared/sharedResource.json.gz`,
+                writePromise: () => (0, file_utils_1.writeFileForSlpk)(slpkSharedPath, sharedDataStr, 'sharedResource.json')
+            });
+        }
+        else {
+            const sharedPath = (0, path_1.join)(childPath, 'shared/');
+            await this.writeQueue.enqueue({ writePromise: () => (0, file_utils_1.writeFile)(sharedPath, sharedDataStr) });
+        }
     }
-
-    if (typeof attribute === STRING_TYPE) {
-      return STRING_TYPE;
-    } else if (typeof attribute === 'number') {
-      return Number.isInteger(attribute) ? SHORT_INT_TYPE : DOUBLE_TYPE;
+    /**
+     * Generates textures based on texture mime type and fill in textureSetDefinitions data.
+     * @param texture - the texture image
+     * @param childPath - a child path to write resources
+     * @param slpkChildPath - the resource path inside *slpk file
+     */
+    async _writeTexture(texture, childPath, slpkChildPath) {
+        if (texture) {
+            const format = this._getFormatByMimeType(texture?.mimeType);
+            const formats = [];
+            const textureData = texture.bufferView.data;
+            switch (format) {
+                case 'jpg':
+                case 'png': {
+                    formats.push({ name: '0', format });
+                    await this.writeTextureFile(textureData, '0', format, childPath, slpkChildPath);
+                    if (this.generateTextures) {
+                        formats.push({ name: '1', format: 'ktx2' });
+                        // For Node.js texture.image.data is type of Buffer
+                        const copyArrayBuffer = texture.image.data.subarray();
+                        const arrayToEncode = new Uint8Array(copyArrayBuffer);
+                        const ktx2TextureData = (0, core_1.encode)({ ...texture.image, data: arrayToEncode }, textures_1.KTX2BasisWriterWorker, {
+                            ...textures_1.KTX2BasisWriterWorker.options,
+                            source: this.workerSource.ktx2,
+                            reuseWorkers: true,
+                            _nodeWorkers: true
+                        });
+                        await this.writeTextureFile(ktx2TextureData, '1', 'ktx2', childPath, slpkChildPath);
+                    }
+                    break;
+                }
+                case 'ktx2': {
+                    formats.push({ name: '1', format });
+                    await this.writeTextureFile(textureData, '1', format, childPath, slpkChildPath);
+                    if (this.generateTextures) {
+                        formats.push({ name: '0', format: 'jpg' });
+                        const decodedFromKTX2TextureData = (0, core_1.encode)(texture.image.data[0], images_1.ImageWriter);
+                        await this.writeTextureFile(decodedFromKTX2TextureData, '0', 'jpg', childPath, slpkChildPath);
+                    }
+                }
+            }
+            if (!this.layers0.textureSetDefinitions.length) {
+                this.layers0.textureSetDefinitions.push({ formats });
+                this.layers0.textureSetDefinitions.push({ formats, atlas: true });
+            }
+        }
     }
-
-    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;
+    /**
+     * Write the texture image in a file
+     * @param textureData
+     * @param name
+     * @param format
+     * @param childPath
+     * @param slpkChildPath
+     */
+    async writeTextureFile(textureData, name, format, childPath, slpkChildPath) {
+        if (this.options.slpk) {
+            const slpkTexturePath = (0, path_1.join)(childPath, 'textures');
+            const compress = false;
+            await this.writeQueue.enqueue({
+                archiveKey: `${slpkChildPath}/textures/${name}.${format}`,
+                writePromise: () => (0, file_utils_1.writeFileForSlpk)(slpkTexturePath, textureData, `${name}.${format}`, compress)
+            });
+        }
+        else {
+            const texturePath = (0, path_1.join)(childPath, `textures/${name}/`);
+            await this.writeQueue.enqueue({
+                writePromise: () => (0, file_utils_1.writeFile)(texturePath, textureData, `index.${format}`)
+            });
+        }
     }
-  }
-
-  _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';
+    /**
+     * Write feature attributes in files
+     * @param attributes - feature attributes
+     * @param childPath - a child path to write resources
+     * @param slpkChildPath - the resource path inside *slpk file
+     */
+    async _writeAttributes(attributes = [], childPath, slpkChildPath) {
+        if (attributes?.length && 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_1.join)(childPath, 'attributes', folderName);
+                    await this.writeQueue.enqueue({
+                        archiveKey: `${slpkChildPath}/attributes/${folderName}.bin.gz`,
+                        writePromise: () => (0, file_utils_1.writeFileForSlpk)(slpkAttributesPath, fileBuffer, '0.bin')
+                    });
+                }
+                else {
+                    const attributesPath = (0, path_1.join)(childPath, `attributes/${folderName}/0`);
+                    await this.writeQueue.enqueue({
+                        writePromise: () => (0, file_utils_1.writeFile)(attributesPath, fileBuffer, 'index.bin')
+                    });
+                }
+            }
+        }
     }
-  }
-
-  _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
-      });
+    /**
+     * Return file format by its MIME type
+     * @param mimeType - feature attributes
+     */
+    _getFormatByMimeType(mimeType) {
+        switch (mimeType) {
+            case 'image/jpeg':
+                return 'jpg';
+            case 'image/png':
+                return 'png';
+            case 'image/ktx2':
+                return 'ktx2';
+            default:
+                return 'jpg';
+        }
     }
-
-    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 calculateFilesSize(params);
-    const diff = process.hrtime(this.conversionStartTime);
-    const conversionTime = 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() {
-    const options = {
-      'cesium-ion': {
-        accessToken: this.options.token || ION_DEFAULT_TOKEN
-      }
-    };
-    const preloadOptions = await CesiumIonLoader.preload(this.options.inputUrl, options);
-    this.refreshTokenTime = process.hrtime();
-    return { ...options,
-      ...preloadOptions
-    };
-  }
-
-  async _updateTilesetOptions() {
-    const diff = process.hrtime(this.refreshTokenTime);
-
-    if (diff[0] < REFRESH_TOKEN_TIMEOUT) {
-      return;
+    /**
+     * Find or create material in materialDefinitions array
+     * @param material - end-to-end index of the node
+     * @return material id
+     */
+    _findOrCreateMaterial(material) {
+        const hash = (0, md5_1.default)(JSON.stringify(material));
+        if (this.materialMap.has(hash)) {
+            return this.materialMap.get(hash) || 0;
+        }
+        const newMaterialId = this.materialDefinitions.push(material) - 1;
+        this.materialMap.set(hash, newMaterialId);
+        return newMaterialId;
+    }
+    /**
+     * Get unique geometry configuration index
+     * In the end of conversion configurations will be transformed to geometryDefinitions array
+     * @param hasTexture
+     * @param hasUvRegions
+     * @returns
+     */
+    findOrCreateGeometryDefinition(hasTexture, hasUvRegions) {
+        const geometryConfig = { hasTexture, hasUvRegions };
+        const hash = (0, md5_1.default)(JSON.stringify(geometryConfig));
+        if (this.geometryMap.has(hash)) {
+            return this.geometryMap.get(hash) || 0;
+        }
+        const newGeometryId = this.geometryConfigs.push(geometryConfig) - 1;
+        this.geometryMap.set(hash, newGeometryId);
+        return newGeometryId;
+    }
+    /**
+     * Do conversion of 3DTiles property table to I3s node attributes.
+     * @param propertyTable - Table with layer meta data.
+     */
+    _convertPropertyTableToNodeAttributes(propertyTable) {
+        let attributeIndex = 0;
+        const propertyTableWithObjectId = {
+            OBJECTID: [0],
+            ...propertyTable
+        };
+        for (const key in propertyTableWithObjectId) {
+            const firstAttribute = propertyTableWithObjectId[key][0];
+            const attributeType = (0, feature_attributes_1.getAttributeType)(key, firstAttribute);
+            const storageAttribute = (0, feature_attributes_1.createdStorageAttribute)(attributeIndex, key, attributeType);
+            const fieldAttributeType = (0, feature_attributes_1.getFieldAttributeType)(attributeType);
+            const fieldAttribute = (0, feature_attributes_1.createFieldAttribute)(key, fieldAttributeType);
+            const popupInfo = (0, feature_attributes_1.createPopupInfo)(propertyTableWithObjectId);
+            this.layers0.attributeStorageInfo.push(storageAttribute);
+            this.layers0.fields.push(fieldAttribute);
+            this.layers0.popupInfo = popupInfo;
+            this.layers0.layerType = _3D_OBJECT_LAYER_TYPE;
+            attributeIndex += 1;
+        }
     }
-
-    this.refreshTokenTime = process.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');
+    /**
+     * Print statistics in the end of conversion
+     * @param params - output files data
+     */
+    async _finishConversion(params) {
+        const { tilesCount, tilesWithAddRefineCount } = this.refinementCounter;
+        const addRefinementPercentage = tilesWithAddRefineCount
+            ? (tilesWithAddRefineCount / tilesCount) * 100
+            : 0;
+        const filesSize = await (0, statistic_utills_1.calculateFilesSize)(params);
+        const diff = process_1.default.hrtime(this.conversionStartTime);
+        const conversionTime = (0, statistic_utills_1.timeConverter)(diff);
+        console.log(`------------------------------------------------`); // eslint-disable-line no-undef, no-console
+        console.log(`Finishing conversion of ${_3D_TILES}`); // eslint-disable-line no-undef, no-console
+        console.log(`Total conversion time: ${conversionTime}`); // eslint-disable-line no-undef, no-console
+        console.log(`Vertex count: `, this.vertexCounter); // eslint-disable-line no-undef, no-console
+        console.log(`File(s) size: `, filesSize, ' bytes'); // eslint-disable-line no-undef, no-console
+        console.log(`Percentage of tiles with "ADD" refinement type:`, addRefinementPercentage, '%'); // eslint-disable-line no-undef, no-console
+        console.log(`------------------------------------------------`); // eslint-disable-line no-undef, no-console
+    }
+    /**
+     * Fetch preload options for ION tileset
+     */
+    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_1.default.hrtime();
+        return { ...options, ...preloadOptions };
+    }
+    /**
+     * Update options of source tileset
+     */
+    async _updateTilesetOptions() {
+        const diff = process_1.default.hrtime(this.refreshTokenTime);
+        if (diff[0] < REFRESH_TOKEN_TIMEOUT) {
+            return;
+        }
+        this.refreshTokenTime = process_1.default.hrtime();
+        const preloadOptions = await this._fetchPreloadOptions();
+        if (preloadOptions.headers) {
+            this.loadOptions.fetch = {
+                ...this.loadOptions.fetch,
+                headers: preloadOptions.headers
+            };
+            console.log('Authorization Bearer token has been updated'); // eslint-disable-line no-undef, no-console
+        }
     }
-  }
-
-  _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');
+    /** Do calculations of all tiles and tiles with "ADD" type of refinement.
+     * @param tile
+     */
+    _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'); // eslint-disable-line
+        }
+        this.refinementCounter.tilesCount += 1;
+    }
+    /**
+     * Check if the tile's content format is supported by the converter
+     * @param sourceTile
+     * @returns
+     */
+    isContentSupported(sourceTile) {
+        return ['b3dm', 'glTF', 'scenegraph'].includes(sourceTile.type || '');
+    }
+    async loadWorkers() {
+        console.log(`Loading workers source...`); // eslint-disable-line no-undef, no-console
+        if (this.options.draco) {
+            const url = (0, worker_utils_1.getWorkerURL)(draco_1.DracoWriterWorker, { ...(0, core_1.getLoaderOptions)() });
+            const sourceResponse = await (0, core_1.fetchFile)(url);
+            const source = await sourceResponse.text();
+            this.workerSource.draco = source;
+        }
+        if (this.generateTextures) {
+            const url = (0, worker_utils_1.getWorkerURL)(textures_1.KTX2BasisWriterWorker, { ...(0, core_1.getLoaderOptions)() });
+            const sourceResponse = await (0, core_1.fetchFile)(url);
+            const source = await sourceResponse.text();
+            this.workerSource.ktx2 = source;
+        }
+        const i3sAttributesWorkerUrl = (0, worker_utils_1.getWorkerURL)(i3s_attributes_worker_1.I3SAttributesWorker, { ...(0, core_1.getLoaderOptions)() });
+        const sourceResponse = await (0, core_1.fetchFile)(i3sAttributesWorkerUrl);
+        const source = await sourceResponse.text();
+        this.workerSource.I3SAttributes = source;
+        console.log(`Loading workers source completed!`); // eslint-disable-line no-undef, no-console
     }
-
-    this.refinementCounter.tilesCount += 1;
-  }
-
 }
-//# sourceMappingURL=i3s-converter.js.map
+exports.default = I3SConverter;