@loaders.gl/tile-converter 3.1.8 → 3.2.0-alpha.3

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

@@ -0,0 +1,1074 @@
+"use strict";
+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 tiles_1 = require("@loaders.gl/tiles");
+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 = __importDefault(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 node_1 = require("./json-templates/node");
+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 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 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; // 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.geoidHeightModel = null;
+        this.Loader = _3d_tiles_1.Tiles3DLoader;
+        this.workerSource = {};
+        this.writeQueue = new write_queue_1.default();
+        this.nodePages = new node_pages_1.default(file_utils_1.writeFile, HARDCODED_NODES_PER_PAGE);
+        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.generateTextures = false;
+        this.generateBoundingVolumes = false;
+        this.layersHasTexture = false;
+    }
+    /**
+     * 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
+     */
+    async convert(options) {
+        this.conversionStartTime = process_1.default.hrtime();
+        const { tilesetName, slpk, egmFilePath, inputUrl, validate, outputPath, draco, sevenZipExe, maxDepth, token, generateTextures, generateBoundingVolumes } = options;
+        this.options = { maxDepth, slpk, sevenZipExe, egmFilePath, draco, token, inputUrl };
+        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();
+            const tilesetOptions = { loadOptions: { basis: { format: 'rgba32' } } };
+            if (preloadOptions.headers) {
+                tilesetOptions.loadOptions.fetch = { headers: preloadOptions.headers };
+            }
+            Object.assign(tilesetOptions, preloadOptions);
+            const sourceTilesetJson = await (0, core_1.load)(inputUrl, this.Loader, tilesetOptions.loadOptions);
+            // console.log(tilesetJson); // eslint-disable-line
+            this.sourceTileset = new tiles_1.Tileset3D(sourceTilesetJson, tilesetOptions);
+            await this._createAndSaveTileset(outputPath, tilesetName);
+            await this._finishConversion({ slpk: Boolean(slpk), outputPath, tilesetName });
+            return sourceTilesetJson;
+        }
+        catch (error) {
+            throw error;
+        }
+        finally {
+            // Clean up worker pools
+            const workerFarm = worker_utils_1.WorkerFarm.getWorkerFarm({});
+            workerFarm.destroy();
+        }
+    }
+    /**
+     * 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._formLayers0(tilesetName);
+        this.materialDefinitions = [];
+        this.materialMap = new Map();
+        const sourceRootTile = this.sourceTileset.root;
+        const boundingVolumes = (0, coordinate_converter_1.createBoundingVolumes)(sourceRootTile, this.geoidHeightModel);
+        const parentId = this.nodePages.push({
+            index: 0,
+            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;
+        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);
+        await this._writeNodeIndexDocument(root0, 'root', (0, path_1.join)(this.layers0Path, 'nodes', 'root'));
+        await this.nodePages.save(this.layers0Path, this.writeQueue, isCreateSlpk);
+        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
+     */
+    _formLayers0(tilesetName) {
+        const fullExtent = (0, coordinate_converter_1.convertBoundingVolumeToI3SFullExtent)(this.sourceTileset?.boundingVolume || this.sourceTileset?.root?.boundingVolume);
+        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
+        };
+        this.layers0 = (0, json_map_transform_1.default)(layers0data, (0, layers_1.LAYERS)());
+    }
+    /**
+     * Convert and save the layer and embedded tiles
+     * @param boundingVolumes - mbs and obb data about node's bounding volume
+     * @return 3DNodeIndexDocument data https://github.com/Esri/i3s-spec/blob/master/docs/1.7/3DNodeIndexDocument.cmn.md
+     */
+    _formRootNodeIndexDocument(boundingVolumes) {
+        const root0data = {
+            version: `{${(0, uuid_1.v4)().toUpperCase()}}`,
+            id: 'root',
+            level: 0,
+            lodSelection: [
+                {
+                    metricType: 'maxScreenThresholdSQ',
+                    maxError: 0
+                },
+                {
+                    metricType: 'maxScreenThreshold',
+                    maxError: 0
+                }
+            ],
+            ...boundingVolumes,
+            children: []
+        };
+        return (0, json_map_transform_1.default)(root0data, (0, node_1.NODE)());
+    }
+    /**
+     * Form object of 3DSceneLayer https://github.com/Esri/i3s-spec/blob/master/docs/1.7/3DSceneLayer.cmn.md
+     * @param root0 - 3DNodeIndexDocument of root node https://github.com/Esri/i3s-spec/blob/master/docs/1.7/3DNodeIndexDocument.cmn.md
+     * @param sourceRootTile - Source (3DTile) tile data
+     * @param parentId - node id in node pages
+     * @param boundingVolumes - mbs and obb data about node's bounding volume
+     */
+    async _convertNodesTree(root0, sourceRootTile, parentId, boundingVolumes) {
+        await this.sourceTileset._loadTile(sourceRootTile);
+        if (this.isContentSupported(sourceRootTile)) {
+            root0.children = root0.children || [];
+            root0.children.push({
+                id: '1',
+                href: './1',
+                ...boundingVolumes
+            });
+            const [child] = await this._createNode(root0, sourceRootTile, parentId, 0);
+            const childPath = (0, path_1.join)(this.layers0Path, 'nodes', child.path);
+            if (this.options.slpk) {
+                this.writeQueue.enqueue({
+                    archiveKey: 'nodes/1/3dNodeIndexDocument.json.gz',
+                    writePromise: (0, file_utils_1.writeFileForSlpk)(childPath, JSON.stringify(child), '3dNodeIndexDocument.json')
+                });
+            }
+            else {
+                this.writeQueue.enqueue({ writePromise: (0, file_utils_1.writeFile)(childPath, JSON.stringify(child)) });
+            }
+        }
+        else {
+            await this._addChildrenWithNeighborsAndWriteFile({
+                parentNode: root0,
+                sourceTiles: sourceRootTile.children,
+                parentId,
+                level: 1
+            });
+        }
+        await sourceRootTile.unloadContent();
+    }
+    /**
+     * Write 3DSceneLayer https://github.com/Esri/i3s-spec/blob/master/docs/1.7/3DSceneLayer.cmn.md in file
+     */
+    async _writeLayers0() {
+        if (this.options.slpk) {
+            this.writeQueue.enqueue({
+                archiveKey: '3dSceneLayer.json.gz',
+                writePromise: (0, file_utils_1.writeFileForSlpk)(this.layers0Path, JSON.stringify(this.layers0), '3dSceneLayer.json')
+            });
+        }
+        else {
+            this.writeQueue.enqueue({
+                writePromise: (0, file_utils_1.writeFile)(this.layers0Path, JSON.stringify(this.layers0))
+            });
+        }
+    }
+    /**
+     * Write 3DNodeIndexDocument https://github.com/Esri/i3s-spec/blob/master/docs/1.7/3DNodeIndexDocument.cmn.md in file
+     */
+    async _writeNodeIndexDocument(root0, nodePath, rootPath) {
+        if (this.options.slpk) {
+            this.writeQueue.enqueue({
+                archiveKey: `nodes/${nodePath}/3dNodeIndexDocument.json.gz`,
+                writePromise: (0, file_utils_1.writeFileForSlpk)(rootPath, JSON.stringify(root0), '3dNodeIndexDocument.json')
+            });
+        }
+        else {
+            this.writeQueue.enqueue({ writePromise: (0, file_utils_1.writeFile)(rootPath, JSON.stringify(root0)) });
+        }
+    }
+    /**
+     * 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
+            }
+        }
+    }
+    /**
+     * Add child nodes recursively and write them to files
+     * @param data - arguments
+     * @param data.sourceTiles - array of source child nodes
+     * @param data.parentNode - 3DNodeIndexDocument of parent node for processing child nodes
+     * @param data.parentId - id of parent node in node pages
+     * @param data.level - level of node (distanse to root node in the tree)
+     */
+    async _addChildrenWithNeighborsAndWriteFile(data) {
+        const childNodes = [];
+        await this._addChildren({ ...data, childNodes });
+        await this._addNeighborsAndWriteFile(data.parentNode, childNodes);
+    }
+    /**
+     * Add child nodes recursively and write them to files
+     * @param data - arguments
+     * @param data.childNodes - array of target child nodes
+     * @param data.sourceTiles - array of source child nodes
+     * @param data.parentNode - 3DNodeIndexDocument of parent node for processing child nodes
+     * @param data.parentId - id of parent node in node pages
+     * @param data.level - level of node (distanse to root node in the tree)
+     */
+    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 children = await this._createNode(parentNode, sourceTile, parentId, level);
+                parentNode.children = parentNode.children || [];
+                for (const child of children) {
+                    parentNode.children.push({
+                        id: child.id,
+                        href: `../${child.path}`,
+                        obb: child.obb,
+                        mbs: child.mbs
+                    });
+                    childNodes.push(child);
+                }
+            }
+            if (sourceTile.id) {
+                console.log(sourceTile.id); // eslint-disable-line
+            }
+        }
+    }
+    /**
+     * Add neightbors to 3DNodeIndexDocument and write it in a file
+     * @param parentNode - arguments
+     * @param childNodes - array of target child nodes
+     */
+    async _addNeighborsAndWriteFile(parentNode, childNodes) {
+        for (const node of childNodes) {
+            const childPath = (0, path_1.join)(this.layers0Path, 'nodes', node.path);
+            const nodePath = node.path;
+            delete node.path;
+            // Don't do large amount of "neightbors" to avoid big memory consumption
+            if (Number(parentNode?.children?.length) < 1000) {
+                for (const neighbor of parentNode.children || []) {
+                    // eslint-disable-next-line max-depth
+                    if (node.id === neighbor.id) {
+                        continue; // eslint-disable-line
+                    }
+                    if (node.neighbors) {
+                        node.neighbors.push({ ...neighbor });
+                    }
+                }
+            }
+            else {
+                // eslint-disable-next-line no-console, no-undef
+                console.warn(`Node ${node.id}: neighbors attribute is omited because of large number of neigbors`);
+                delete node.neighbors;
+            }
+            await this._writeNodeIndexDocument(node, nodePath, childPath);
+            node.neighbors = [];
+        }
+    }
+    /**
+     * Convert tile to one or more I3S nodes
+     * @param parentTile - parent 3DNodeIndexDocument
+     * @param sourceTile - source tile (3DTile)
+     * @param parentId - id of parent node in node pages
+     * @param level - level of node (distanse to root node in the tree)
+     */
+    async _createNode(parentTile, sourceTile, parentId, level) {
+        if (this.validate) {
+            this._checkAddRefinementTypeForTile(sourceTile);
+        }
+        await this._updateTilesetOptions();
+        await this.sourceTileset._loadTile(sourceTile);
+        let boundingVolumes = (0, coordinate_converter_1.createBoundingVolumes)(sourceTile, this.geoidHeightModel);
+        const batchTable = sourceTile?.content?.batchTableJson;
+        if (batchTable) {
+            this._convertAttributeStorageInfo(sourceTile.content);
+        }
+        const resourcesData = await this._convertResources(sourceTile);
+        const nodes = [];
+        const nodesInPage = [];
+        const emptyResources = {
+            geometry: null,
+            compressedGeometry: null,
+            texture: null,
+            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 = 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, node_debug_1.validateNodeBoundingVolumes)(node);
+                if (this.boundingVolumeWarnings && this.boundingVolumeWarnings.length) {
+                    console.warn('Bounding Volume Warnings: ', ...this.boundingVolumeWarnings); //eslint-disable-line
+                }
+            }
+            nodes.push(node);
+            nodesInPage.push(nodeInPage);
+        }
+        sourceTile.unloadContent();
+        await this._addChildrenWithNeighborsAndWriteFile({
+            parentNode: nodes[0],
+            sourceTiles: sourceTile.children,
+            parentId: nodesInPage[0].index,
+            level: level + 1
+        });
+        return nodes;
+    }
+    /**
+     * Convert attributesStorageInfo https://github.com/Esri/i3s-spec/blob/master/docs/1.7/attributeStorageInfo.cmn.md
+     * from B3DM batch table
+     * @param sourceTileContent - tile content of 3DTile
+     * @return {void}
+     */
+    _convertAttributeStorageInfo(sourceTileContent) {
+        // In legacy b3dm files sometimes sourceTileContent is null.
+        const batchTable = sourceTileContent && sourceTileContent.batchTableJson;
+        if (batchTable && !this.layers0?.attributeStorageInfo?.length) {
+            this._convertBatchTableInfoToNodeAttributes(batchTable);
+        }
+    }
+    /**
+     * Convert tile to one or more I3S nodes
+     * @param sourceTile - source tile (3DTile)
+     * result.geometry - ArrayBuffer with geometry attributes
+     * result.compressedGeometry - ArrayBuffer with compressed (draco) geometry
+     * result.texture - texture image
+     * result.sharedResources - shared resource data object
+     * result.meshMaterial - PBR-like material object
+     * result.vertexCount - number of vertices in geometry
+     * result.attributes - feature attributes
+     * result.featureCount - number of features
+     */
+    async _convertResources(sourceTile) {
+        if (!this.isContentSupported(sourceTile)) {
+            return null;
+        }
+        const resourcesData = await (0, geometry_converter_1.default)(sourceTile.content, Number(this.nodePages.nodesCounter), this.featuresHashArray, this.layers0?.attributeStorageInfo, this.options.draco, this.generateBoundingVolumes, this.geoidHeightModel, this.workerSource);
+        return resourcesData;
+    }
+    /**
+     * Create a new 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
+     * @return the node object in node pages
+     */
+    _createNodeInNodePages(maxScreenThresholdSQ, boundingVolumes, sourceTile, parentId, resources) {
+        const { meshMaterial, texture, vertexCount, featureCount, geometry } = resources;
+        const nodeInPage = {
+            index: 0,
+            lodThreshold: maxScreenThresholdSQ.maxError,
+            obb: boundingVolumes.obb,
+            children: []
+        };
+        if (geometry && this.isContentSupported(sourceTile)) {
+            nodeInPage.mesh = {
+                geometry: {
+                    definition: texture ? 0 : 1,
+                    resource: 0
+                },
+                attribute: {
+                    resource: 0
+                },
+                material: {
+                    definition: 0
+                }
+            };
+        }
+        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;
+    }
+    /**
+     * Create a new node page object in node pages
+     * @param parentNode - 3DNodeIndexDocument https://github.com/Esri/i3s-spec/blob/master/docs/1.7/3DNodeIndexDocument.cmn.md object of the parent node
+     * @param boundingVolumes - Bounding volumes
+     * @param lodSelection - Level of Details (LOD) metrics
+     * @param nodeInPage - corresponding node object in a node page
+     * @param resources - the node resources data
+     * @param resources.texture - texture image
+     * @param resources.attributes - feature attributes
+     * @return 3DNodeIndexDocument https://github.com/Esri/i3s-spec/blob/master/docs/1.7/3DNodeIndexDocument.cmn.md object
+     */
+    _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: `../${parentNode.id}`,
+                mbs: parentNode.mbs,
+                obb: parentNode.obb
+            },
+            children: [],
+            neighbors: []
+        };
+        const node = (0, json_map_transform_1.default)(nodeData, (0, node_1.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?.length) {
+                node.attributeData = [];
+                for (let index = 0; index < attributes.length; index++) {
+                    const folderName = this.layers0.attributeStorageInfo[index].key;
+                    node.attributeData.push({ href: `./attributes/${folderName}/0` });
+                }
+            }
+        }
+        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');
+            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/');
+            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');
+                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/');
+                this.writeQueue.enqueue({
+                    writePromise: (0, file_utils_1.writeFile)(compressedGeometryPath, compressedGeometry, 'index.bin')
+                });
+            }
+        }
+    }
+    /**
+     * 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');
+            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/');
+            this.writeQueue.enqueue({ writePromise: (0, file_utils_1.writeFile)(sharedPath, sharedDataStr) });
+        }
+    }
+    /**
+     * 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' });
+                        const ktx2TextureData = (0, core_1.encode)(texture.image, 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 });
+            }
+        }
+    }
+    /**
+     * 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;
+            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}/`);
+            this.writeQueue.enqueue({
+                writePromise: (0, file_utils_1.writeFile)(texturePath, textureData, `index.${format}`)
+            });
+        }
+    }
+    /**
+     * 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);
+                    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`);
+                    this.writeQueue.enqueue({
+                        writePromise: (0, file_utils_1.writeFile)(attributesPath, fileBuffer, 'index.bin')
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * 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';
+        }
+    }
+    /**
+     * 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);
+        }
+        const newMaterialId = this.materialDefinitions.push(material) - 1;
+        this.materialMap.set(hash, newMaterialId);
+        return newMaterialId;
+    }
+    /**
+     * Generate storage attribute for map segmentation.
+     * @param attributeIndex - order index of attribute (f_0, f_1 ...).
+     * @param key - attribute key from batch table.\
+     * @param attributeType - attribute type.
+     * @return Updated storageAttribute.
+     */
+    _createdStorageAttribute(attributeIndex, key, attributeType) {
+        const storageAttribute = {
+            key: `f_${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;
+    }
+    /**
+     * Get the attribute type for attributeStorageInfo https://github.com/Esri/i3s-spec/blob/master/docs/1.7/attributeStorageInfo.cmn.md
+     * @param key - attribute's key
+     * @param attribute - attribute's type in batchTable
+     */
+    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;
+    }
+    /**
+     * Setup storage attribute as string.
+     * @param storageAttribute - attribute for map segmentation.
+     */
+    _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
+        };
+    }
+    /**
+     * Setup Id attribute for map segmentation.
+     * @param storageAttribute - attribute for map segmentation .
+     */
+    _setupIdAttribute(storageAttribute) {
+        storageAttribute.attributeValues = {
+            valueType: 'Oid32',
+            valuesPerElement: 1
+        };
+    }
+    /**
+     * Setup double attribute for map segmentation.
+     * @param storageAttribute - attribute for map segmentation .
+     */
+    _setupDoubleAttribute(storageAttribute) {
+        storageAttribute.attributeValues = {
+            valueType: 'Float64',
+            valuesPerElement: 1
+        };
+    }
+    /**
+     * Setup field attribute for map segmentation.
+     * @param key - attribute for map segmentation.
+     * @param fieldAttributeType - esri attribute type ('esriFieldTypeString' or 'esriFieldTypeOID').
+     */
+    _createFieldAttribute(key, fieldAttributeType) {
+        return {
+            name: key,
+            type: fieldAttributeType,
+            alias: key
+        };
+    }
+    /**
+     * Do conversion of 3DTiles batch table to I3s node attributes.
+     * @param batchTable - Table with layer meta data.
+     */
+    _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;
+        }
+    }
+    /**
+     * Find and return attribute type based on key form Batch table.
+     * @param attributeType
+     */
+    _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';
+        }
+    }
+    /**
+     * Generate popup info to show metadata on the map.
+     * @param batchTable - Batch table data with OBJECTID.
+     * @return data for correct rendering of popup.
+     */
+    _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
+        };
+    }
+    /**
+     * 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();
+        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'); // eslint-disable-line no-undef, no-console
+        }
+    }
+    /** 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 sourceRootTile
+     * @returns
+     */
+    isContentSupported(sourceRootTile) {
+        return ['b3dm', 'glTF'].includes(sourceRootTile?.content?.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
+    }
+}
+exports.default = I3SConverter;