@loaders.gl/tile-converter 4.2.0-alpha.1 → 4.2.0-alpha.3

package/src/3d-tiles-converter/3d-tiles-converter.ts

@@ -4,7 +4,7 @@ import type {
   NodeReference,
   I3STilesetHeader
 } from '@loaders.gl/i3s';
-import type {Tiles3DTileJSON} from '@loaders.gl/3d-tiles';
+import type {Tile3DBoundingVolume, Tiles3DTileJSON} from '@loaders.gl/3d-tiles';
 
 import {join} from 'path';
 import process from 'process';
@@ -24,8 +24,11 @@ import {WorkerFarm} from '@loaders.gl/worker-utils';
 import {BROWSER_ERROR_MESSAGE} from '../constants';
 import B3dmConverter, {I3SAttributesData} from './helpers/b3dm-converter';
 import {I3STileHeader} from '@loaders.gl/i3s/src/types';
-import {loadI3SContent} from './helpers/load-i3s';
+import {getNodeCount, loadFromArchive, loadI3SContent, openSLPK} from './helpers/load-i3s';
 import {I3SLoaderOptions} from '@loaders.gl/i3s/src/i3s-loader';
+import {ZipFileSystem} from '../../../zip/src';
+import {ConversionDump, ConversionDumpOptions} from '../lib/utils/conversion-dump';
+import {Progress} from '../i3s-converter/helpers/progress';
 
 const I3S = 'I3S';
 
