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

package/src/i3s-converter/helpers/load-3d-tiles.ts

@@ -4,7 +4,8 @@ import type {
   Tiles3DTileJSONPostprocessed,
   Tiles3DTilesetJSONPostprocessed
 } from '@loaders.gl/3d-tiles';
-import {load} from '@loaders.gl/core';
+import {Tiles3DArchiveFileSystem} from '@loaders.gl/3d-tiles';
+import {LoaderWithParser, load} from '@loaders.gl/core';
 
 /**
  * Load nested 3DTiles tileset. If the sourceTile is not nested tileset - do nothing
@@ -18,7 +19,7 @@ export const loadNestedTileset = async (
   sourceTile: Tiles3DTileJSONPostprocessed,
   tilesetLoadOptions: Tiles3DLoaderOptions
 ): Promise<void> => {
-  const isTileset = sourceTile.type === 'json';
+  const isTileset = isNestedTileset(sourceTile);
   if (!sourceTileset || !sourceTile.contentUrl || !isTileset) {
     return;
   }
@@ -30,7 +31,11 @@ export const loadNestedTileset = async (
       assetGltfUpAxis: (sourceTileset.asset && sourceTileset.asset.gltfUpAxis) || 'Y'
     }
   };
-  const tileContent = await load(sourceTile.contentUrl, sourceTileset.loader, loadOptions);
+  const tileContent = await loadFromArchive(
+    sourceTile.contentUrl,
+    sourceTileset.loader,
+    loadOptions
+  );
 
   if (tileContent.root) {
     sourceTile.children = [tileContent.root];
@@ -49,7 +54,7 @@ export const loadTile3DContent = async (
   sourceTile: Tiles3DTileJSONPostprocessed,
   tilesetLoadOptions: Tiles3DLoaderOptions
 ): Promise<Tiles3DTileContent | null> => {
-  const isTileset = sourceTile.type === 'json';
+  const isTileset = isNestedTileset(sourceTile);
   if (!sourceTileset || !sourceTile.contentUrl || isTileset) {
     return null;
   }
@@ -62,7 +67,58 @@ export const loadTile3DContent = async (
       assetGltfUpAxis: (sourceTileset.asset && sourceTileset.asset.gltfUpAxis) || 'Y'
     }
   };
-  const tileContent = await load(sourceTile.contentUrl, sourceTileset.loader, loadOptions);
+  const tileContent = await loadFromArchive(
+    sourceTile.contentUrl,
+    sourceTileset.loader,
+    loadOptions
+  );
 
   return tileContent;
 };
+
+/**
+ * Load a resource with load options and .3tz format support
+ * @param url - resource URL
+ * @param loader - loader to parse data (Tiles3DLoader / CesiumIonLoader)
+ * @param loadOptions - 3d-tiles loader options
+ * @returns 3d-tiles resource
+ */
+export async function loadFromArchive(
+  url: string,
+  loader: LoaderWithParser,
+  loadOptions: Tiles3DLoaderOptions
+) {
+  const tz3UrlParts = url.split('.3tz');
+  let filename: string | null;
+  // No '.3tz'. The file will be loaded with global fetch function
+  if (tz3UrlParts.length === 1) {
+    filename = null;
+  } else if (tz3UrlParts.length === 2) {
+    filename = tz3UrlParts[1].slice(1);
+    if (filename === '') {
+      filename = 'tileset.json';
+    }
+  } else {
+    throw new Error('Unexpected URL format');
+  }
+  if (filename) {
+    const tz3Path = `${tz3UrlParts[0]}.3tz`;
+    const fileSystem = new Tiles3DArchiveFileSystem(tz3Path);
+    const content = await load(filename, loader, {
+      ...loadOptions,
+      fetch: fileSystem.fetch.bind(fileSystem)
+    });
+    await fileSystem.destroy();
+    return content;
+  }
+  return await load(url, loader, loadOptions);
+}
+
+/**
+ * Check if tile is nested tileset
+ * @param tile - 3DTiles header data
+ * @returns true if tile is nested tileset
+ */
+export function isNestedTileset(tile: Tiles3DTileJSONPostprocessed) {
+  return tile?.type === 'json' || tile?.type === '3tz';
+}

