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

package/src/i3s-converter/i3s-converter.ts

@@ -1,20 +1,11 @@
 import type {Tile3D, Tileset3DProps} from '@loaders.gl/tiles';
-import type {BatchTableJson, B3DMContent} from '@loaders.gl/3d-tiles';
+import type {FeatureTableJson} from '@loaders.gl/3d-tiles';
 import type {WriteQueueItem} from '../lib/utils/write-queue';
 import type {
-  AttributeStorageInfo,
   SceneLayer3D,
   BoundingVolumes,
-  Node3DIndexDocument,
-  NodeReference,
   MaxScreenThresholdSQ,
-  NodeInPage,
-  LodSelection,
-  Attribute,
-  ESRIField,
-  Field,
-  PopupInfo,
-  FieldInfo
+  NodeInPage
 } from '@loaders.gl/i3s';
 import {load, encode, fetchFile, getLoaderOptions, isBrowser} from '@loaders.gl/core';
 import {Tileset3D} from '@loaders.gl/tiles';
@@ -27,14 +18,15 @@ import transform from 'json-map-transform';
 import md5 from 'md5';
 
 import NodePages from './helpers/node-pages';
-import {writeFile, removeDir, writeFileForSlpk} from '../lib/utils/file-utils';
+import {writeFile, removeDir, writeFileForSlpk, removeFile} from '../lib/utils/file-utils';
 import {
+  compressFileWithGzip,
   compressWithChildProcess
   // generateHash128FromZip,
   // addFileToZip
 } from '../lib/utils/compress-util';
 import {calculateFilesSize, timeConverter} from '../lib/utils/statistic-utills';
