@loaders.gl/tile-converter 4.0.0-alpha.4 → 4.0.0-alpha.5

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

@@ -1,5 +1,4 @@
-import type {Tileset3DProps} from '@loaders.gl/tiles';
-import type {GLTFMaterial} from '@loaders.gl/gltf';
+import type {Tile3D, Tileset3DProps} from '@loaders.gl/tiles';
 import type {BatchTableJson, B3DMContent} from '@loaders.gl/3d-tiles';
 
 import type {
@@ -8,20 +7,20 @@ import type {
   BoundingVolumes,
   Node3DIndexDocument,
   NodeReference,
-  I3SGeometry,
   MaxScreenThresholdSQ,
   NodeInPage,
   LodSelection,
   SharedResources,
-  TextureImage,
   Attribute,
   ESRIField,
   Field,
-  PopupInfo
+  PopupInfo,
+  FieldInfo
 } from '@loaders.gl/i3s';
 import {load, encode} from '@loaders.gl/core';
 import {Tileset3D} from '@loaders.gl/tiles';
-import {CesiumIonLoader} from '@loaders.gl/3d-tiles';
+import {CesiumIonLoader, Tiles3DLoader} from '@loaders.gl/3d-tiles';
+import {Geoid} from '@math.gl/geoid';
 import {join} from 'path';
 import {v4 as uuidv4} from 'uuid';
 import process from 'process';
@@ -47,11 +46,15 @@ import {PGMLoader} from '../pgm-loader';
 
 import {LAYERS as layersTemplate} from './json-templates/layers';
 import {NODE as nodeTemplate} from './json-templates/node';
-import {SHARED_RESOURCES_TEMPLATE} from './json-templates/shared-resources';
+import {SHARED_RESOURCES as sharedResourcesTemplate} from './json-templates/shared-resources';
 import {validateNodeBoundingVolumes} from './helpers/node-debug';
-import {GeoidHeightModel} from '../lib/geoid-height-model';
 import TileHeader from '@loaders.gl/tiles/src/tileset/tile-3d';
 import {KTX2BasisUniversalTextureWriter} from '@loaders.gl/textures';
+import {LoaderWithParser} from '@loaders.gl/loader-utils';
+import {I3SMaterialDefinition, TextureSetDefinitionFormats} from '@loaders.gl/i3s/src/types';
+import {ImageWriter} from '@loaders.gl/images';
+import {GLTFImagePostprocessed} from '@loaders.gl/gltf';
+import {I3SConvertedResources} from './types';
 
 const ION_DEFAULT_TOKEN =
   process.env.IonToken || // eslint-disable-line
@@ -64,6 +67,7 @@ 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';
 
 /**
@@ -75,20 +79,23 @@ export default class I3SConverter {
   options: any;
   layers0Path: string;
   materialMap: Map<any, any>;
-  materialDefinitions: GLTFMaterial[];
+  materialDefinitions: I3SMaterialDefinition[];
   vertexCounter: number;
-  layers0: SceneLayer3D;
+  layers0: SceneLayer3D | null;
   featuresHashArray: string[];
   refinementCounter: {
     tilesCount: number;
     tilesWithAddRefineCount: number;
   };
   validate: boolean;
-  boundingVolumeWarnings?: string[];
-  conversionStartTime: [number, number];
-  refreshTokenTime: [number, number];
-  sourceTileset: Tileset3D | null;
-  geoidHeightModel: GeoidHeightModel | null;
+  boundingVolumeWarnings?: string[] = [];
+  conversionStartTime: [number, number] = [0, 0];
+  refreshTokenTime: [number, number] = [0, 0];
+  sourceTileset: Tileset3D | null = null;
+  geoidHeightModel: Geoid | null = null;
+  Loader: LoaderWithParser = Tiles3DLoader;
+  generateTextures: boolean;
+  generateBoundingVolumes: boolean;
 
   constructor() {
     this.nodePages = new NodePages(writeFile, HARDCODED_NODES_PER_PAGE);
@@ -105,7 +112,8 @@ export default class I3SConverter {
       tilesWithAddRefineCount: 0
     };
     this.validate = false;
-    this.boundingVolumeWarnings = null;
+    this.generateTextures = false;
+    this.generateBoundingVolumes = false;
   }
 
   /**
@@ -127,12 +135,16 @@ export default class I3SConverter {
     outputPath: string;
     tilesetName: string;
     sevenZipExe: string;
-    egmFilePath?: string;
+    egmFilePath: string;
     maxDepth?: number;
     slpk?: boolean;
     token?: string;
     draco?: boolean;
     validate?: boolean;
+    generateTextures?: boolean;
+    generateBoundingVolumes?: boolean;
+    /** @deprecated */
+    inputType?: string;
   }): Promise<any> {
     this.conversionStartTime = process.hrtime();
     const {
@@ -145,10 +157,15 @@ export default class I3SConverter {
       draco,
       sevenZipExe,
       maxDepth,
-      token
+      token,
+      generateTextures,
+      generateBoundingVolumes
     } = options;
     this.options = {maxDepth, slpk, sevenZipExe, egmFilePath, draco, token, inputUrl};
-    this.validate = validate;
+    this.validate = Boolean(validate);
+    this.Loader = inputUrl.indexOf(CESIUM_DATASET_PREFIX) !== -1 ? CesiumIonLoader : Tiles3DLoader;
+    this.generateTextures = Boolean(generateTextures);
+    this.generateBoundingVolumes = Boolean(generateBoundingVolumes);
 
     console.log('Loading egm file...'); // eslint-disable-line
     this.geoidHeightModel = await load(egmFilePath, PGMLoader);
@@ -159,17 +176,17 @@ export default class I3SConverter {
     }
 
     const preloadOptions = await this._fetchPreloadOptions();
-    const tilesetOptions: Tileset3DProps = {loadOptions: {}};
+    const tilesetOptions: Tileset3DProps = {loadOptions: {basis: {format: 'rgba32'}}};
     if (preloadOptions.headers) {
-      tilesetOptions.loadOptions.fetch = {headers: preloadOptions.headers};
+      tilesetOptions.loadOptions!.fetch = {headers: preloadOptions.headers};
     }
     Object.assign(tilesetOptions, preloadOptions);
-    const sourceTilesetJson = await load(inputUrl, CesiumIonLoader, tilesetOptions.loadOptions);
+    const sourceTilesetJson = await load(inputUrl, this.Loader, tilesetOptions.loadOptions);
     // console.log(tilesetJson); // eslint-disable-line
     this.sourceTileset = new Tileset3D(sourceTilesetJson, tilesetOptions);
 
     await this._createAndSaveTileset(outputPath, tilesetName);
-    await this._finishConversion({slpk, outputPath, tilesetName});
+    await this._finishConversion({slpk: Boolean(slpk), outputPath, tilesetName});
     return sourceTilesetJson;
   }
 
@@ -194,9 +211,10 @@ export default class I3SConverter {
     this.materialDefinitions = [];
     this.materialMap = new Map();
 
-    const sourceRootTile = this.sourceTileset.root;
-    const boundingVolumes = createBoundingVolumes(sourceRootTile, this.geoidHeightModel);
+    const sourceRootTile: TileHeader = this.sourceTileset!.root!;
+    const boundingVolumes = createBoundingVolumes(sourceRootTile, this.geoidHeightModel!);
     const parentId = this.nodePages.push({
+      index: 0,
       lodThreshold: 0,
       obb: boundingVolumes.obb,
       children: []
@@ -207,7 +225,7 @@ export default class I3SConverter {
 
     await this._convertNodesTree(root0, sourceRootTile, parentId, boundingVolumes);
 
-    this.layers0.materialDefinitions = this.materialDefinitions;
+    this.layers0!.materialDefinitions = this.materialDefinitions;
     await this._writeLayers0();
     createSceneServerPath(tilesetName, this.layers0, tilesetPath);
     await this._writeNodeIndexDocument(root0, 'root', join(this.layers0Path, 'nodes', 'root'));
@@ -236,7 +254,7 @@ export default class I3SConverter {
       compressGeometry: this.options.draco
     };
 
-    this.layers0 = transform(layers0data, layersTemplate);
+    this.layers0 = transform(layers0data, layersTemplate());
   }
 
   /**
@@ -262,7 +280,7 @@ export default class I3SConverter {
       ...boundingVolumes,
       children: []
     };
-    return transform(root0data, nodeTemplate);
+    return transform(root0data, nodeTemplate());
   }
 
   /**
@@ -278,15 +296,16 @@ export default class I3SConverter {
     parentId: number,
     boundingVolumes: BoundingVolumes
   ): Promise<void> {
-    await this.sourceTileset._loadTile(sourceRootTile);
-    if (sourceRootTile.content && sourceRootTile.content.type === 'b3dm') {
+    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);
+      const childPath = join(this.layers0Path, 'nodes', child.path!);
 
       if (this.options.slpk) {
         this.fileMap['nodes/1/3dNodeIndexDocument.json.gz'] = await writeFileForSlpk(
@@ -355,6 +374,7 @@ export default class I3SConverter {
         slpkFileName,
         0,
         '.',
+        // @ts-expect-error
         this.options.sevenZipExe
       );
 
@@ -425,7 +445,7 @@ export default class I3SConverter {
     }
     for (const sourceTile of sourceTiles) {
       if (sourceTile.type === 'json') {
-        await this.sourceTileset._loadTile(sourceTile);
+        await this.sourceTileset!._loadTile(sourceTile);
         await this._addChildren({
           parentNode,
           sourceTiles: sourceTile.children,
@@ -435,13 +455,14 @@ export default class I3SConverter {
         });
         await sourceTile.unloadContent();
       } else {
-        const boundingVolumes = createBoundingVolumes(sourceTile, this.geoidHeightModel);
         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}`,
-            ...boundingVolumes
+            obb: child.obb,
+            mbs: child.mbs
           });
           childNodes.push(child);
         }
@@ -462,19 +483,21 @@ export default class I3SConverter {
     childNodes: Node3DIndexDocument[]
   ): Promise<void> {
     for (const node of childNodes) {
-      const childPath = join(this.layers0Path, 'nodes', node.path);
+      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 (parentNode.children.length < 1000) {
-        for (const neighbor of parentNode.children) {
+      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
           }
 
-          node.neighbors.push({...neighbor});
+          if (node.neighbors) {
+            node.neighbors.push({...neighbor});
+          }
         }
       } else {
         // eslint-disable-next-line no-console, no-undef
@@ -483,7 +506,7 @@ export default class I3SConverter {
         );
         delete node.neighbors;
       }
-      await this._writeNodeIndexDocument(node, nodePath, childPath);
+      await this._writeNodeIndexDocument(node, nodePath!, childPath);
       node.neighbors = [];
     }
   }
@@ -506,13 +529,9 @@ export default class I3SConverter {
     }
 
     await this._updateTilesetOptions();
-    await this.sourceTileset._loadTile(sourceTile);
-    const boundingVolumes = createBoundingVolumes(sourceTile, this.geoidHeightModel);
+    await this.sourceTileset!._loadTile(sourceTile);
 
-    const lodSelection = convertGeometricErrorToScreenThreshold(sourceTile, boundingVolumes);
-    const maxScreenThresholdSQ = lodSelection.find(
-      (val) => val.metricType === 'maxScreenThresholdSQ'
-    ) || {maxError: 0};
+    let boundingVolumes = createBoundingVolumes(sourceTile, this.geoidHeightModel!);
 
     const batchTable = sourceTile?.content?.batchTableJson;
 
@@ -522,7 +541,8 @@ export default class I3SConverter {
 
     const resourcesData = await this._convertResources(sourceTile);
 
-    const nodes = [];
+    const nodes: Node3DIndexDocument[] = [];
+    const nodesInPage: NodeInPage[] = [];
     const emptyResources = {
       geometry: null,
       compressedGeometry: null,
@@ -531,9 +551,20 @@ export default class I3SConverter {
       meshMaterial: null,
       vertexCount: null,
       attributes: null,
-      featureCount: null
+      featureCount: null,
+      boundingVolumes: null
     };
+
     for (const resources of resourcesData || [emptyResources]) {
+      if (this.generateBoundingVolumes && resources.boundingVolumes) {
+        boundingVolumes = resources.boundingVolumes;
+      }
+
+      const lodSelection = convertGeometricErrorToScreenThreshold(sourceTile, boundingVolumes);
+      const maxScreenThresholdSQ = lodSelection.find(
+        (val) => val.metricType === 'maxScreenThresholdSQ'
+      ) || {maxError: 0};
+
       const nodeInPage = this._createNodeInNodePages(
         maxScreenThresholdSQ,
         boundingVolumes,
@@ -550,7 +581,7 @@ export default class I3SConverter {
       );
 
       if (nodeInPage.mesh) {
-        await this._writeResources(resources, node.path);
+        await this._writeResources(resources, node.path!);
       }
 
       if (this.validate) {
@@ -562,15 +593,15 @@ export default class I3SConverter {
       }
 
       nodes.push(node);
+      nodesInPage.push(nodeInPage);
     }
 
     sourceTile.unloadContent();
 
-    const firstNode = nodes[0];
     await this._addChildrenWithNeighborsAndWriteFile({
-      parentNode: firstNode,
+      parentNode: nodes[0],
       sourceTiles: sourceTile.children,
-      parentId: firstNode.id,
+      parentId: nodesInPage[0].index!,
       level: level + 1
     });
     return nodes;
@@ -585,7 +616,7 @@ export default class I3SConverter {
   private _convertAttributeStorageInfo(sourceTileContent: B3DMContent): void {
     // In legacy b3dm files sometimes sourceTileContent is null.
     const batchTable = sourceTileContent && sourceTileContent.batchTableJson;
-    if (batchTable && !this.layers0.attributeStorageInfo.length) {
+    if (batchTable && !this.layers0?.attributeStorageInfo?.length) {
       this._convertBatchTableInfoToNodeAttributes(batchTable);
     }
   }
@@ -602,16 +633,18 @@ export default class I3SConverter {
    * result.attributes - feature attributes
    * result.featureCount - number of features
    */
-  private async _convertResources(sourceTile: TileHeader): Promise<I3SGeometry[]> {
-    if (!sourceTile.content || sourceTile.content.type !== 'b3dm') {
+  private async _convertResources(sourceTile: TileHeader): Promise<I3SConvertedResources[] | null> {
+    if (!this.isContentSupported(sourceTile)) {
       return null;
     }
     const resourcesData = await convertB3dmToI3sGeometry(
       sourceTile.content,
       Number(this.nodePages.nodesCounter),
       this.featuresHashArray,
-      this.layers0.attributeStorageInfo,
-      this.options.draco
+      this.layers0?.attributeStorageInfo,
+      this.options.draco,
+      this.generateBoundingVolumes,
+      this.geoidHeightModel!
     );
     return resourcesData;
   }
@@ -635,21 +668,27 @@ export default class I3SConverter {
     boundingVolumes: BoundingVolumes,
     sourceTile: TileHeader,
     parentId: number,
-    resources: I3SGeometry
+    resources: I3SConvertedResources
   ): NodeInPage {
     const {meshMaterial, texture, vertexCount, featureCount, geometry} = resources;
-    const nodeInPage = {
+    const nodeInPage: NodeInPage = {
+      index: 0,
       lodThreshold: maxScreenThresholdSQ.maxError,
       obb: boundingVolumes.obb,
-      children: [],
-      mesh: null
+      children: []
     };
-    if (geometry && sourceTile.content && sourceTile.content.type === 'b3dm') {
+    if (geometry && this.isContentSupported(sourceTile)) {
       nodeInPage.mesh = {
         geometry: {
-          definition: texture ? 0 : 1
+          definition: texture ? 0 : 1,
+          resource: 0
+        },
+        attribute: {
+          resource: 0
         },
-        attribute: {}
+        material: {
+          definition: 0
+        }
       };
     }
     const nodeId = this.nodePages.push(nodeInPage, parentId);
@@ -691,15 +730,15 @@ export default class I3SConverter {
     boundingVolumes: BoundingVolumes,
     lodSelection: LodSelection[],
     nodeInPage: NodeInPage,
-    resources: I3SGeometry
+    resources: I3SConvertedResources
   ): Node3DIndexDocument {
     const {texture, attributes} = resources;
-    const nodeId = nodeInPage.index;
+    const nodeId = nodeInPage.index!;
     const nodeData = {
       version: parentNode.version,
       id: nodeId.toString(),
       path: nodeId.toString(),
-      level: parentNode.level + 1,
+      level: parentNode.level! + 1,
       ...boundingVolumes,
       lodSelection,
       parentNode: {
@@ -711,7 +750,7 @@ export default class I3SConverter {
       children: [],
       neighbors: []
     };
-    const node = transform(nodeData, nodeTemplate);
+    const node = transform(nodeData, nodeTemplate());
 
     if (nodeInPage.mesh) {
       node.geometryData = [{href: './geometries/0'}];
@@ -721,12 +760,7 @@ export default class I3SConverter {
         node.textureData = [{href: './textures/0'}, {href: './textures/1'}];
       }
 
-      if (
-        attributes &&
-        attributes.length &&
-        this.layers0.attributeStorageInfo &&
-        this.layers0.attributeStorageInfo.length
-      ) {
+      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;
@@ -748,7 +782,7 @@ export default class I3SConverter {
    * @param resources.attributes - feature attributes
    * @return {Promise<void>}
    */
-  private async _writeResources(resources: I3SGeometry, nodePath: string): Promise<void> {
+  private async _writeResources(resources: I3SConvertedResources, nodePath: string): Promise<void> {
     const {
       geometry: geometryBuffer,
       compressedGeometry,
@@ -759,8 +793,8 @@ export default class I3SConverter {
     const childPath = join(this.layers0Path, 'nodes', nodePath);
     const slpkChildPath = join('nodes', nodePath);
 
-    await this._writeGeometries(geometryBuffer, compressedGeometry, childPath, slpkChildPath);
-    await this._writeShared(sharedResources, childPath, slpkChildPath, nodePath);
+    await this._writeGeometries(geometryBuffer!, compressedGeometry!, childPath, slpkChildPath);
+    await this._writeShared(sharedResources!, childPath, slpkChildPath, nodePath);
     await this._writeTexture(texture, childPath, slpkChildPath);
     await this._writeAttributes(attributes, childPath, slpkChildPath);
   }
@@ -819,7 +853,7 @@ export default class I3SConverter {
     nodePath: string
   ): Promise<void> {
     sharedResources.nodePath = nodePath;
-    const sharedData = transform(sharedResources, SHARED_RESOURCES_TEMPLATE);
+    const sharedData = transform(sharedResources, sharedResourcesTemplate());
     const sharedDataStr = JSON.stringify(sharedData);
     if (this.options.slpk) {
       const slpkSharedPath = join(childPath, 'shared');
@@ -835,63 +869,95 @@ export default class I3SConverter {
   }
 
   /**
-   * Write the texture image in a file
+   * Generates textures based on texture mime type and fill in textureSetDefinitions data.
    * @param texture - the texture image
    * @param childPath - a child path to write resources
    * @param slpkChildPath - the resource path inside *slpk file
    */
   private async _writeTexture(
-    texture: TextureImage,
+    texture: GLTFImagePostprocessed,
     childPath: string,
     slpkChildPath: string
   ): Promise<void> {
     if (texture) {
-      const format = this._getFormatByMimeType(texture.mimeType);
-      if (!this.layers0.textureSetDefinitions.length) {
-        this.layers0.textureSetDefinitions.push({
-          formats: [
-            {
-              name: '0',
-              format
-            },
-            {
-              name: '1',
-              format: 'ktx2'
-            }
-          ]
-        });
-      }
-
-      const textureData = texture.bufferView.data;
-      const ktx2TextureData = await encode(texture.image, KTX2BasisUniversalTextureWriter);
+      const format = this._getFormatByMimeType(texture?.mimeType);
+      const formats: TextureSetDefinitionFormats = [];
+      const textureData = texture.bufferView!.data;
+
+      switch (format) {
+        case 'jpg':
+        case 'png': {
+          formats.push({name: '0', format});
+          await this.writeTextureFile(textureData, '0', format, childPath, slpkChildPath);
+
+          if (this.generateTextures) {
+            formats.push({name: '1', format: 'ktx2'});
+            const ktx2TextureData = new Uint8Array(
+              await encode(texture.image, KTX2BasisUniversalTextureWriter)
+            );
+            await this.writeTextureFile(ktx2TextureData, '1', 'ktx2', childPath, slpkChildPath);
+          }
 
-      if (this.options.slpk) {
-        const slpkTexturePath = join(childPath, 'textures');
-        const compress = false;
-
-        this.fileMap[`${slpkChildPath}/textures/0.${format}`] = await writeFileForSlpk(
-          slpkTexturePath,
-          textureData,
-          `0.${format}`,
-          compress
-        );
+          break;
+        }
 
-        this.fileMap[`${slpkChildPath}/textures/1.ktx2`] = await writeFileForSlpk(
-          slpkTexturePath,
-          ktx2TextureData,
-          `1.ktx2`,
-          compress
-        );
-      } else {
-        const texturePath = join(childPath, 'textures/0/');
-        await writeFile(texturePath, textureData, `index.${format}`);
+        case 'ktx2': {
+          formats.push({name: '1', format});
+          await this.writeTextureFile(textureData, '1', format, childPath, slpkChildPath);
+
+          if (this.generateTextures) {
+            formats.push({name: '0', format: 'jpg'});
+            const decodedFromKTX2TextureData = new Uint8Array(
+              await encode(texture.image!.data[0], ImageWriter)
+            );
+            await this.writeTextureFile(
+              decodedFromKTX2TextureData,
+              '0',
+              'jpg',
+              childPath,
+              slpkChildPath
+            );
+          }
+        }
+      }
 
-        const ktx2TexturePath = join(childPath, 'textures/1/');
-        await writeFile(ktx2TexturePath, ktx2TextureData, `index.ktx2`);
+      if (!this.layers0!.textureSetDefinitions!.length) {
+        this.layers0!.textureSetDefinitions!.push({formats});
       }
     }
   }
 
+  /**
+   * Write the texture image in a file
+   * @param textureData
+   * @param name
+   * @param format
+   * @param childPath
+   * @param slpkChildPath
+   */
+  private async writeTextureFile(
+    textureData: ArrayBuffer,
+    name: string,
+    format: 'jpg' | 'png' | 'ktx2',
+    childPath: string,
+    slpkChildPath: string
+  ): Promise<void> {
+    const texturePath = join(childPath, `textures/${name}/`);
+    await writeFile(texturePath, textureData, `index.${format}`);
+
+    if (this.options.slpk) {
+      const slpkTexturePath = join(childPath, 'textures');
+      const compress = false;
+
+      this.fileMap[`${slpkChildPath}/textures/${name}.${format}`] = await writeFileForSlpk(
+        slpkTexturePath,
+        textureData,
+        `${name}.${format}`,
+        compress
+      );
+    }
+  }
+
   /**
    * Write feature attributes in files
    * @param attributes - feature attributes
@@ -903,11 +969,7 @@ export default class I3SConverter {
     childPath: string,
     slpkChildPath: string
   ): Promise<void> {
-    if (
-      attributes.length &&
-      this.layers0.attributeStorageInfo &&
-      this.layers0.attributeStorageInfo.length
-    ) {
+    if (attributes.length && this.layers0?.attributeStorageInfo?.length) {
       for (let index = 0; index < attributes.length; index++) {
         const folderName = this.layers0.attributeStorageInfo[index].key;
         const fileBuffer = new Uint8Array(attributes[index]);
@@ -931,12 +993,14 @@ export default class I3SConverter {
    * Return file format by its MIME type
    * @param mimeType - feature attributes
    */
-  private _getFormatByMimeType(mimeType: string): string {
+  private _getFormatByMimeType(mimeType: string | undefined): 'jpg' | 'png' | 'ktx2' {
     switch (mimeType) {
       case 'image/jpeg':
         return 'jpg';
       case 'image/png':
         return 'png';
+      case 'image/ktx2':
+        return 'ktx2';
       default:
         return 'jpg';
     }
@@ -947,7 +1011,7 @@ export default class I3SConverter {
    * @param material - end-to-end index of the node
    * @return material id
    */
-  private _findOrCreateMaterial(material: GLTFMaterial): number {
+  private _findOrCreateMaterial(material: I3SMaterialDefinition): number {
     const hash = md5(JSON.stringify(material));
     if (this.materialMap.has(hash)) {
       return this.materialMap.get(hash);
@@ -1018,7 +1082,7 @@ export default class I3SConverter {
    * @param storageAttribute - attribute for map segmentation.
    */
   private _setupStringAttribute(storageAttribute: AttributeStorageInfo): void {
-    storageAttribute.ordering.unshift('attributeByteCounts');
+    storageAttribute.ordering!.unshift('attributeByteCounts');
     storageAttribute.header.push({property: 'attributeValuesByteCount', valueType: 'UInt32'});
     storageAttribute.attributeValues = {
       valueType: 'String',
@@ -1086,10 +1150,10 @@ export default class I3SConverter {
       const fieldAttribute = this._createFieldAttribute(key, fieldAttributeType);
       const popupInfo = this._createPopupInfo(batchTableWithObjectId);
 
-      this.layers0.attributeStorageInfo.push(storageAttribute);
-      this.layers0.fields.push(fieldAttribute);
-      this.layers0.popupInfo = popupInfo;
-      this.layers0.layerType = _3D_OBJECT_LAYER_TYPE;
+      this.layers0!.attributeStorageInfo!.push(storageAttribute);
+      this.layers0!.fields!.push(fieldAttribute);
+      this.layers0!.popupInfo = popupInfo;
+      this.layers0!.layerType = _3D_OBJECT_LAYER_TYPE;
 
       attributeIndex += 1;
     }
@@ -1122,8 +1186,11 @@ export default class I3SConverter {
   private _createPopupInfo(batchTable: BatchTableJson): PopupInfo {
     const title = '{OBJECTID}';
     const mediaInfos = [];
-    const fieldInfos = [];
-    const popupElements = [];
+    const fieldInfos: FieldInfo[] = [];
+    const popupElements: {
+      fieldInfos: FieldInfo[];
+      type: string;
+    }[] = [];
     const expressionInfos = [];
 
     for (const key in batchTable) {
@@ -1177,10 +1244,13 @@ export default class I3SConverter {
    * Fetch preload options for ION tileset
    */
   private async _fetchPreloadOptions(): Promise<any> {
+    if (!this.Loader.preload) {
+      return {};
+    }
     const options = {
       'cesium-ion': {accessToken: this.options.token || ION_DEFAULT_TOKEN}
     };
-    const preloadOptions = await CesiumIonLoader.preload(this.options.inputUrl, options);
+    const preloadOptions = await this.Loader.preload(this.options.inputUrl, options);
     this.refreshTokenTime = process.hrtime();
     return {...options, ...preloadOptions};
   }
@@ -1196,10 +1266,10 @@ export default class I3SConverter {
     this.refreshTokenTime = process.hrtime();
 
     const preloadOptions = await this._fetchPreloadOptions();
-    this.sourceTileset.options = {...this.sourceTileset.options, ...preloadOptions};
+    this.sourceTileset!.options = {...this.sourceTileset!.options, ...preloadOptions};
     if (preloadOptions.headers) {
-      this.sourceTileset.loadOptions.fetch = {
-        ...this.sourceTileset.loadOptions.fetch,
+      this.sourceTileset!.loadOptions.fetch = {
+        ...this.sourceTileset!.loadOptions.fetch,
         headers: preloadOptions.headers
       };
       console.log('Authorization Bearer token has been updated'); // eslint-disable-line no-undef, no-console
@@ -1219,4 +1289,12 @@ export default class I3SConverter {
 
     this.refinementCounter.tilesCount += 1;
   }
+  /**
+   * Check if the tile's content format is supported by the converter
+   * @param sourceRootTile
+   * @returns
+   */
+  private isContentSupported(sourceRootTile: Tile3D): boolean {
+    return ['b3dm', 'glTF'].includes(sourceRootTile?.content?.type);
+  }
 }