package/src/i3s-converter/helpers/node-index-document.ts

@@ -323,7 +323,11 @@ export class NodeIndexDocument {
         parentNode.converter.layers0?.attributeStorageInfo?.length
       ) {
         node.attributeData = [];
-        for (let index = 0; index < attributes.length; index++) {
+        const minimumLength =
+          attributes.length < parentNode.converter.layers0.attributeStorageInfo.length
+            ? attributes.length
+            : parentNode.converter.layers0.attributeStorageInfo.length;
+        for (let index = 0; index < minimumLength; index++) {
           const folderName = parentNode.converter.layers0.attributeStorageInfo[index].key;
           node.attributeData.push({href: `./attributes/${folderName}/0`});
         }

package/src/i3s-converter/helpers/preprocess-3d-tiles.ts

@@ -1,38 +1,44 @@
-import {Tiles3DTileContent, Tiles3DTileJSONPostprocessed} from '@loaders.gl/3d-tiles';
-import {GltfPrimitiveModeString, PreprocessData} from '../types';
-import {GLTF, GLTFLoader} from '@loaders.gl/gltf';
+import {Tiles3DTileContent} from '@loaders.gl/3d-tiles';
+import {GLTFPrimitiveModeString, PreprocessData} from '../types';
+import {
+  EXT_STRUCTURAL_METADATA,
+  GLTF,
+  GLTFLoader,
+  GLTF_EXT_feature_metadata_GLTF,
+  GLTF_EXT_structural_metadata_GLTF
+} from '@loaders.gl/gltf';
 import {parse} from '@loaders.gl/core';
+import {EXT_FEATURE_METADATA} from '@loaders.gl/gltf';
 
 /**
  * glTF primitive modes
  * @see https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#_mesh_primitive_mode
  */
 export const GLTF_PRIMITIVE_MODES = [
-  GltfPrimitiveModeString.POINTS, // 0
-  GltfPrimitiveModeString.LINES, // 1
-  GltfPrimitiveModeString.LINE_LOOP, // 2
-  GltfPrimitiveModeString.LINE_STRIP, // 3
-  GltfPrimitiveModeString.TRIANGLES, // 4
-  GltfPrimitiveModeString.TRIANGLE_STRIP, // 5
-  GltfPrimitiveModeString.TRIANGLE_FAN // 6
+  GLTFPrimitiveModeString.POINTS, // 0
+  GLTFPrimitiveModeString.LINES, // 1
+  GLTFPrimitiveModeString.LINE_LOOP, // 2
+  GLTFPrimitiveModeString.LINE_STRIP, // 3
+  GLTFPrimitiveModeString.TRIANGLES, // 4
+  GLTFPrimitiveModeString.TRIANGLE_STRIP, // 5
+  GLTFPrimitiveModeString.TRIANGLE_FAN // 6
 ];
 
 /**
  * Analyze tile content. This function is used during preprocess stage of
  * conversion
- * @param tile - 3DTiles tile JSON metadata
  * @param tileContent - 3DTiles tile content ArrayBuffer
  * @returns
  */
 export const analyzeTileContent = async (
-  tile: Tiles3DTileJSONPostprocessed,
   tileContent: Tiles3DTileContent | null
 ): Promise<PreprocessData> => {
-  const result: PreprocessData = {
-    meshTopologyTypes: new Set()
+  const defaultResult = {
+    meshTopologyTypes: new Set<GLTFPrimitiveModeString>(),
+    metadataClasses: new Set<string>()
   };
   if (!tileContent?.gltfArrayBuffer) {
-    return result;
+    return defaultResult;
   }
 
   const gltfData = await parse(tileContent.gltfArrayBuffer, GLTFLoader, {
@@ -41,11 +47,14 @@ export const analyzeTileContent = async (
   const gltf = gltfData.json;
 
   if (!gltf) {
-    return result;
+    return defaultResult;
   }
-  const meshTypes = getMeshTypesFromGltf(gltf);
-  result.meshTopologyTypes = meshTypes;
-  return result;
+  const meshTopologyTypes = getMeshTypesFromGLTF(gltf);
+  const metadataClasses = getMetadataClassesFromGLTF(gltf);
+  return {
+    meshTopologyTypes,
+    metadataClasses
+  };
 };
 
 /**
@@ -53,8 +62,8 @@ export const analyzeTileContent = async (
  * @param gltfJson - JSON part of GLB content
  * @returns array of mesh types found
  */
-const getMeshTypesFromGltf = (gltfJson: GLTF): Set<GltfPrimitiveModeString> => {
-  const result: Set<GltfPrimitiveModeString> = new Set();
+const getMeshTypesFromGLTF = (gltfJson: GLTF): Set<GLTFPrimitiveModeString> => {
+  const result: Set<GLTFPrimitiveModeString> = new Set();
   for (const mesh of gltfJson.meshes || []) {
     for (const primitive of mesh.primitives) {
       let {mode} = primitive;
@@ -67,6 +76,41 @@ const getMeshTypesFromGltf = (gltfJson: GLTF): Set<GltfPrimitiveModeString> => {
   return result;
 };
 
+/**
+ * Get feature metadata classes from glTF
+ * The tileset might contain multiple metadata classes provided by EXT_feature_metadata and EXT_structural_metadata extensions.
+ * Every class is a set of properties. But I3S can consume only one set of properties.
+ * On the pre-process we collect all classes from the tileset in order to show the prompt to select one class for conversion to I3S.
+ * @param gltfJson - JSON part of GLB content
+ * @returns array of classes
+ */
+const getMetadataClassesFromGLTF = (gltfJson: GLTF): Set<string> => {
+  const result: Set<string> = new Set();
+
+  // Try to parse from EXT_feature_metadata
+  const extFeatureMetadataClasses = (
+    gltfJson.extensions?.[EXT_FEATURE_METADATA] as GLTF_EXT_feature_metadata_GLTF
+  )?.schema?.classes;
+
+  if (extFeatureMetadataClasses) {
+    for (const classKey of Object.keys(extFeatureMetadataClasses)) {
+      result.add(classKey);
+    }
+  }
+
+  // Try to parse from EXT_structural_metadata
+  const extStructuralMetadataClasses = (
+    gltfJson.extensions?.[EXT_STRUCTURAL_METADATA] as GLTF_EXT_structural_metadata_GLTF
+  )?.schema?.classes;
+  if (extStructuralMetadataClasses) {
+    for (const classKey of Object.keys(extStructuralMetadataClasses)) {
+      result.add(classKey);
+    }
+  }
+
+  return result;
+};
+
 /**
  * Merge object2 into object1
  * @param object1
@@ -78,4 +122,9 @@ export const mergePreprocessData = (object1: PreprocessData, object2: Preprocess
   for (const type of object2.meshTopologyTypes) {
     object1.meshTopologyTypes.add(type);
   }
+
+  // Merge feature metadata classes
+  for (const metadataClass of object2.metadataClasses) {
+    object1.metadataClasses.add(metadataClass);
+  }
 };

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

@@ -12,9 +12,10 @@ import type {
   SceneLayer3D,
   BoundingVolumes,
   MaxScreenThresholdSQ,
-  NodeInPage
+  NodeInPage,
+  AttributeStorageInfo
 } from '@loaders.gl/i3s';
-import {load, encode, fetchFile, getLoaderOptions, isBrowser} from '@loaders.gl/core';
+import {load, encode, isBrowser} from '@loaders.gl/core';
 import {CesiumIonLoader, Tiles3DLoader} from '@loaders.gl/3d-tiles';
 import {Geoid} from '@math.gl/geoid';
 import {join} from 'path';
@@ -51,15 +52,13 @@ import {I3SMaterialDefinition, TextureSetDefinitionFormats} from '@loaders.gl/i3
 import {ImageWriter} from '@loaders.gl/images';
 import {GLTFImagePostprocessed} from '@loaders.gl/gltf';
 import {
-  GltfPrimitiveModeString,
+  GLTFPrimitiveModeString,
   I3SConvertedResources,
   PreprocessData,
   SharedResourcesArrays
 } from './types';
-import {getWorkerURL, WorkerFarm} from '@loaders.gl/worker-utils';
-import {DracoWriterWorker} from '@loaders.gl/draco';
+import {WorkerFarm} from '@loaders.gl/worker-utils';
 import WriteQueue from '../lib/utils/write-queue';
-import {I3SAttributesWorker} from '../i3s-attributes-worker';
 import {BROWSER_ERROR_MESSAGE} from '../constants';
 import {
   createdStorageAttribute,
@@ -69,16 +68,19 @@ import {
   getFieldAttributeType
 } from './helpers/feature-attributes';
 import {NodeIndexDocument} from './helpers/node-index-document';
-import {loadNestedTileset, loadTile3DContent} from './helpers/load-3d-tiles';
+import {
+  isNestedTileset,
+  loadNestedTileset,
+  loadTile3DContent,
+  loadFromArchive
+} from './helpers/load-3d-tiles';
 import {Matrix4} from '@math.gl/core';
 import {BoundingSphere, OrientedBoundingBox} from '@math.gl/culling';
 import {createBoundingVolume} from '@loaders.gl/tiles';
 import {TraversalConversionProps, traverseDatasetWith} from './helpers/tileset-traversal';
 import {analyzeTileContent, mergePreprocessData} from './helpers/preprocess-3d-tiles';
 
-const ION_DEFAULT_TOKEN =
-  process.env?.IonToken || // eslint-disable-line
-  'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJlYWMxMzcyYy0zZjJkLTQwODctODNlNi01MDRkZmMzMjIxOWIiLCJpZCI6OTYyMCwic2NvcGVzIjpbImFzbCIsImFzciIsImdjIl0sImlhdCI6MTU2Mjg2NjI3M30.1FNiClUyk00YH_nWfSGpiQAjR5V2OvREDq1PJ5QMjWQ'; // eslint-disable-line
+const ION_DEFAULT_TOKEN = process.env?.IonToken;
 const HARDCODED_NODES_PER_PAGE = 64;
 const _3D_TILES = '3DTILES';
 const _3D_OBJECT_LAYER_TYPE = '3DObject';
@@ -112,6 +114,7 @@ export default class I3SConverter {
   loadOptions: Tiles3DLoaderOptions = {
     _nodeWorkers: true,
     reuseWorkers: true,
+    useLocalLibraries: true,
     basis: {
       format: 'rgba32',
       // We need to load local fs workers because nodejs can't load workers from the Internet
@@ -119,7 +122,8 @@ export default class I3SConverter {
     },
     // We need to load local fs workers because nodejs can't load workers from the Internet
     draco: {workerUrl: './modules/draco/dist/draco-worker-node.js'},
-    fetch: {}
+    fetch: {},
+    modules: {}
   };
   geoidHeightModel: Geoid | null = null;
   Loader: LoaderWithParser = Tiles3DLoader;
@@ -130,7 +134,8 @@ export default class I3SConverter {
   writeQueue: WriteQueue<WriteQueueItem> = new WriteQueue();
   compressList: string[] | null = null;
   preprocessData: PreprocessData = {
-    meshTopologyTypes: new Set()
+    meshTopologyTypes: new Set(),
+    metadataClasses: new Set()
   };
 
   constructor() {
@@ -187,6 +192,8 @@ export default class I3SConverter {
     generateTextures?: boolean;
     generateBoundingVolumes?: boolean;
     instantNodeWriting?: boolean;
+    inquirer?: Promise<unknown>;
+    metadataClass?: string;
   }): Promise<string> {
     if (isBrowser) {
       console.log(BROWSER_ERROR_MESSAGE);
@@ -207,7 +214,9 @@ export default class I3SConverter {
       generateTextures,
       generateBoundingVolumes,
       instantNodeWriting = false,
-      mergeMaterials = true
+      mergeMaterials = true,
+      inquirer,
+      metadataClass
     } = options;
     this.options = {
       maxDepth,
@@ -218,7 +227,9 @@ export default class I3SConverter {
       token,
       inputUrl,
       instantNodeWriting,
-      mergeMaterials
+      mergeMaterials,
+      inquirer,
+      metadataClass
     };
     this.compressList = (this.options.instantNodeWriting && []) || null;
     this.validate = Boolean(validate);
@@ -237,14 +248,16 @@ export default class I3SConverter {
       this.nodePages.useWriteFunction(writeFileForSlpk);
     }
 
-    await this.loadWorkers();
-
     try {
       const preloadOptions = await this._fetchPreloadOptions();
+      let tilesetUrl = inputUrl;
+      if (preloadOptions.url) {
+        tilesetUrl = preloadOptions.url;
+      }
       if (preloadOptions.headers) {
         this.loadOptions.fetch = {headers: preloadOptions.headers};
       }
-      this.sourceTileset = await load(inputUrl, this.Loader, this.loadOptions);
+      this.sourceTileset = await loadFromArchive(tilesetUrl, this.Loader, this.loadOptions);
 
       const preprocessResult = await this.preprocessConversion();
 
@@ -278,14 +291,24 @@ export default class I3SConverter {
       undefined,
       this.options.maxDepth
     );
-    const {meshTopologyTypes} = this.preprocessData;
+    const {meshTopologyTypes, metadataClasses} = this.preprocessData;
+
     console.log(`------------------------------------------------`);
     console.log(`Preprocess results:`);
     console.log(`glTF mesh topology types: ${Array.from(meshTopologyTypes).join(', ')}`);
+
+    if (metadataClasses.size) {
+      console.log(
+        `Feature metadata classes have been found: ${Array.from(metadataClasses).join(', ')}`
+      );
+    } else {
+      console.log('Feature metadata classes have not been found');
+    }
+
     console.log(`------------------------------------------------`);
     if (
-      !meshTopologyTypes.has(GltfPrimitiveModeString.TRIANGLES) &&
-      !meshTopologyTypes.has(GltfPrimitiveModeString.TRIANGLE_STRIP)
+      !meshTopologyTypes.has(GLTFPrimitiveModeString.TRIANGLES) &&
+      !meshTopologyTypes.has(GLTFPrimitiveModeString.TRIANGLE_STRIP)
     ) {
       console.log(
         'The tileset is of unsupported mesh topology types. The conversion will be interrupted.'
@@ -293,6 +316,32 @@ export default class I3SConverter {
       console.log(`------------------------------------------------`);
       return false;
     }
+
+    if (metadataClasses.size > 1) {
+      if (this.options.metadataClass?.length) {
+        console.log(`${this.options.metadataClass} has been selected`);
+      } else if (this.options.inquirer) {
+        const result = await this.options.inquirer.prompt([
+          {
+            name: 'metadataClass',
+            type: 'list',
+            message: 'Select feature metadata data class to convert...',
+            choices: Array.from(metadataClasses)
+          }
+        ]);
+        this.options.metadataClass = result.metadataClass;
+        console.log(`${result.metadataClass} has been selected`);
+      } else {
+        console.log(
+          `A feature metadata class has not been selected. Start the converter with option "--metadata-class". For example, "npx tile-converter ... --metadata-class ${
+            Array.from(metadataClasses)[0]
+          }"`
+        );
+        console.log(`------------------------------------------------`);
+        return false;
+      }
+    }
+
     return true;
   }
 
@@ -306,18 +355,27 @@ export default class I3SConverter {
     sourceTile: Tiles3DTileJSONPostprocessed,
     traversalProps: null
   ): Promise<null> {
-    if (sourceTile.type === 'json') {
+    const isTileset = isNestedTileset(sourceTile);
+    if (isTileset) {
       await loadNestedTileset(this.sourceTileset, sourceTile, this.loadOptions);
       return null;
     }
     if (sourceTile.id) {
       console.log(`[analyze]: ${sourceTile.id}`); // eslint-disable-line
     }
-    const tileContent = await loadTile3DContent(this.sourceTileset, sourceTile, {
-      ...this.loadOptions,
-      '3d-tiles': {...this.loadOptions['3d-tiles'], loadGLTF: false}
-    });
-    const tilePreprocessData = await analyzeTileContent(sourceTile, tileContent);
+
+    let tileContent: Tiles3DTileContent | null = null;
+    try {
+      tileContent = await loadTile3DContent(this.sourceTileset, sourceTile, {
+        ...this.loadOptions,
+        '3d-tiles': {...this.loadOptions['3d-tiles'], loadGLTF: false}
+      });
+    } catch (error) {
+      console.log(
+        `[warning]: Failed to load ${sourceTile.contentUrl}. An I3S tile with empty content will be added to the output tileset`
+      );
+    }
+    const tilePreprocessData = await analyzeTileContent(tileContent);
     mergePreprocessData(this.preprocessData, tilePreprocessData);
 
     return null;
@@ -511,8 +569,9 @@ export default class I3SConverter {
     sourceTile: Tiles3DTileJSONPostprocessed,
     traversalProps: TraversalConversionProps
   ): Promise<TraversalConversionProps> {
-    if (sourceTile.type === 'json' || sourceTile.type === 'empty') {
-      if (sourceTile.type === 'json') {
+    const isTileset = isNestedTileset(sourceTile);
+    if (isTileset || sourceTile.type === 'empty') {
+      if (isTileset) {
         if (sourceTile.id) {
           console.log(`[load]: ${sourceTile.id}`); // eslint-disable-line
         }
@@ -576,7 +635,12 @@ export default class I3SConverter {
 
     await this._updateTilesetOptions();
 
-    const tileContent = await loadTile3DContent(this.sourceTileset, sourceTile, this.loadOptions);
+    let tileContent: Tiles3DTileContent | null = null;
+    try {
+      tileContent = await loadTile3DContent(this.sourceTileset, sourceTile, this.loadOptions);
+    } catch (error) {
+      console.log(`[warning]: Failed to load ${sourceTile.contentUrl}`);
+    }
     const sourceBoundingVolume = createBoundingVolume(
       sourceTile.boundingVolume,
       transformationMatrix,
@@ -584,9 +648,15 @@ export default class I3SConverter {
     );
     let boundingVolumes = createBoundingVolumes(sourceBoundingVolume, this.geoidHeightModel!);
 
-    const propertyTable = getPropertyTable(tileContent);
+    const propertyTable = getPropertyTable(tileContent, this.options.metadataClass);
 
-    if (propertyTable && !this.layers0?.attributeStorageInfo?.length) {
+    if (propertyTable) {
+      /*
+        Call the convertion procedure even if the node attributes have been already created.
+        We will append new attributes only in case the property table is updated.
+        According to ver 1.9 (see https://github.com/Esri/i3s-spec/blob/master/docs/1.9/attributeStorageInfo.cmn.md):
+        "The attributeStorageInfo object describes the structure of the binary attribute data resource of a layer, which is the same for every node in the layer."
+      */
       this._convertPropertyTableToNodeAttributes(propertyTable);
     }
 
@@ -672,7 +742,7 @@ export default class I3SConverter {
    * @param boundingVolume - initialized bounding volume of the source tile
    * @param tileContent - content of the source tile
    * @param parentId - id of parent node in node pages
-   * @param propertyTable - batch table from b3dm / feature properties from EXT_FEATURE_METADATA
+   * @param propertyTable - batch table from b3dm / feature properties from EXT_FEATURE_METADATA, EXT_MESH_FEATURES or EXT_STRUCTURAL_METADATA
    * @returns - converted node resources
    */
   private async _convertResources(
@@ -703,7 +773,8 @@ export default class I3SConverter {
       this.generateBoundingVolumes,
       this.options.mergeMaterials,
       this.geoidHeightModel!,
-      this.workerSource
+      this.loadOptions.modules as Record<string, string>,
+      this.options.metadataClass
     );
     return resourcesData;
   }
@@ -753,13 +824,17 @@ export default class I3SConverter {
     }
 
     let nodeId = resources.nodeId;
-    let node;
+    let node: NodeInPage;
     if (!nodeId) {
       node = await this.nodePages.push(nodeInPage, parentId);
     } else {
       node = await this.nodePages.getNodeById(nodeId);
     }
 
+    if (!nodeInPage.mesh) {
+      console.log(`[warning]: node ${node.index} is created with empty content`);
+    }
+
     NodePages.updateAll(node, nodeInPage);
     if (meshMaterial) {
       NodePages.updateMaterialByNodeId(node, this._findOrCreateMaterial(meshMaterial));
@@ -915,9 +990,13 @@ export default class I3SConverter {
               KTX2BasisWriterWorker,
               {
                 ...KTX2BasisWriterWorker.options,
-                source: this.workerSource.ktx2,
+                ['ktx2-basis-writer']: {
+                  // We need to load local fs workers because nodejs can't load workers from the Internet
+                  workerUrl: './modules/textures/dist/ktx2-basis-writer-worker-node.js'
+                },
                 reuseWorkers: true,
-                _nodeWorkers: true
+                _nodeWorkers: true,
+                useLocalLibraries: true
               }
             );
 
@@ -996,7 +1075,12 @@ export default class I3SConverter {
     slpkChildPath: string
   ): Promise<void> {
     if (attributes?.length && this.layers0?.attributeStorageInfo?.length) {
-      for (let index = 0; index < attributes.length; index++) {
+      const minimumLength =
+        attributes.length < this.layers0.attributeStorageInfo.length
+          ? attributes.length
+          : this.layers0.attributeStorageInfo.length;
+
+      for (let index = 0; index < minimumLength; index++) {
         const folderName = this.layers0.attributeStorageInfo[index].key;
         const fileBuffer = new Uint8Array(attributes[index]);
 
@@ -1078,19 +1162,30 @@ export default class I3SConverter {
     };
 
     for (const key in propertyTableWithObjectId) {
-      const firstAttribute = propertyTableWithObjectId[key][0];
-      const attributeType = getAttributeType(key, firstAttribute);
-
-      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);
-      this.layers0!.popupInfo = popupInfo;
-      this.layers0!.layerType = _3D_OBJECT_LAYER_TYPE;
-
+      /*
+        We will append new attributes only in case the property table is updated.
+        According to ver 1.9 (see https://github.com/Esri/i3s-spec/blob/master/docs/1.9/attributeStorageInfo.cmn.md):
+        "The attributeStorageInfo object describes the structure of the binary attribute data resource of a layer, which is the same for every node in the layer."
+      */
+      const found = this.layers0!.attributeStorageInfo!.find((element) => element.name === key);
+      if (!found) {
+        const firstAttribute = propertyTableWithObjectId[key][0];
+        const attributeType = getAttributeType(key, firstAttribute);
+
+        const storageAttribute: AttributeStorageInfo = 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);
+        this.layers0!.popupInfo = popupInfo;
+        this.layers0!.layerType = _3D_OBJECT_LAYER_TYPE;
+      }
       attributeIndex += 1;
     }
   }
@@ -1177,27 +1272,4 @@ export default class I3SConverter {
   private isContentSupported(sourceTile: Tiles3DTileJSONPostprocessed): boolean {
     return ['b3dm', 'glTF', 'scenegraph'].includes(sourceTile.type || '');
   }
-
-  private async loadWorkers(): Promise<void> {
-    console.log(`Loading workers source...`); // eslint-disable-line no-undef, no-console
-    if (this.options.draco) {
-      const url = getWorkerURL(DracoWriterWorker, {...getLoaderOptions()});
-      const sourceResponse = await fetchFile(url);
-      const source = await sourceResponse.text();
-      this.workerSource.draco = source;
-    }
-
-    if (this.generateTextures) {
-      const url = getWorkerURL(KTX2BasisWriterWorker, {...getLoaderOptions()});
-      const sourceResponse = await fetchFile(url);
-      const source = await sourceResponse.text();
-      this.workerSource.ktx2 = source;
-    }
-
-    const i3sAttributesWorkerUrl = getWorkerURL(I3SAttributesWorker, {...getLoaderOptions()});
-    const sourceResponse = await fetchFile(i3sAttributesWorkerUrl);
-    const source = await sourceResponse.text();
-    this.workerSource.I3SAttributes = source;
-    console.log(`Loading workers source completed!`); // eslint-disable-line no-undef, no-console
-  }
 }