@loaders.gl/tile-converter 3.3.0-alpha.1 → 3.3.0-alpha.10

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

@@ -1,4 +1,27 @@
 "use strict";
+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 };
 };
@@ -15,13 +38,13 @@ 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 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 node_1 = require("./json-templates/node");
+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");
@@ -31,15 +54,13 @@ 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 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';
@@ -56,11 +77,14 @@ class I3SConverter {
         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.compressList = null;
+        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 = [];
@@ -72,6 +96,7 @@ class I3SConverter {
         this.generateTextures = false;
         this.generateBoundingVolumes = false;
         this.layersHasTexture = false;
+        this.compressList = null;
     }
     /**
      * Convert a 3d tileset
@@ -86,6 +111,9 @@ class I3SConverter {
      * @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) {
@@ -93,8 +121,19 @@ class I3SConverter {
             return constants_1.BROWSER_ERROR_MESSAGE;
         }
         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 };
+        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);
@@ -110,7 +149,18 @@ class I3SConverter {
         await this.loadWorkers();
         try {
             const preloadOptions = await this._fetchPreloadOptions();
-            const tilesetOptions = { loadOptions: { basis: { format: 'rgba32' } } };
+            const tilesetOptions = {
+                loadOptions: {
+                    _nodeWorkers: true,
+                    reuseWorkers: true,
+                    basis: { format: 'rgba32' },
+                    'basis-nodejs': {
+                        format: 'rgba32',
+                        workerUrl: './modules/textures/dist/basis-nodejs-worker.js'
+                    },
+                    'draco-nodejs': { workerUrl: './modules/draco/dist/draco-nodejs-worker.js' }
+                }
+            };
             if (preloadOptions.headers) {
                 tilesetOptions.loadOptions.fetch = { headers: preloadOptions.headers };
             }
@@ -118,7 +168,7 @@ class I3SConverter {
             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._createAndSaveTileset(outputPath, tilesetName, sourceTilesetJson?.root?.boundingVolume?.region);
             await this._finishConversion({ slpk: Boolean(slpk), outputPath, tilesetName });
             return sourceTilesetJson;
         }
@@ -136,7 +186,7 @@ class I3SConverter {
      * @param outputPath - path to save output data
      * @param tilesetName - new tileset path
      */
-    async _createAndSaveTileset(outputPath, tilesetName) {
+    async _createAndSaveTileset(outputPath, tilesetName, boundingVolumeRegion) {
         const tilesetPath = (0, path_1.join)(`${outputPath}`, `${tilesetName}`);
         // Removing the tilesetPath needed to exclude erroneous files after conversion
         try {
@@ -146,29 +196,35 @@ class I3SConverter {
             // do nothing
         }
         this.layers0Path = (0, path_1.join)(tilesetPath, 'SceneServer', 'layers', '0');
-        this._formLayers0(tilesetName);
+        this._formLayers0(tilesetName, boundingVolumeRegion);
         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({
+        await 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);
+        const rootNode = await node_index_document_1.NodeIndexDocument.createRootNode(boundingVolumes, this);
+        await this._convertNodesTree(rootNode, sourceRootTile);
         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);
-        await this._writeNodeIndexDocument(root0, 'root', (0, path_1.join)(this.layers0Path, 'nodes', 'root'));
-        await this.nodePages.save(this.layers0Path, this.writeQueue, isCreateSlpk);
+        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);
     }
@@ -176,8 +232,12 @@ class I3SConverter {
      * 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) {
+    _formLayers0(tilesetName, boundingVolumeRegion) {
         const fullExtent = (0, coordinate_converter_1.convertBoundingVolumeToI3SFullExtent)(this.sourceTileset?.boundingVolume || this.sourceTileset?.root?.boundingVolume);
+        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()}}`,
@@ -196,99 +256,46 @@ class I3SConverter {
         };
         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 rootNode - 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) {
+    async _convertNodesTree(rootNode, sourceRootTile) {
         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)) });
+            const childNodes = await this._createNode(rootNode, sourceRootTile, 0);
+            for (const childNode of childNodes) {
+                await childNode.save();
             }
+            await rootNode.addChildren(childNodes);
         }
         else {
             await this._addChildrenWithNeighborsAndWriteFile({
-                parentNode: root0,
+                parentNode: rootNode,
                 sourceTiles: sourceRootTile.children,
-                parentId,
                 level: 1
             });
         }
         await sourceRootTile.unloadContent();
+        await rootNode.save();
     }
     /**
      * 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({
+            await this.writeQueue.enqueue({
                 archiveKey: '3dSceneLayer.json.gz',
-                writePromise: (0, file_utils_1.writeFileForSlpk)(this.layers0Path, JSON.stringify(this.layers0), '3dSceneLayer.json')
+                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))
+            await 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
@@ -327,116 +334,101 @@ class I3SConverter {
     /**
      * Add child nodes recursively and write them to files
      * @param data - arguments
+     * @param data.parentNode - 3DNodeIndexDocument of parent node
      * @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);
+        await this._addChildren(data);
+        await data.parentNode.addNeighbors();
+    }
+    /**
+     * Convert nested subtree of 3DTiles dataset
+     * @param param0
+     * @param data.parentNode - 3DNodeIndexDocument of parent node
+     * @param param0.sourceTile - source 3DTile data
+     * @param param0.level - tree level
+     */
+    async convertNestedTileset({ parentNode, sourceTile, level }) {
+        await this.sourceTileset._loadTile(sourceTile);
+        await this._addChildren({
+            parentNode,
+            sourceTiles: sourceTile.children,
+            level: level + 1
+        });
+        await sourceTile.unloadContent();
+    }
+    /**
+     * Convert 3DTiles tile to I3S node
+     * @param param0
+     * @param param0.parentNode - 3DNodeIndexDocument of parent node
+     * @param param0.sourceTile - source 3DTile data
+     * @param param0.level - tree level
+     */
+    async convertNode({ parentNode, sourceTile, level }) {
+        const childNodes = await this._createNode(parentNode, sourceTile, level);
+        await parentNode.addChildren(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)
+     * @param param0 - arguments
+     * @param param0.parentNode - 3DNodeIndexDocument of parent node
+     * @param param0.sourceTile - source 3DTile data
+     * @param param0.level - tree level
      */
     async _addChildren(data) {
-        const { childNodes, sourceTiles, parentNode, parentId, level } = data;
+        const { sourceTiles, parentNode, level } = data;
         if (this.options.maxDepth && level > this.options.maxDepth) {
             return;
         }
+        const promises = [];
         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();
+                if (this.options.instantNodeWriting) {
+                    await this.convertNestedTileset({ parentNode, sourceTile, level });
+                }
+                else {
+                    promises.push(this.convertNestedTileset({ parentNode, sourceTile, level }));
+                }
             }
             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 (this.options.instantNodeWriting) {
+                    await this.convertNode({ parentNode, sourceTile, level });
+                }
+                else {
+                    promises.push(this.convertNode({ parentNode, sourceTile, level }));
                 }
             }
             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 = [];
-        }
+        await Promise.all(promises);
     }
     /**
      * 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)
+     * @param parentNode - 3DNodeIndexDocument of parent node
+     * @param sourceTile - source 3DTile data
+     * @param level - tree level
      */
-    async _createNode(parentTile, sourceTile, parentId, level) {
-        if (this.validate) {
-            this._checkAddRefinementTypeForTile(sourceTile);
-        }
+    async _createNode(parentNode, sourceTile, level) {
+        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 propertyTable = (0, geometry_converter_1.getPropertyTable)(sourceTile.content);
+        if (propertyTable && !this.layers0?.attributeStorageInfo?.length) {
+            this._convertPropertyTableToNodeAttributes(propertyTable);
         }
-        const resourcesData = await this._convertResources(sourceTile);
+        const resourcesData = await this._convertResources(sourceTile, 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,
@@ -451,63 +443,51 @@ class I3SConverter {
             }
             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);
+            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.path);
+                await this._writeResources(resources, node.id);
             }
             if (this.validate) {
-                this.boundingVolumeWarnings = (0, node_debug_1.validateNodeBoundingVolumes)(node);
+                this.boundingVolumeWarnings = (0, node_debug_1.validateNodeBoundingVolumes)(nodeData);
                 if (this.boundingVolumeWarnings && this.boundingVolumeWarnings.length) {
                     console.warn('Bounding Volume Warnings: ', ...this.boundingVolumeWarnings); //eslint-disable-line
                 }
             }
-            nodes.push(node);
+            nodeIds.push(nodeInPage.index);
             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
+     * @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) {
+    async _convertResources(sourceTile, parentId, propertyTable) {
         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);
+        const draftObb = {
+            center: [],
+            halfSize: [],
+            quaternion: []
+        };
+        const resourcesData = await (0, geometry_converter_1.default)(sourceTile.content, 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;
     }
     /**
-     * Create a new node object (https://github.com/Esri/i3s-spec/blob/master/docs/1.7/node.cmn.md)
+     * 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
@@ -518,10 +498,11 @@ class I3SConverter {
      * @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
      */
-    _createNodeInNodePages(maxScreenThresholdSQ, boundingVolumes, sourceTile, parentId, resources) {
-        const { meshMaterial, texture, vertexCount, featureCount, geometry } = resources;
+    async _updateNodeInNodePages(maxScreenThresholdSQ, boundingVolumes, sourceTile, parentId, resources) {
+        const { meshMaterial, texture, vertexCount, featureCount, geometry, hasUvRegions } = resources;
         const nodeInPage = {
             index: 0,
             lodThreshold: maxScreenThresholdSQ.maxError,
@@ -531,7 +512,7 @@ class I3SConverter {
         if (geometry && this.isContentSupported(sourceTile)) {
             nodeInPage.mesh = {
                 geometry: {
-                    definition: texture ? 0 : 1,
+                    definition: this.findOrCreateGeometryDefinition(Boolean(texture), hasUvRegions),
                     resource: 0
                 },
                 attribute: {
@@ -542,69 +523,31 @@ class I3SConverter {
                 }
             };
         }
-        const nodeId = this.nodePages.push(nodeInPage, parentId);
+        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) {
-            this.nodePages.updateMaterialByNodeId(nodeId, this._findOrCreateMaterial(meshMaterial));
+            node_pages_1.default.updateMaterialByNodeId(node, this._findOrCreateMaterial(meshMaterial));
         }
         if (texture) {
             const texelCountHint = texture.image.height * texture.image.width;
-            this.nodePages.updateTexelCountHintByNodeId(nodeId, texelCountHint);
+            node_pages_1.default.updateTexelCountHintByNodeId(node, texelCountHint);
         }
         if (vertexCount) {
             this.vertexCounter += vertexCount;
-            this.nodePages.updateVertexCountByNodeId(nodeId, vertexCount);
+            node_pages_1.default.updateVertexCountByNodeId(node, vertexCount);
         }
-        this.nodePages.updateNodeAttributeByNodeId(nodeId);
+        node_pages_1.default.updateNodeAttributeByNodeId(node);
         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` });