@@ -41,6 +44,7 @@ export default class Tiles3DConverter {
   sourceTileset: I3STilesetHeader | null;
   attributeStorageInfo?: AttributeStorageInfo[] | null;
   workerSource: {[key: string]: string} = {};
+  slpkFilesystem: ZipFileSystem | null = null;
   loaderOptions: I3SLoaderOptions = {
     _nodeWorkers: true,
     reuseWorkers: true,
@@ -52,6 +56,8 @@ export default class Tiles3DConverter {
       workerUrl: './modules/i3s/dist/i3s-content-worker-node.js'
     }
   };
+  conversionDump: ConversionDump;
+  progress: Progress;
 
   constructor() {
     this.options = {};
@@ -62,6 +68,8 @@ export default class Tiles3DConverter {
     this.sourceTileset = null;
     this.attributeStorageInfo = null;
     this.workerSource = {};
+    this.conversionDump = new ConversionDump();
+    this.progress = new Progress();
   }
 
   /**
@@ -79,20 +87,43 @@ export default class Tiles3DConverter {
     tilesetName: string;
     maxDepth?: number;
     egmFilePath: string;
+    inquirer?: Promise<unknown>;
+    analyze?: boolean;
   }): Promise<any> {
     if (isBrowser) {
       console.log(BROWSER_ERROR_MESSAGE);
       return BROWSER_ERROR_MESSAGE;
     }
-    const {inputUrl, outputPath, tilesetName, maxDepth, egmFilePath} = options;
+    const {inputUrl, outputPath, tilesetName, maxDepth, egmFilePath, inquirer, analyze} = options;
     this.conversionStartTime = process.hrtime();
-    this.options = {maxDepth};
+    this.options = {maxDepth, inquirer};
 
     console.log('Loading egm file...'); // eslint-disable-line
     this.geoidHeightModel = await load(egmFilePath, PGMLoader);
     console.log('Loading egm file completed!'); // eslint-disable-line
 
-    this.sourceTileset = await load(inputUrl, I3SLoader, this.loaderOptions);
+    this.slpkFilesystem = await openSLPK(inputUrl);
+
+    let preprocessResult = true;
+    if (analyze || this.slpkFilesystem) {
+      preprocessResult = await this.preprocessConversion();
+      if (!preprocessResult || analyze) {
+        return;
+      }
+    }
+
+    this.progress.startMonitoring();
+
+    this.sourceTileset = await loadFromArchive(
+      inputUrl,
+      I3SLoader,
+      {
+        ...this.loaderOptions,
+        // @ts-expect-error `isTileset` can be boolean of 'auto' but TS expects a string
+        i3s: {...this.loaderOptions.i3s, isTileset: true}
+      },
+      this.slpkFilesystem
+    );
 
     if (!this.sourceTileset) {
       return;
@@ -105,11 +136,28 @@ export default class Tiles3DConverter {
 
     this.tilesetPath = join(`${outputPath}`, `${tilesetName}`);
     this.attributeStorageInfo = this.sourceTileset.attributeStorageInfo;
+
+    await this.conversionDump.createDump(options as ConversionDumpOptions);
+    if (this.conversionDump.restored && this.options.inquirer) {
+      const result = await this.options.inquirer.prompt([
+        {
+          name: 'resumeConversion',
+          type: 'confirm',
+          message:
+            'Dump file of the previous conversion exists, do you want to resume that conversion?'
+        }
+      ]);
+      if (!result.resumeConversion) {
+        this.conversionDump.reset();
+      }
+    }
     // Removing the tilesetPath needed to exclude erroneous files after conversion
-    try {
-      await removeDir(this.tilesetPath);
-    } catch (e) {
-      // do nothing
+    if (!this.conversionDump.restored) {
+      try {
+        await removeDir(this.tilesetPath);
+      } catch (e) {
+        // do nothing
+      }
     }
 
     const rootTile: Tiles3DTileJSON = {
@@ -125,14 +173,47 @@ export default class Tiles3DConverter {
 
     const tileset = transform({root: rootTile}, tilesetTemplate());
     await writeFile(this.tilesetPath, JSON.stringify(tileset), 'tileset.json');
+    await this.conversionDump.deleteDumpFile();
+
+    this.progress.stopMonitoring();
 
-    this._finishConversion({slpk: false, outputPath, tilesetName});
+    await this._finishConversion({slpk: false, outputPath, tilesetName});
+
+    if (this.slpkFilesystem) {
+      this.slpkFilesystem.destroy();
+    }
 
     // Clean up worker pools
     const workerFarm = WorkerFarm.getWorkerFarm({});
     workerFarm.destroy();
   }
 
+  /**
+   * Preprocess stage of the tile converter. Calculate number of nodes
+   * @returns true - the conversion is possible, false - the tileset's content is not supported
+   */
+  private async preprocessConversion(): Promise<boolean> {
+    console.log(`Analyze source layer`);
+    const nodesCount = await getNodeCount(this.slpkFilesystem);
+    this.progress.stepsTotal = nodesCount;
+
+    console.log(`------------------------------------------------`);
+    console.log(`Preprocess results:`);
+    if (this.slpkFilesystem) {
+      console.log(`Node count: ${nodesCount}`);
+      if (nodesCount === 0) {
+        console.log('Node count is 0. The conversion will be interrupted.');
+        console.log(`------------------------------------------------`);
+        return false;
+      }
+    } else {
+      console.log(`Node count cannot be calculated for the remote dataset`);
+    }
+
+    console.log(`------------------------------------------------`);
+    return true;
+  }
+
   /**
    * Convert particular I3S Node
    * @param parentSourceNode the parent node tile object (@loaders.gl/tiles/Tile3D)
@@ -146,9 +227,25 @@ export default class Tiles3DConverter {
     level: number,
     childNodeInfo: NodeReference
   ): Promise<void> {
+    let nextParentNode = parentNode;
     const sourceChild = await this._loadChildNode(parentSourceNode, childNodeInfo);
     if (sourceChild.contentUrl) {
-      const content = await loadI3SContent(this.sourceTileset, sourceChild, this.loaderOptions);
+      if (
+        this.conversionDump.restored &&
+        this.conversionDump.isFileConversionComplete(`${sourceChild.id}.b3dm`) &&
+        (sourceChild.obb || sourceChild.mbs)
+      ) {
+        const {child} = this._createChildAndBoundingVolume(sourceChild);
+        parentNode.children.push(child);
+        await this._addChildren(sourceChild, child, level + 1);
+        return;
+      }
+      const content = await loadI3SContent(
+        this.sourceTileset,
+        sourceChild,
+        this.loaderOptions,
+        this.slpkFilesystem
+      );
 
       if (!content) {
         await this._addChildren(sourceChild, parentNode, level + 1);
@@ -162,39 +259,39 @@ export default class Tiles3DConverter {
         featureAttributes = await this._loadChildAttributes(sourceChild, this.attributeStorageInfo);
       }
 
-      if (!sourceChild.obb) {
-        sourceChild.obb = createObbFromMbs(sourceChild.mbs);
-      }
-
-      const boundingVolume = {
-        box: i3sObbTo3dTilesObb(sourceChild.obb, this.geoidHeightModel)
-      };
-      const child: Tiles3DTileJSON = {
-        boundingVolume,
-        geometricError: convertScreenThresholdToGeometricError(sourceChild),
-        children: []
-      };
+      const {child, boundingVolume} = this._createChildAndBoundingVolume(sourceChild);
 
       const i3sAttributesData: I3SAttributesData = {
         tileContent: content,
-        box: boundingVolume.box,
+        box: boundingVolume.box || [],
         textureFormat: sourceChild.textureFormat
       };
 
       const b3dmConverter = new B3dmConverter();
       const b3dm = await b3dmConverter.convert(i3sAttributesData, featureAttributes);
 
-      child.content = {
-        uri: `${sourceChild.id}.b3dm`,
-        boundingVolume
-      };
+      await this.conversionDump.addNode(`${sourceChild.id}.b3dm`, sourceChild.id);
       await writeFile(this.tilesetPath, new Uint8Array(b3dm), `${sourceChild.id}.b3dm`);
+      await this.conversionDump.updateConvertedNodesDumpFile(
+        `${sourceChild.id}.b3dm`,
+        sourceChild.id,
+        true
+      );
       parentNode.children.push(child);
+      nextParentNode = child;
+    }
 
-      await this._addChildren(sourceChild, child, level + 1);
-    } else {
-      await this._addChildren(sourceChild, parentNode, level + 1);
+    this.progress.stepsDone += 1;
+    let timeRemainingString = 'Calculating time left...';
+    const timeRemaining = this.progress.getTimeRemainingString();
+    if (timeRemaining) {
+      timeRemainingString = `${timeRemaining} left`;
     }
+    const percentString = this.progress.getPercentString();
+    const progressString = percentString ? ` ${percentString}%, ${timeRemainingString}` : '';
+    console.log(`[converted${progressString}]: ${childNodeInfo.id}`); // eslint-disable-line
+
+    await this._addChildren(sourceChild, nextParentNode, level + 1);
   }
 
   /**
@@ -235,20 +332,48 @@ export default class Tiles3DConverter {
     } else {
       const nodeUrl = this._relativeUrlToFullUrl(parentNode.url, childNodeInfo.href!);
       // load metadata
-      const options = {
+      const options: I3SLoaderOptions = {
         i3s: {
           ...this.loaderOptions,
+          // @ts-expect-error
           isTileHeader: true,
           loadContent: false
         }
       };
 
       console.log(`Node conversion: ${nodeUrl}`); // eslint-disable-line no-console,no-undef
-      header = await load(nodeUrl, I3SLoader, options);
+      header = await loadFromArchive(nodeUrl, I3SLoader, options, this.slpkFilesystem);
     }
     return header;
   }
 
+  /**
+   * Create child and child's boundingVolume for the converted node
+   * @param sourceChild
+   * @returns child and child's boundingVolume
+   */
+  private _createChildAndBoundingVolume(sourceChild: I3STileHeader): {
+    boundingVolume: Tile3DBoundingVolume;
+    child: Tiles3DTileJSON;
+  } {
+    if (!sourceChild.obb) {
+      sourceChild.obb = createObbFromMbs(sourceChild.mbs);
+    }
+    const boundingVolume: Tile3DBoundingVolume = {
+      box: i3sObbTo3dTilesObb(sourceChild.obb, this.geoidHeightModel)
+    };
+    const child: Tiles3DTileJSON = {
+      boundingVolume,
+      geometricError: convertScreenThresholdToGeometricError(sourceChild),
+      children: [],
+      content: {
+        uri: `${sourceChild.id}.b3dm`,
+        boundingVolume
+      }
+    };
+    return {boundingVolume, child};
+  }
+
   /**
    * Make an url of a resource from its relative url having the base url
    * @param baseUrl the base url. A resulting url will be related from this url
@@ -292,7 +417,7 @@ export default class Tiles3DConverter {
         attributeType: this._getAttributeType(attribute)
       };
 
-      promises.push(load(inputUrl, I3SAttributeLoader, options));
+      promises.push(loadFromArchive(inputUrl, I3SAttributeLoader, options, this.slpkFilesystem));
     }
     const attributesList = await Promise.all(promises);
     this._replaceNestedArrays(attributesList);

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

@@ -1,36 +1,45 @@
-import {load} from '@loaders.gl/core';
+import {LoaderWithParser, load} from '@loaders.gl/core';
 import {
   I3STileContent,
   I3STileHeader,
   I3STilesetHeader,
   I3SLoader,
-  I3SLoaderOptions
+  I3SLoaderOptions,
+  parseSLPKArchive
 } from '@loaders.gl/i3s';
+import {FileHandleFile} from '@loaders.gl/loader-utils';
+import {ZipFileSystem, makeZipCDHeaderIterator} from '@loaders.gl/zip';
+
+export type SLPKUrlParts = {slpkFileName: string; internalFileName: string};
 
 /**
  * Load I3S node content
  * @param sourceTileset - source layer JSON
  * @param sourceTile - source I3S node metadata
  * @param tilesetLoadOptions - load options for Tiles3DLoader
+ * @param slpkFilesystem - loaded instance of ZipFileSystem for local convertion from SLPK file
  * @returns - 3DTiles tile content or null
  */
 export const loadI3SContent = async (
   sourceTileset: I3STilesetHeader | null,
   sourceTile: I3STileHeader,
-  tilesetLoadOptions: I3SLoaderOptions
+  tilesetLoadOptions: I3SLoaderOptions,
+  slpkFilesystem: ZipFileSystem | null
 ): Promise<I3STileContent | null> => {
   if (!sourceTileset || !sourceTile.contentUrl) {
     return null;
   }
 
-  const loadOptions = {
+  const loadOptions: I3SLoaderOptions = {
     ...tilesetLoadOptions,
     i3s: {
       ...tilesetLoadOptions.i3s,
+      // @ts-expect-error
       isTileset: false,
+      // @ts-expect-error
       isTileHeader: false,
       _tileOptions: {
-        attributeUrls: sourceTile.attributeUrls,
+        attributeUrls: sourceTile.attributeUrls || [],
         textureUrl: sourceTile.textureUrl,
         textureFormat: sourceTile.textureFormat,
         textureLoaderOptions: sourceTile.textureLoaderOptions,
@@ -40,13 +49,103 @@ export const loadI3SContent = async (
       },
       _tilesetOptions: {
         store: sourceTileset.store,
+        // @ts-expect-error
         attributeStorageInfo: sourceTileset.attributeStorageInfo,
+        // @ts-expect-error
         fields: sourceTileset.fields
       }
     }
   };
-  const tileContent = await load(sourceTile.contentUrl, I3SLoader, loadOptions);
+  const tileContent = await loadFromArchive(
+    sourceTile.contentUrl,
+    I3SLoader,
+    loadOptions,
+    slpkFilesystem
+  );
 
-  // @ts-expect-error
   return tileContent;
 };
+
+/**
+ * Load local SLPK file to ZipFileSystem instance
+ * @param url - path to SLPK file
+ * @returns instance of ZipFileSystem or null if url is not an SLPK file
+ */
+export async function openSLPK(url: string): Promise<ZipFileSystem | null> {
+  const slpkUrlParts = url.split('.slpk');
+  const {slpkFileName} = getSlpkUrlParts(url) || {};
+  if (slpkFileName) {
+    const slpkFileName = `${slpkUrlParts[0]}.slpk`;
+    const fileProvider = new FileHandleFile(slpkFileName);
+    const archive = await parseSLPKArchive(fileProvider, undefined, slpkFileName);
+    const fileSystem = new ZipFileSystem(archive);
+    return fileSystem;
+  }
+  return null;
+}
+
+/**
+ * Load a resource with load options and .3tz format support
+ * @param url - resource URL
+ * @param loader - loader to parse data (Tiles3DLoader / CesiumIonLoader)
+ * @param loadOptions - i3s loader options
+ * @returns i3s resource
+ */
+export async function loadFromArchive(
+  url: string,
+  loader: LoaderWithParser,
+  loadOptions: I3SLoaderOptions,
+  fileSystem: ZipFileSystem | null
+) {
+  const slpkUrlParts = getSlpkUrlParts(url);
+  if (fileSystem !== null && slpkUrlParts !== null) {
+    const {internalFileName} = slpkUrlParts;
+    const content = await load(internalFileName, loader, {
+      ...loadOptions,
+      fetch: fileSystem.fetch.bind(fileSystem)
+    });
+    return content;
+  }
+  return await load(url, loader, loadOptions);
+}
+
+/**
+ * Extract slpk file path and internal from the url
+ * For example, for `./path/to/file.slpk/nodes/0` it returns
+ * {"slpkFileName": "./path/to/file.slpk", "internalFileName": "/nodes/0" }
+ * @param url full internal file path
+ * @returns object with internal slpk file parts
+ */
+function getSlpkUrlParts(url: string): SLPKUrlParts | null {
+  const slpkUrlParts = url.split('.slpk');
+  let result: SLPKUrlParts | null;
+  // Not '.slpk'. The file will be loaded with global fetch function
+  if (slpkUrlParts.length === 1) {
+    result = null;
+  } else if (slpkUrlParts.length === 2) {
+    result = {slpkFileName: `${slpkUrlParts[0]}.slpk`, internalFileName: slpkUrlParts[1].slice(1)};
+  } else {
+    throw new Error('Unexpected URL format');
+  }
+  return result;
+}
+
+/**
+ * Get nodes count inside SLPK
+ * @param fileSystem - file system of SLPK
+ * @returns number of nodes
+ */
+export async function getNodeCount(fileSystem: ZipFileSystem | null): Promise<number> {
+  if (!fileSystem?.fileProvider) {
+    return 0;
+  }
+  let count = 0;
+  const filesIterator = makeZipCDHeaderIterator(fileSystem.fileProvider);
+  for await (const file of filesIterator) {
+    const filename = file.fileName;
+    if (filename.indexOf('3dNodeIndexDocument.json.gz') >= 0) {
+      count++;
+    }
+  }
+  return count;
+}

package/src/converter-cli.ts

@@ -59,6 +59,8 @@ type TileConversionOptions = {
   metadataClass?: string;
   /** With this options the tileset content will be analyzed without conversion */
   analyze?: boolean;
+  /** Skip all prompts that stop conversion and wait for a user input */
+  quiet?: boolean;
 };
 
 /* During validation we check that particular options are defined so they can't be undefined */
@@ -100,36 +102,40 @@ async function main() {
   if (options.addHash) {
     const validatedOptions = validateOptions(options, true);
     let finalPath = validatedOptions.tileset;
-    if (validatedOptions.output === 'data') {
-      const nameWithoutExt = validatedOptions.tileset.substring(
-        0,
-        validatedOptions.tileset.length - 5
-      );
 
-      const result = await inquirer.prompt<{isNewFileRequired: boolean}>([
-        {
-          name: 'isNewFileRequired',
-          type: 'list',
-          message: 'What would you like to do?',
-          choices: [
-            {
-              name: 'Add hash file to the current SLPK file',
-              value: false
-            },
-            {
-              name: `Create a new file ${nameWithoutExt}-hash.slpk with hash file inside`,
-              value: true
-            }
-          ]
-        }
-      ]);
+    if (!options.quiet) {
+      if (validatedOptions.output === 'data') {
+        const nameWithoutExt = validatedOptions.tileset.substring(
+          0,
+          validatedOptions.tileset.length - 5
+        );
+
+        const result = await inquirer.prompt<{isNewFileRequired: boolean}>([
+          {
+            name: 'isNewFileRequired',
+            type: 'list',
+            message: 'What would you like to do?',
+            choices: [
+              {
+                name: 'Add hash file to the current SLPK file',
+                value: false
+              },
+              {
+                name: `Create a new file ${nameWithoutExt}-hash.slpk with hash file inside`,
+                value: true
+              }
+            ]
+          }
+        ]);
 
-      if (result.isNewFileRequired) {
-        finalPath = `${nameWithoutExt}-hash.slpk`;
+        if (result.isNewFileRequired) {
+          finalPath = `${nameWithoutExt}-hash.slpk`;
+        }
+      } else {
+        finalPath = validatedOptions.output;
       }
-    } else {
-      finalPath = validatedOptions.output;
     }
+
     if (finalPath !== validatedOptions.tileset) {
       await copyFile(validatedOptions.tileset, finalPath);
     }
@@ -190,6 +196,9 @@ function printHelp(): void {
     '--metadata-class [One of the list of feature metadata classes, detected by converter on "analyze" stage, default: not set]'
   );
   console.log('--validate [Enable validation]');
+  console.log(
+    '--quiet [Skip all prompts that stop conversion and wait for a user input: default: false]'
+  );
   process.exit(0); // eslint-disable-line
 }
 
@@ -210,7 +219,9 @@ async function convert(options: ValidatedTileConversionOptions) {
         outputPath: options.output,
         tilesetName: options.name,
         maxDepth: options.maxDepth,
-        egmFilePath: options.egm
+        egmFilePath: options.egm,
+        analyze: options.analyze,
+        inquirer: options.quiet ? undefined : inquirer
       });
       break;
     case TILESET_TYPE._3DTILES:
@@ -232,7 +243,7 @@ async function convert(options: ValidatedTileConversionOptions) {
         instantNodeWriting: options.instantNodeWriting,
         metadataClass: options.metadataClass,
         analyze: options.analyze,
-        inquirer
+        inquirer: options.quiet ? undefined : inquirer
       });
       break;
     default:
@@ -307,7 +318,8 @@ function parseOptions(args: string[]): TileConversionOptions {
     generateBoundingVolumes: false,
     validate: false,
     slpk: false,
-    addHash: false
+    addHash: false,
+    quiet: false
   };
 
   // eslint-disable-next-line complexity
@@ -368,6 +380,9 @@ function parseOptions(args: string[]): TileConversionOptions {
         case '--analyze':
           opts.analyze = getBooleanValue(index, args);
           break;
+        case '--quiet':
+          opts.quiet = getBooleanValue(index, args);
+          break;
         case '--metadata-class':
           opts.metadataClass = getStringValue(index, args);
           break;

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

@@ -4,8 +4,17 @@ import type {
   Tiles3DTileJSONPostprocessed,
   Tiles3DTilesetJSONPostprocessed
 } from '@loaders.gl/3d-tiles';
-import {Tiles3DArchiveFileSystem} from '@loaders.gl/3d-tiles';
+import {Tiles3DArchive} from '@loaders.gl/3d-tiles';
 import {LoaderWithParser, load} from '@loaders.gl/core';
+import {FileHandleFile, FileProvider} from '@loaders.gl/loader-utils';
+import {
+  CD_HEADER_SIGNATURE,
+  ZipFileSystem,
+  parseHashTable,
+  parseZipCDFileHeader,
+  parseZipLocalFileHeader,
+  searchFromTheEnd
+} from '@loaders.gl/zip';
 
 /**
  * Load nested 3DTiles tileset. If the sourceTile is not nested tileset - do nothing
@@ -104,7 +113,10 @@ export async function loadFromArchive(
   }
   if (filename) {
     const tz3Path = `${tz3UrlParts[0]}.3tz`;
-    const fileSystem = new Tiles3DArchiveFileSystem(tz3Path);
+    const fileProvider = new FileHandleFile(tz3Path);
+    const hashTable = await loadHashTable(fileProvider);
+    const archive = new Tiles3DArchive(fileProvider, hashTable, tz3Path);
+    const fileSystem = new ZipFileSystem(archive);
     const content = await load(filename, loader, {
       ...loadOptions,
       fetch: fileSystem.fetch.bind(fileSystem)
@@ -123,3 +135,41 @@ export async function loadFromArchive(
 export function isNestedTileset(tile: Tiles3DTileJSONPostprocessed) {
   return tile?.type === 'json' || tile?.type === '3tz';
 }
+
+/**
+ * Load hash file from 3TZ
+ * @param fileProvider - binary reader of 3TZ
+ * @returns hash table of the 3TZ file content or undefined if the hash file is not presented inside
+ */
+async function loadHashTable(
+  fileProvider: FileProvider
+): Promise<undefined | Record<string, bigint>> {
+  let hashTable: undefined | Record<string, bigint>;
+
+  const hashCDOffset = await searchFromTheEnd(fileProvider, CD_HEADER_SIGNATURE);
+
+  const cdFileHeader = await parseZipCDFileHeader(hashCDOffset, fileProvider);
+
+  // '@3dtilesIndex1@' is index file that must be the last in the archive. It allows
+  // to improve load and read performance when the archive contains a very large number
+  // of files.
+  if (cdFileHeader?.fileName === '@3dtilesIndex1@') {
+    const localFileHeader = await parseZipLocalFileHeader(
+      cdFileHeader.localHeaderOffset,
+      fileProvider
+    );
+    if (!localFileHeader) {
+      throw new Error('corrupted 3tz');
+    }
+
+    const fileDataOffset = localFileHeader.fileDataOffset;
+    const hashFile = await fileProvider.slice(
+      fileDataOffset,
+      fileDataOffset + localFileHeader.compressedSize
+    );
+
+    hashTable = parseHashTable(hashFile);
+  }
+
+  return hashTable;
+}

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

@@ -322,7 +322,6 @@ export default class I3SConverter {
       console.log('Feature metadata classes have not been found');
     }
 
-    console.log(`------------------------------------------------`);
     if (
       !meshTopologyTypes.has(GLTFPrimitiveModeString.TRIANGLES) &&
       !meshTopologyTypes.has(GLTFPrimitiveModeString.TRIANGLE_STRIP)
@@ -334,6 +333,7 @@ export default class I3SConverter {
       return false;
     }
 
+    console.log(`------------------------------------------------`);
     return true;
   }