-import convertB3dmToI3sGeometry from './helpers/geometry-converter';
+import convertB3dmToI3sGeometry, {getPropertyTable} from './helpers/geometry-converter';
 import {
   createBoundingVolumes,
   convertBoundingVolumeToI3SFullExtent
@@ -44,7 +36,7 @@ import {convertGeometricErrorToScreenThreshold} from '../lib/utils/lod-conversio
 import {PGMLoader} from '../pgm-loader';
 
 import {LAYERS as layersTemplate} from './json-templates/layers';
-import {NODE as nodeTemplate} from './json-templates/node';
+import {GEOMETRY_DEFINITION as geometryDefinitionTemlate} from './json-templates/geometry-definitions';
 import {SHARED_RESOURCES as sharedResourcesTemplate} from './json-templates/shared-resources';
 import {validateNodeBoundingVolumes} from './helpers/node-debug';
 import TileHeader from '@loaders.gl/tiles/src/tileset/tile-3d';
@@ -59,6 +51,14 @@ import {DracoWriterWorker} from '@loaders.gl/draco';
 import WriteQueue from '../lib/utils/write-queue';
 import {I3SAttributesWorker} from '../i3s-attributes-worker';
 import {BROWSER_ERROR_MESSAGE} from '../constants';
+import {
+  createdStorageAttribute,
+  createFieldAttribute,
+  createPopupInfo,
+  getAttributeType,
+  getFieldAttributeType
+} from './helpers/feature-attributes';
+import {NodeIndexDocument} from './helpers/node-index-document';
 
 const ION_DEFAULT_TOKEN =
   process.env?.IonToken || // eslint-disable-line
@@ -66,10 +66,6 @@ const ION_DEFAULT_TOKEN =
 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';
@@ -81,8 +77,10 @@ export default class I3SConverter {
   nodePages: NodePages;
   options: any;
   layers0Path: string;
-  materialMap: Map<any, any>;
+  materialMap: Map<string, number>;
   materialDefinitions: I3SMaterialDefinition[];
+  geometryMap: Map<string, number>;
+  geometryConfigs: {hasTexture: boolean; hasUvRegions: boolean}[];
   vertexCounter: number;
   layers0: SceneLayer3D | null;
   featuresHashArray: string[];
@@ -102,13 +100,16 @@ export default class I3SConverter {
   layersHasTexture: boolean;
   workerSource: {[key: string]: string} = {};
   writeQueue: WriteQueue<WriteQueueItem> = new WriteQueue();
+  compressList: string[] | null = null;
 
   constructor() {
-    this.nodePages = new NodePages(writeFile, HARDCODED_NODES_PER_PAGE);
+    this.nodePages = new NodePages(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 = [];
@@ -120,6 +121,7 @@ export default class I3SConverter {
     this.generateTextures = false;
     this.generateBoundingVolumes = false;
     this.layersHasTexture = false;
+    this.compressList = null;
   }
 
   /**
@@ -135,6 +137,9 @@ export default 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: {
     inputUrl: string;
@@ -146,9 +151,11 @@ export default class I3SConverter {
     slpk?: boolean;
     token?: string;
     draco?: boolean;
+    mergeMaterials?: boolean;
     validate?: boolean;
     generateTextures?: boolean;
     generateBoundingVolumes?: boolean;
+    instantNodeWriting?: boolean;
   }): Promise<any> {
     if (isBrowser) {
       console.log(BROWSER_ERROR_MESSAGE);
@@ -162,14 +169,27 @@ export default class I3SConverter {
       inputUrl,
       validate,
       outputPath,
-      draco,
+      draco = true,
       sevenZipExe,
       maxDepth,
       token,
       generateTextures,
-      generateBoundingVolumes
+      generateBoundingVolumes,
+      instantNodeWriting = false,
+      mergeMaterials = true
     } = options;
-    this.options = {maxDepth, slpk, sevenZipExe, egmFilePath, draco, token, inputUrl};
+    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 ? CesiumIonLoader : Tiles3DLoader;
     this.generateTextures = Boolean(generateTextures);
@@ -190,7 +210,18 @@ export default class I3SConverter {
 
     try {
       const preloadOptions = await this._fetchPreloadOptions();
-      const tilesetOptions: Tileset3DProps = {loadOptions: {basis: {format: 'rgba32'}}};
+      const tilesetOptions: Tileset3DProps = {
+        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};
       }
@@ -199,7 +230,11 @@ export default class I3SConverter {
       // console.log(tilesetJson); // eslint-disable-line
       this.sourceTileset = new 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;
     } catch (error) {
@@ -216,7 +251,11 @@ export default class I3SConverter {
    * @param outputPath - path to save output data
    * @param tilesetName - new tileset path
    */
-  private async _createAndSaveTileset(outputPath: string, tilesetName: string): Promise<void> {
+  private async _createAndSaveTileset(
+    outputPath: string,
+    tilesetName: string,
+    boundingVolumeRegion?: number[]
+  ): Promise<void> {
     const tilesetPath = join(`${outputPath}`, `${tilesetName}`);
     // Removing the tilesetPath needed to exclude erroneous files after conversion
     try {
@@ -227,26 +266,31 @@ export default class I3SConverter {
 
     this.layers0Path = join(tilesetPath, 'SceneServer', 'layers', '0');
 
-    this._formLayers0(tilesetName);
+    this._formLayers0(tilesetName, boundingVolumeRegion);
 
     this.materialDefinitions = [];
     this.materialMap = new Map();
 
     const sourceRootTile: TileHeader = this.sourceTileset!.root!;
     const boundingVolumes = 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 NodeIndexDocument.createRootNode(boundingVolumes, this);
+    await this._convertNodesTree(rootNode, sourceRootTile);
 
     this.layers0!.materialDefinitions = this.materialDefinitions;
+    // @ts-ignore
+    this.layers0.geometryDefinitions = transform(
+      this.geometryConfigs.map((config) => ({
+        geometryConfig: {...config, draco: this.options.draco}
+      })),
+      geometryDefinitionTemlate()
+    );
 
     if (this.layersHasTexture === false) {
       this.layers0!.store.defaultGeometrySchema.ordering =
@@ -257,8 +301,11 @@ export default class I3SConverter {
 
     await this._writeLayers0();
     createSceneServerPath(tilesetName, this.layers0!, tilesetPath);
-    await this._writeNodeIndexDocument(root0, 'root', join(this.layers0Path, 'nodes', 'root'));
-    await this.nodePages.save(this.layers0Path, this.writeQueue, isCreateSlpk);
+    for (const filePath of this.compressList || []) {
+      await compressFileWithGzip(filePath);
+      await removeFile(filePath);
+    }
+    await this.nodePages.save();
     await this.writeQueue.finalize();
     await this._createSlpk(tilesetPath);
   }
@@ -267,10 +314,14 @@ export default 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
    */
-  private _formLayers0(tilesetName: string): void {
+  private _formLayers0(tilesetName: string, boundingVolumeRegion?: number[]): void {
     const fullExtent = 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: `{${uuidv4().toUpperCase()}}`,
@@ -290,77 +341,31 @@ export default class I3SConverter {
     this.layers0 = transform(layers0data, layersTemplate());
   }
 
-  /**
-   * 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
-   */
-  private _formRootNodeIndexDocument(boundingVolumes: BoundingVolumes): Node3DIndexDocument {
-    const root0data = {
-      version: `{${uuidv4().toUpperCase()}}`,
-      id: 'root',
-      level: 0,
-      lodSelection: [
-        {
-          metricType: 'maxScreenThresholdSQ',
-          maxError: 0
-        },
-        {
-          metricType: 'maxScreenThreshold',
-          maxError: 0
-        }
-      ],
-      ...boundingVolumes,
-      children: []
-    };
-    return transform(root0data, nodeTemplate());
-  }
-
   /**
    * 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
    */
   private async _convertNodesTree(
-    root0: Node3DIndexDocument,
-    sourceRootTile: TileHeader,
-    parentId: number,
-    boundingVolumes: BoundingVolumes
+    rootNode: NodeIndexDocument,
+    sourceRootTile: TileHeader
   ): Promise<void> {
     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 = join(this.layers0Path, 'nodes', child.path!);
-
-      if (this.options.slpk) {
-        this.writeQueue.enqueue({
-          archiveKey: 'nodes/1/3dNodeIndexDocument.json.gz',
-          writePromise: writeFileForSlpk(
-            childPath,
-            JSON.stringify(child),
-            '3dNodeIndexDocument.json'
-          )
-        });
-      } else {
-        this.writeQueue.enqueue({writePromise: 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();
   }
 
   /**
@@ -368,36 +373,15 @@ export default class I3SConverter {
    */
   private async _writeLayers0(): Promise<void> {
     if (this.options.slpk) {
-      this.writeQueue.enqueue({
+      await this.writeQueue.enqueue({
         archiveKey: '3dSceneLayer.json.gz',
-        writePromise: writeFileForSlpk(
-          this.layers0Path,
-          JSON.stringify(this.layers0),
-          '3dSceneLayer.json'
-        )
+        writePromise: () =>
+          writeFileForSlpk(this.layers0Path, JSON.stringify(this.layers0), '3dSceneLayer.json')
       });
     } else {
-      this.writeQueue.enqueue({
-        writePromise: 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
-   */
-  private async _writeNodeIndexDocument(
-    root0: Node3DIndexDocument,
-    nodePath: string,
-    rootPath: string
-  ): Promise<void> {
-    if (this.options.slpk) {
-      this.writeQueue.enqueue({
-        archiveKey: `nodes/${nodePath}/3dNodeIndexDocument.json.gz`,
-        writePromise: writeFileForSlpk(rootPath, JSON.stringify(root0), '3dNodeIndexDocument.json')
+      await this.writeQueue.enqueue({
+        writePromise: () => writeFile(this.layers0Path, JSON.stringify(this.layers0))
       });
-    } else {
-      this.writeQueue.enqueue({writePromise: writeFile(rootPath, JSON.stringify(root0))});
     }
   }
 
@@ -446,146 +430,141 @@ export default 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)
    */
   private async _addChildrenWithNeighborsAndWriteFile(data: {
-    parentNode: Node3DIndexDocument;
+    parentNode: NodeIndexDocument;
     sourceTiles: TileHeader[];
-    parentId: number;
     level: number;
   }): Promise<void> {
-    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
+   */
+  private async convertNestedTileset({
+    parentNode,
+    sourceTile,
+    level
+  }: {
+    parentNode: NodeIndexDocument;
+    sourceTile: TileHeader;
+    level: number;
+  }) {
+    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
+   */
+  private async convertNode({
+    parentNode,
+    sourceTile,
+    level
+  }: {
+    parentNode: NodeIndexDocument;
+    sourceTile: TileHeader;
+    level: number;
+  }) {
+    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
    */
   private async _addChildren(data: {
-    childNodes: NodeReference[];
+    parentNode: NodeIndexDocument;
     sourceTiles: TileHeader[];
-    parentNode: Node3DIndexDocument;
-    parentId: number;
     level: number;
   }): Promise<void> {
-    const {childNodes, sourceTiles, parentNode, parentId, level} = data;
+    const {sourceTiles, parentNode, level} = data;
     if (this.options.maxDepth && level > this.options.maxDepth) {
       return;
     }
+
+    const promises: Promise<void>[] = [];
     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
-   */
-  private async _addNeighborsAndWriteFile(
-    parentNode: Node3DIndexDocument,
-    childNodes: Node3DIndexDocument[]
-  ): Promise<void> {
-    for (const node of childNodes) {
-      const childPath = 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
    */
   private async _createNode(
-    parentTile: Node3DIndexDocument,
+    parentNode: NodeIndexDocument,
     sourceTile: TileHeader,
-    parentId: number,
     level: number
-  ): Promise<Node3DIndexDocument[]> {
-    if (this.validate) {
-      this._checkAddRefinementTypeForTile(sourceTile);
-    }
+  ): Promise<NodeIndexDocument[]> {
+    this._checkAddRefinementTypeForTile(sourceTile);
 
     await this._updateTilesetOptions();
     await this.sourceTileset!._loadTile(sourceTile);
 
     let boundingVolumes = createBoundingVolumes(sourceTile, this.geoidHeightModel!);
 
-    const batchTable = sourceTile?.content?.batchTableJson;
+    const propertyTable = getPropertyTable(sourceTile.content);
 
-    if (batchTable) {
-      this._convertAttributeStorageInfo(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: Node3DIndexDocument[] = [];
+    const nodes: NodeIndexDocument[] = [];
+    const nodeIds: number[] = [];
     const nodesInPage: NodeInPage[] = [];
     const emptyResources = {
       geometry: null,
       compressedGeometry: null,
       texture: null,
+      hasUvRegions: false,
       sharedResources: null,
       meshMaterial: null,
       vertexCount: null,
@@ -606,34 +585,37 @@ export default class I3SConverter {
         (val) => val.metricType === 'maxScreenThresholdSQ'
       ) || {maxError: 0};
 
-      const nodeInPage = this._createNodeInNodePages(
+      const nodeInPage = await this._updateNodeInNodePages(
         maxScreenThresholdSQ,
         boundingVolumes,
         sourceTile,
-        parentId,
+        parentNode.inPageId,
         resources
       );
-      const node = this._createNodeIndexDocument(
-        parentTile,
+
+      const nodeData = await NodeIndexDocument.createNodeIndexDocument(
+        parentNode,
         boundingVolumes,
         lodSelection,
         nodeInPage,
         resources
       );
+      const node = await new 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 = validateNodeBoundingVolumes(node);
+        this.boundingVolumeWarnings = 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);
     }
 
@@ -642,49 +624,40 @@ export default class I3SConverter {
     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}
-   */
-  private _convertAttributeStorageInfo(sourceTileContent: B3DMContent): void {
-    // 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
    */
-  private async _convertResources(sourceTile: TileHeader): Promise<I3SConvertedResources[] | null> {
+  private async _convertResources(
+    sourceTile: TileHeader,
+    parentId: number,
+    propertyTable: FeatureTableJson | null
+  ): Promise<I3SConvertedResources[] | null> {
     if (!this.isContentSupported(sourceTile)) {
       return null;
     }
+    const draftObb = {
+      center: [],
+      halfSize: [],
+      quaternion: []
+    };
     const resourcesData = await convertB3dmToI3sGeometry(
       sourceTile.content,
-      Number(this.nodePages.nodesCounter),
+      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
     );
@@ -692,7 +665,7 @@ export default class I3SConverter {
   }
 
   /**
-   * 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
@@ -703,16 +676,17 @@ export default 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
    */
-  private _createNodeInNodePages(
+  private async _updateNodeInNodePages(
     maxScreenThresholdSQ: MaxScreenThresholdSQ,
     boundingVolumes: BoundingVolumes,
     sourceTile: TileHeader,
     parentId: number,
     resources: I3SConvertedResources
-  ): NodeInPage {
-    const {meshMaterial, texture, vertexCount, featureCount, geometry} = resources;
+  ): Promise<NodeInPage> {
+    const {meshMaterial, texture, vertexCount, featureCount, geometry, hasUvRegions} = resources;
     const nodeInPage: NodeInPage = {
       index: 0,
       lodThreshold: maxScreenThresholdSQ.maxError,
@@ -722,7 +696,7 @@ export default class I3SConverter {
     if (geometry && this.isContentSupported(sourceTile)) {
       nodeInPage.mesh = {
         geometry: {
-          definition: texture ? 0 : 1,
+          definition: this.findOrCreateGeometryDefinition(Boolean(texture), hasUvRegions),
           resource: 0
         },
         attribute: {
@@ -733,83 +707,33 @@ export default class I3SConverter {
         }
       };
     }
-    const nodeId = this.nodePages.push(nodeInPage, parentId);
 
-    if (meshMaterial) {
-      this.nodePages.updateMaterialByNodeId(nodeId, this._findOrCreateMaterial(meshMaterial));
+    let nodeId = resources.nodeId;
+    let node;
+    if (!nodeId) {
+      node = await this.nodePages.push(nodeInPage, parentId);
+    } else {
+      node = await this.nodePages.getNodeById(nodeId);
     }
 
+    NodePages.updateAll(node, nodeInPage);
+    if (meshMaterial) {
+      NodePages.updateMaterialByNodeId(node, this._findOrCreateMaterial(meshMaterial));
+    }
     if (texture) {
       const texelCountHint = texture.image.height * texture.image.width;
-      this.nodePages.updateTexelCountHintByNodeId(nodeId, texelCountHint);
+      NodePages.updateTexelCountHintByNodeId(node, texelCountHint);
     }
-
     if (vertexCount) {
       this.vertexCounter += vertexCount;
-      this.nodePages.updateVertexCountByNodeId(nodeId, vertexCount);
+      NodePages.updateVertexCountByNodeId(node, vertexCount);
     }
-    this.nodePages.updateNodeAttributeByNodeId(nodeId);
+    NodePages.updateNodeAttributeByNodeId(node);
     if (featureCount) {
-      this.nodePages.updateFeatureCountByNodeId(nodeId, featureCount);
+      NodePages.updateFeatureCountByNodeId(node, 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
-   */
-  private _createNodeIndexDocument(
-    parentNode: Node3DIndexDocument,
-    boundingVolumes: BoundingVolumes,
-    lodSelection: LodSelection[],
-    nodeInPage: NodeInPage,
-    resources: I3SConvertedResources
-  ): Node3DIndexDocument {
-    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 = transform(nodeData, nodeTemplate());
-
-    if (nodeInPage.mesh) {
-      node.geometryData = [{href: './geometries/0'}];
-      node.sharedResource = {href: './shared'};
-
-      if (texture) {
-        node.textureData = [{href: './textures/0'}, {href: './textures/1'}];
-      }
-
-      if (attributes && attributes.length && this.layers0?.attributeStorageInfo?.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`});
-        }
-      }
-    }
+    this.nodePages.saveNode(node);
 
     return node;
   }
@@ -856,28 +780,29 @@ export default class I3SConverter {
   ): Promise<void> {
     if (this.options.slpk) {
       const slpkGeometryPath = join(childPath, 'geometries');
-      this.writeQueue.enqueue({
+      await this.writeQueue.enqueue({
         archiveKey: `${slpkChildPath}/geometries/0.bin.gz`,
-        writePromise: writeFileForSlpk(slpkGeometryPath, geometryBuffer, '0.bin')
+        writePromise: () => writeFileForSlpk(slpkGeometryPath, geometryBuffer, '0.bin')
       });
     } else {
       const geometryPath = join(childPath, 'geometries/0/');
-      this.writeQueue.enqueue({
-        writePromise: writeFile(geometryPath, geometryBuffer, 'index.bin')
+      await this.writeQueue.enqueue({
+        writePromise: () => writeFile(geometryPath, geometryBuffer, 'index.bin')
       });
     }
 
     if (this.options.draco) {
       if (this.options.slpk) {
         const slpkCompressedGeometryPath = join(childPath, 'geometries');
-        this.writeQueue.enqueue({
+        await this.writeQueue.enqueue({
           archiveKey: `${slpkChildPath}/geometries/1.bin.gz`,
-          writePromise: writeFileForSlpk(slpkCompressedGeometryPath, compressedGeometry, '1.bin')
+          writePromise: () =>
+            writeFileForSlpk(slpkCompressedGeometryPath, compressedGeometry, '1.bin')
         });
       } else {
         const compressedGeometryPath = join(childPath, 'geometries/1/');
-        this.writeQueue.enqueue({
-          writePromise: writeFile(compressedGeometryPath, compressedGeometry, 'index.bin')
+        await this.writeQueue.enqueue({
+          writePromise: () => writeFile(compressedGeometryPath, compressedGeometry, 'index.bin')
         });
       }
     }
@@ -904,13 +829,13 @@ export default class I3SConverter {
     const sharedDataStr = JSON.stringify(sharedData);
     if (this.options.slpk) {
       const slpkSharedPath = join(childPath, 'shared');
-      this.writeQueue.enqueue({
+      await this.writeQueue.enqueue({
         archiveKey: `${slpkChildPath}/shared/sharedResource.json.gz`,
-        writePromise: writeFileForSlpk(slpkSharedPath, sharedDataStr, 'sharedResource.json')
+        writePromise: () => writeFileForSlpk(slpkSharedPath, sharedDataStr, 'sharedResource.json')
       });
     } else {
       const sharedPath = join(childPath, 'shared/');
-      this.writeQueue.enqueue({writePromise: writeFile(sharedPath, sharedDataStr)});
+      await this.writeQueue.enqueue({writePromise: () => writeFile(sharedPath, sharedDataStr)});
     }
   }
 
@@ -978,6 +903,7 @@ export default class I3SConverter {
 
       if (!this.layers0!.textureSetDefinitions!.length) {
         this.layers0!.textureSetDefinitions!.push({formats});
+        this.layers0!.textureSetDefinitions!.push({formats, atlas: true});
       }
     }
   }
@@ -1001,14 +927,15 @@ export default class I3SConverter {
       const slpkTexturePath = join(childPath, 'textures');
       const compress = false;
 
-      this.writeQueue.enqueue({
+      await this.writeQueue.enqueue({
         archiveKey: `${slpkChildPath}/textures/${name}.${format}`,
-        writePromise: writeFileForSlpk(slpkTexturePath, textureData, `${name}.${format}`, compress)
+        writePromise: () =>
+          writeFileForSlpk(slpkTexturePath, textureData, `${name}.${format}`, compress)
       });
     } else {
       const texturePath = join(childPath, `textures/${name}/`);
-      this.writeQueue.enqueue({
-        writePromise: writeFile(texturePath, textureData, `index.${format}`)
+      await this.writeQueue.enqueue({
+        writePromise: () => writeFile(texturePath, textureData, `index.${format}`)
       });
     }
   }
@@ -1031,14 +958,14 @@ export default class I3SConverter {
 
         if (this.options.slpk) {
           const slpkAttributesPath = join(childPath, 'attributes', folderName);
-          this.writeQueue.enqueue({
+          await this.writeQueue.enqueue({
             archiveKey: `${slpkChildPath}/attributes/${folderName}.bin.gz`,
-            writePromise: writeFileForSlpk(slpkAttributesPath, fileBuffer, '0.bin')
+            writePromise: () => writeFileForSlpk(slpkAttributesPath, fileBuffer, '0.bin')
           });
         } else {
           const attributesPath = join(childPath, `attributes/${folderName}/0`);
-          this.writeQueue.enqueue({
-            writePromise: writeFile(attributesPath, fileBuffer, 'index.bin')
+          await this.writeQueue.enqueue({
+            writePromise: () => writeFile(attributesPath, fileBuffer, 'index.bin')
           });
         }
       }
@@ -1070,7 +997,7 @@ export default class I3SConverter {
   private _findOrCreateMaterial(material: I3SMaterialDefinition): number {
     const hash = md5(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);
@@ -1078,133 +1005,42 @@ export default class I3SConverter {
   }
 
   /**
-   * 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.
-   */
-  private _createdStorageAttribute(
-    attributeIndex: number,
-    key: string,
-    attributeType: Attribute
-  ): AttributeStorageInfo {
-    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
    */
-  private getAttributeType(key: string, attribute: string): string {
-    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;
+  private findOrCreateGeometryDefinition(hasTexture: boolean, hasUvRegions: boolean): number {
+    const geometryConfig = {hasTexture, hasUvRegions};
+    const hash = md5(JSON.stringify(geometryConfig));
+    if (this.geometryMap.has(hash)) {
+      return this.geometryMap.get(hash) || 0;
     }
-    return STRING_TYPE;
-  }
-
-  /**
-   * Setup storage attribute as string.
-   * @param storageAttribute - attribute for map segmentation.
-   */
-  private _setupStringAttribute(storageAttribute: AttributeStorageInfo): void {
-    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 .
-   */
-  private _setupIdAttribute(storageAttribute: AttributeStorageInfo): void {
-    storageAttribute.attributeValues = {
-      valueType: 'Oid32',
-      valuesPerElement: 1
-    };
-  }
-
-  /**
-   * Setup double attribute for map segmentation.
-   * @param storageAttribute - attribute for map segmentation .
-   */
-  private _setupDoubleAttribute(storageAttribute: AttributeStorageInfo): void {
-    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').
-   */
-  private _createFieldAttribute(key: string, fieldAttributeType: ESRIField): Field {
-    return {
-      name: key,
-      type: fieldAttributeType,
-      alias: key
-    };
+    const newGeometryId = this.geometryConfigs.push(geometryConfig) - 1;
+    this.geometryMap.set(hash, newGeometryId);
+    return newGeometryId;
   }
 
   /**
-   * Do conversion of 3DTiles batch table to I3s node attributes.
-   * @param batchTable - Table with layer meta data.
+   * Do conversion of 3DTiles property table to I3s node attributes.
+   * @param propertyTable - Table with layer meta data.
    */
-  private _convertBatchTableInfoToNodeAttributes(batchTable: BatchTableJson): void {
+  private _convertPropertyTableToNodeAttributes(propertyTable: FeatureTableJson): void {
     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);
+    for (const key in propertyTableWithObjectId) {
+      const firstAttribute = propertyTableWithObjectId[key][0];
+      const attributeType = 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);
+      const storageAttribute = createdStorageAttribute(attributeIndex, key, attributeType);
+      const fieldAttributeType = getFieldAttributeType(attributeType);
+      const fieldAttribute = createFieldAttribute(key, fieldAttributeType);
+      const popupInfo = createPopupInfo(propertyTableWithObjectId);
 
       this.layers0!.attributeStorageInfo!.push(storageAttribute);
       this.layers0!.fields!.push(fieldAttribute);
@@ -1215,62 +1051,6 @@ export default class I3SConverter {
     }
   }
 
-  /**
-   * Find and return attribute type based on key form Batch table.
-   * @param attributeType
-   */
-  private _getFieldAttributeType(attributeType: Attribute): ESRIField {
-    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.
-   */
-  private _createPopupInfo(batchTable: BatchTableJson): PopupInfo {
-    const title = '{OBJECTID}';
-    const mediaInfos = [];
-    const fieldInfos: FieldInfo[] = [];
-    const popupElements: {
-      fieldInfos: FieldInfo[];
-      type: string;
-    }[] = [];
-    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