-                }
-            }
+            node_pages_1.default.updateFeatureCountByNodeId(node, featureCount);
         }
+        this.nodePages.saveNode(node);
         return node;
     }
     /**
@@ -636,29 +579,29 @@ class I3SConverter {
     async _writeGeometries(geometryBuffer, compressedGeometry, childPath, slpkChildPath) {
         if (this.options.slpk) {
             const slpkGeometryPath = (0, path_1.join)(childPath, 'geometries');
-            this.writeQueue.enqueue({
+            await this.writeQueue.enqueue({
                 archiveKey: `${slpkChildPath}/geometries/0.bin.gz`,
-                writePromise: (0, file_utils_1.writeFileForSlpk)(slpkGeometryPath, geometryBuffer, '0.bin')
+                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')
+            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');
-                this.writeQueue.enqueue({
+                await this.writeQueue.enqueue({
                     archiveKey: `${slpkChildPath}/geometries/1.bin.gz`,
-                    writePromise: (0, file_utils_1.writeFileForSlpk)(slpkCompressedGeometryPath, compressedGeometry, '1.bin')
+                    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')
+                await this.writeQueue.enqueue({
+                    writePromise: () => (0, file_utils_1.writeFile)(compressedGeometryPath, compressedGeometry, 'index.bin')
                 });
             }
         }
@@ -679,14 +622,14 @@ class I3SConverter {
         const sharedDataStr = JSON.stringify(sharedData);
         if (this.options.slpk) {
             const slpkSharedPath = (0, path_1.join)(childPath, 'shared');
-            this.writeQueue.enqueue({
+            await this.writeQueue.enqueue({
                 archiveKey: `${slpkChildPath}/shared/sharedResource.json.gz`,
-                writePromise: (0, file_utils_1.writeFileForSlpk)(slpkSharedPath, sharedDataStr, 'sharedResource.json')
+                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) });
+            await this.writeQueue.enqueue({ writePromise: () => (0, file_utils_1.writeFile)(sharedPath, sharedDataStr) });
         }
     }
     /**
@@ -732,6 +675,7 @@ class I3SConverter {
             }
             if (!this.layers0.textureSetDefinitions.length) {
                 this.layers0.textureSetDefinitions.push({ formats });
+                this.layers0.textureSetDefinitions.push({ formats, atlas: true });
             }
         }
     }
@@ -747,15 +691,15 @@ class I3SConverter {
         if (this.options.slpk) {
             const slpkTexturePath = (0, path_1.join)(childPath, 'textures');
             const compress = false;
-            this.writeQueue.enqueue({
+            await this.writeQueue.enqueue({
                 archiveKey: `${slpkChildPath}/textures/${name}.${format}`,
-                writePromise: (0, file_utils_1.writeFileForSlpk)(slpkTexturePath, textureData, `${name}.${format}`, compress)
+                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}`)
+            await this.writeQueue.enqueue({
+                writePromise: () => (0, file_utils_1.writeFile)(texturePath, textureData, `index.${format}`)
             });
         }
     }
@@ -772,15 +716,15 @@ class I3SConverter {
                 const fileBuffer = new Uint8Array(attributes[index]);
                 if (this.options.slpk) {
                     const slpkAttributesPath = (0, path_1.join)(childPath, 'attributes', folderName);
-                    this.writeQueue.enqueue({
+                    await this.writeQueue.enqueue({
                         archiveKey: `${slpkChildPath}/attributes/${folderName}.bin.gz`,
-                        writePromise: (0, file_utils_1.writeFileForSlpk)(slpkAttributesPath, fileBuffer, '0.bin')
+                        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')
+                    await this.writeQueue.enqueue({
+                        writePromise: () => (0, file_utils_1.writeFile)(attributesPath, fileBuffer, 'index.bin')
                     });
                 }
             }
@@ -810,127 +754,46 @@ class I3SConverter {
     _findOrCreateMaterial(material) {
         const hash = (0, md5_1.default)(JSON.stringify(material));
         if (this.materialMap.has(hash)) {
-            return this.materialMap.get(hash);
+            return this.materialMap.get(hash) || 0;
         }
         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
+     * Get unique geometry configuration index
+     * In the end of conversion configurations will be transformed to geometryDefinitions array
+     * @param hasTexture
+     * @param hasUvRegions
+     * @returns
      */
-    getAttributeType(key, attribute) {
-        if (key === OBJECT_ID_TYPE) {
-            return OBJECT_ID_TYPE;
+    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;
         }
-        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
-        };
+        const newGeometryId = this.geometryConfigs.push(geometryConfig) - 1;
+        this.geometryMap.set(hash, newGeometryId);
+        return newGeometryId;
     }
     /**
-     * Setup field attribute for map segmentation.
-     * @param key - attribute for map segmentation.
-     * @param fieldAttributeType - esri attribute type ('esriFieldTypeString' or 'esriFieldTypeOID').
+     * Do conversion of 3DTiles property table to I3s node attributes.
+     * @param propertyTable - Table with layer meta data.
      */
-    _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) {
+    _convertPropertyTableToNodeAttributes(propertyTable) {
         let attributeIndex = 0;
-        const batchTableWithObjectId = {
+        const propertyTableWithObjectId = {
             OBJECTID: [0],
-            ...batchTable
+            ...propertyTable
         };
-        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);
+        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;
@@ -938,55 +801,6 @@ class I3SConverter {
             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