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

package/src/i3s-server/routes/slpk-router.js

@@ -0,0 +1,33 @@
+const express = require('express');
+const {getFileByUrl} = require('../controllers/slpk-controller');
+const createSceneServer = require('../utils/create-scene-server');
+
+const sceneServerRouter = express.Router();
+sceneServerRouter.get('*', async function (req, res, next) {
+  const file = await getFileByUrl('/');
+  if (file) {
+    const layer = JSON.parse(file.toString());
+    const sceneServerResponse = createSceneServer(layer.name, layer);
+    res.send(sceneServerResponse);
+  } else {
+    res.status(404);
+    res.send('File not found');
+  }
+});
+
+const router = express.Router();
+router.get('*', async function (req, res, next) {
+  console.log(req.path);
+  const file = await getFileByUrl(req.path);
+  if (file) {
+    res.send(file);
+  } else {
+    res.status(404);
+    res.send('File not found');
+  }
+});
+
+module.exports = {
+  sceneServerRouter,
+  router
+};

package/src/i3s-server/utils/create-scene-server.js

@@ -0,0 +1,15 @@
+const {v4: uuidv4} = require('uuid');
+
+const createSceneServer = (name, layer) => {
+  return {
+    serviceItemId: uuidv4().replace(/-/gi, ''),
+    serviceName: name,
+    name,
+    currentVersion: '10.7',
+    serviceVersion: '1.8',
+    supportedBindings: ['REST'],
+    layers: [layer]
+  };
+};
+
+module.exports = createSceneServer;

package/src/index.ts

@@ -1,6 +1,2 @@
 export {default as I3SConverter} from './i3s-converter/i3s-converter';
-export {default as NodePages} from './i3s-converter/helpers/node-pages';
-
 export {default as Tiles3DConverter} from './3d-tiles-converter/3d-tiles-converter';
-
-export {DepsInstaller} from './deps-installer/deps-installer';

package/src/lib/utils/{compress-util.js → compress-util.ts}

@@ -9,7 +9,13 @@ import {MD5Hash} from '@loaders.gl/crypto';
 import crypt from 'crypt';
 import {getAbsoluteFilePath} from './file-utils';
 
-export function compressFileWithGzip(pathFile) {
+/**
+ * Compress file to gzip file
+ *
+ * @param pathFile - the path to the file
+ * @return the path to the gzip file
+ */
+export function compressFileWithGzip(pathFile: string): Promise<string> {
   const compressedPathFile = `${pathFile}.gz`;
   const gzip = createGzip();
   const input = createReadStream(pathFile);
@@ -28,7 +34,18 @@ export function compressFileWithGzip(pathFile) {
   });
 }
 
-export async function compressFilesWithZip(fileMap, outputFile, level = 0) {
+/**
+ * Compress files from map into slpk file
+ *
+ * @param fileMap - map with file paths (key: output path, value: input path)
+ * @param outputFile - output slpk file
+ * @param level - compression level
+ */
+export async function compressFilesWithZip(
+  fileMap: {[key: string]: string},
+  outputFile: string,
+  level: number = 0
+) {
   // Before creating a new file, we need to delete the old file
   try {
     await removeFile(outputFile);
@@ -82,16 +99,44 @@ export async function compressFilesWithZip(fileMap, outputFile, level = 0) {
   });
 }
 
-export async function compressWithChildProcess() {
+/**
+ * Compress files using external tool 'zip'/'7z'
+ *
+ * @param inputFolder - folder to archive - for cwd option
+ * @param outputFile - output slpk file
+ * @param level - compression level
+ * @param inputFiles - input files path to pass to the executable as option
+ * @param sevenZipExe - path to 7z.exe executable
+ */
+export async function compressWithChildProcess(
+  inputFolder: string,
+  outputFile: string,
+  level: number,
+  inputFiles: string,
+  sevenZipExe: string
+) {
   // eslint-disable-next-line no-undef
   if (process.platform === 'win32') {
-    await compressWithChildProcessWindows(...arguments);
+    await compressWithChildProcessWindows(inputFolder, outputFile, level, inputFiles, sevenZipExe);
   } else {
-    await compressWithChildProcessUnix(...arguments);
+    await compressWithChildProcessUnix(inputFolder, outputFile, level, inputFiles);
   }
 }
 
-async function compressWithChildProcessUnix(inputFolder, outputFile, level = 0, inputFiles = '.') {
+/**
+ * Compress files using external linux tool 'zip'
+ *
+ * @param inputFolder - folder to archive - for cwd option
+ * @param outputFile - output slpk file
+ * @param level - compression level
+ * @param inputFiles - input files path to pass to the executable as option
+ */
+async function compressWithChildProcessUnix(
+  inputFolder: string,
+  outputFile: string,
+  level: number = 0,
+  inputFiles: string = '.'
+) {
   const fullOutputFile = getAbsoluteFilePath(outputFile);
   const args = [`-${level}`, '-r', fullOutputFile, inputFiles];
   const childProcess = new ChildProcessProxy();
@@ -105,12 +150,21 @@ async function compressWithChildProcessUnix(inputFolder, outputFile, level = 0,
   });
 }
 
+/**
+ * Compress files using windows external tool '7z'
+ *
+ * @param inputFolder - folder to archive - for cwd option
+ * @param outputFile - output slpk file
+ * @param level - compression level
+ * @param inputFiles - input files path to pass to the executable as option
+ * @param sevenZipExe - path to 7z.exe executable
+ */
 async function compressWithChildProcessWindows(
-  inputFolder,
-  outputFile,
-  level = 0,
-  inputFiles = join('.', '*'),
-  sevenZipExe
+  inputFolder: string,
+  outputFile: string,
+  level: number = 0,
+  inputFiles: string = join('.', '*'),
+  sevenZipExe: string
 ) {
   // Workaround for @listfile issue. In 7z.exe @-leading files are handled as listfiles
   // https://sevenzip.osdn.jp/chm/cmdline/syntax.htm
@@ -131,10 +185,17 @@ async function compressWithChildProcessWindows(
   });
 }
 
-export async function generateHash128FromZip(inputZipFile, outputFile) {
+/**
+ * Generate hash file from zip archive
+ * https://github.com/Esri/i3s-spec/blob/master/docs/1.7/slpk_hashtable.cmn.md
+ *
+ * @param inputZipFile
+ * @param outputFile
+ */
+export async function generateHash128FromZip(inputZipFile: string, outputFile: string) {
   const input = await fs.readFile(inputZipFile);
   const zip = await JSZip.loadAsync(input);
-  const hashTable = [];
+  const hashTable: {key: string; value: string}[] = [];
   const zipFiles = zip.files;
   for (const relativePath in zipFiles) {
     const zipEntry = zipFiles[relativePath];
@@ -169,7 +230,7 @@ export async function generateHash128FromZip(inputZipFile, outputFile) {
     });
     for (const key in hashTable) {
       const item = hashTable[key];
-      const value = _longToByteArray(item.value);
+      const value = longToByteArray(item.value);
       // TODO: perhaps you need to wait for the 'drain' event if the write returns 'false'
       // eslint-disable-next-line no-undef
       output.write(Buffer.from(crypt.hexToBytes(item.key).concat(value)));
@@ -178,19 +239,45 @@ export async function generateHash128FromZip(inputZipFile, outputFile) {
   });
 }
 
-function _longToByteArray(long) {
+/**
+ * Encode 64 bit value to byte array
+ *
+ * @param long - stringified number
+ * @returns
+ */
+function longToByteArray(long: string): number[] {
   const buffer = new ArrayBuffer(8); // JS numbers are 8 bytes long, or 64 bits
   const longNum = new Float64Array(buffer); // so equivalent to Float64
-  longNum[0] = long;
+  longNum[0] = parseInt(long);
   return Array.from(new Uint8Array(buffer)).reverse(); // reverse to get little endian
 }
 
-export async function addFileToZip(inputFolder, fileName, zipFile, sevenZipExe) {
+/**
+ * Add file to zip archive
+ *
+ * @param inputFile
+ * @param fileName
+ * @param zipFile
+ * @param sevenZipExe
+ */
+export async function addFileToZip(
+  inputFolder: string,
+  fileName: string,
+  zipFile: string,
+  sevenZipExe: string
+) {
   await compressWithChildProcess(inputFolder, zipFile, 0, fileName, sevenZipExe);
   console.log(`${fileName} added to ${zipFile}.`); // eslint-disable-line
 }
 
-function appendFileToArchive(archive, subFileName, subFileData) {
+/**
+ *
+ * @param archive zip archive instance
+ * @param subFileName file path inside archive
+ * @param subFileData source file path
+ * @returns
+ */
+function appendFileToArchive(archive: any, subFileName: string, subFileData: string) {
   return new Promise((resolve) => {
     const fileStream = createReadStream(subFileData);
     console.log(`Compression start: ${subFileName}`); // eslint-disable-line no-undef,no-console

package/src/lib/utils/file-utils.ts

@@ -0,0 +1,140 @@
+import {load} from '@loaders.gl/core';
+import {JSONLoader} from '@loaders.gl/loader-utils';
+import {promises as fs} from 'fs';
+import {isAbsolute, join} from 'path';
+import {compressFileWithGzip} from './compress-util';
+
+/**
+ * Write a file with data and name fileName to path
+ *
+ * @param path - output path
+ * @param data - file content
+ * @param fileName - name of output file (default: index.json)
+ */
+export async function writeFile(
+  path: string,
+  data: string | Uint8Array | ArrayBuffer | Promise<ArrayBuffer>,
+  fileName: string = 'index.json'
+): Promise<string> {
+  let toWriteData: string | Uint8Array;
+  if (data instanceof Promise) {
+    toWriteData = new Uint8Array(await data);
+  } else if (data instanceof ArrayBuffer) {
+    toWriteData = new Uint8Array(data as ArrayBuffer);
+  } else {
+    toWriteData = data;
+  }
+  await fs.mkdir(path, {recursive: true});
+  const pathFile = join(path, fileName);
+  try {
+    await fs.writeFile(pathFile, toWriteData);
+  } catch (err) {
+    throw err;
+  }
+  console.log(`${pathFile} saved.`); // eslint-disable-line
+  return pathFile;
+}
+
+/**
+ * Write a file with data and name fileName to path - specific one for further packaging into slpk
+ *
+ * @param path - output path
+ * @param data - file content
+ * @param fileName - name of output file (default: index.json)
+ * @param compress - if need to compress file with gzip (default: true)
+ * @param compressList - if set - the file should be added to this list and compressed in the end of conversion
+ */
+export async function writeFileForSlpk(
+  path: string,
+  data: string | Uint8Array | ArrayBuffer | Promise<ArrayBuffer>,
+  fileName: string = 'index.json',
+  compress: boolean = true,
+  compressList?: string[] | null
+): Promise<string | null> {
+  const pathFile = await writeFile(path, data, fileName);
+  if (compress) {
+    if (compressList) {
+      if (!compressList.includes(pathFile)) {
+        compressList.push(pathFile);
+        return `${pathFile}.gz`;
+      } else {
+        return null;
+      }
+    } else {
+      const pathGzFile = await compressFileWithGzip(pathFile);
+      // After compression, we don't need an uncompressed file
+      await removeFile(pathFile);
+      return pathGzFile;
+    }
+  }
+  return pathFile;
+}
+
+/**
+ * Open json file
+ * @param path - path to the file
+ * @param fileName - file name
+ * @returns object
+ */
+export async function openJson(path: string, fileName: string): Promise<{[key: string]: any}> {
+  return new Promise((resolve, reject) => {
+    let count = 0;
+    console.log(`load ${path}/${fileName}.`); // eslint-disable-line
+    const intervalId = setInterval(() => {
+      const pathFile = join(path, fileName);
+      load(pathFile, JSONLoader)
+        .then((result) => {
+          clearInterval(intervalId);
+          resolve(result);
+        })
+        .catch(() => {
+          count++;
+          if (count > 100) {
+            clearInterval(intervalId);
+            reject(new Error(`Cannon load ${path}/${fileName}.`));
+          }
+        });
+    }, 200);
+  });
+}
+
+/**
+ * Check if the file exists
+ * @param fileName - full name of file
+ * @returns true if file exists, otherwise - false
+ */
+export async function isFileExists(fileName: string): Promise<boolean> {
+  try {
+    await fs.stat(fileName);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Remove dir with path
+ *
+ * @param path
+ */
+export function removeDir(path: string) {
+  // (node:35607) [DEP0147] DeprecationWarning: In future versions of Node.js, fs.rmdir(path, { recursive: true }) will be removed. Use fs.rm(path, { recursive: true }) instead
+  return fs.rm(path, {recursive: true});
+}
+
+/**
+ * Remove file with path
+ *
+ * @param path
+ */
+export function removeFile(path: string) {
+  return fs.unlink(path);
+}
+
+/**
+ * Generates absolute file path
+ * @param filePath
+ */
+export function getAbsoluteFilePath(filePath: string) {
+  return isAbsolute(filePath) ? filePath : join(process.cwd(), filePath);
+}

package/src/lib/utils/geometry-utils.ts

@@ -0,0 +1,14 @@
+/**
+ * luma.gl can not work without indices now:
+ * https://github.com/visgl/luma.gl/blob/d8cad75b9f8ca3e578cf078ed9d19e619c2ddbc9/modules/experimental/src/gltf/gltf-instantiator.js#L115
+ * This method generates syntetic indices array: [0, 1, 2, 3, .... , vertexCount-1]
+ * @param {number} vertexCount - vertex count in the geometry
+ * @returns {Uint32Array} indices array.
+ */
+export const generateSyntheticIndices = (vertexCount: number): Uint32Array => {
+  const result = new Uint32Array(vertexCount);
+  for (let index = 0; index < vertexCount; index++) {
+    result[index] = index;
+  }
+  return result;
+};

package/src/lib/utils/{lod-conversion-utils.js → lod-conversion-utils.ts}

@@ -1,9 +1,12 @@
+import {Tiles3DTileJSONPostprocessed} from '@loaders.gl/3d-tiles';
+import {BoundingVolumes} from '@loaders.gl/i3s';
+import {Tile3D} from '@loaders.gl/tiles';
+
 // https://cesium.com/docs/cesiumjs-ref-doc/Cesium3DTileset.html
 const DEFAULT_MAXIMUM_SCREEN_SPACE_ERROR = 16;
 /**
  * Do conversion from geometric error to screen threshold
- * @param {Object} tile
- * @param {Object} coordinates
+ * 
  * In 3DTiles we have HLOD logic and parent tile also has bigger lodMetric value then its children.
  * In I3s we have reverse logic related to maxError. Parent has lower maxError than its child.
  * In nodes where are no children tile.lodMetricValue is 0. This is because of logic of HLOD in 3DTiles
@@ -13,9 +16,27 @@ const DEFAULT_MAXIMUM_SCREEN_SPACE_ERROR = 16;
  * https://github.com/Esri/i3s-spec/blob/master/docs/1.7/lodSelection.cmn.md
  * To avoid infinity values when we do calculations of maxError we shold replace 0 with value which allows us
  * to make child maxError bigger than his parent maxError.
+ * 
+ * @param tile - 3d-tiles tile JSON
+ * @param coordinates - node converted coordinates
+ * @returns An array of LOD metrics in format compatible with i3s 3DNodeIndexDocument.lodSelection
+ * @example 
+ *  [
+        {
+            "metricType": "maxScreenThresholdSQ",
+            "maxError": 870638.071285568
+        },
+        {
+            "metricType": "maxScreenThreshold",
+            "maxError": 1052.8679031638949
+        }
+    ]
  */
-export function convertGeometricErrorToScreenThreshold(tile, coordinates) {
-  const lodSelection = [];
+export function convertGeometricErrorToScreenThreshold(
+  tile: Tiles3DTileJSONPostprocessed,
+  coordinates: BoundingVolumes
+) {
+  const lodSelection: {metricType: string; maxError: number}[] = [];
   const boundingVolume = tile.boundingVolume;
   const lodMetricValue = tile.lodMetricValue || 0.1;
   const maxScreenThreshold = {
@@ -38,7 +59,12 @@ export function convertGeometricErrorToScreenThreshold(tile, coordinates) {
   return lodSelection;
 }
 
-export function convertScreenThresholdToGeometricError(node) {
+/**
+ * Convert LOD metric from "Screen Threshold" to "Screen Space Error"
+ * @param node - i3s node data
+ * @returns lod metric in 3d-tiles format
+ */
+export function convertScreenThresholdToGeometricError(node: Tile3D): number {
   const metricData = node.header.lodSelection.maxScreenThreshold || {};
   let maxError = metricData.maxError;
   if (!maxError) {

package/src/lib/utils/queue.ts

@@ -0,0 +1,17 @@
+export class Queue<T> extends Array<T> {
+  enqueue(val: T) {
+    this.push(val);
+  }
+
+  dequeue(): T | undefined {
+    return this.shift();
+  }
+
+  peek(): T {
+    return this[0];
+  }
+
+  isEmpty() {
+    return this.length === 0;
+  }
+}

package/src/lib/utils/write-queue.ts

@@ -0,0 +1,110 @@
+import {Queue} from './queue';
+import process from 'process';
+
+/** Memory limit size is based on testing */
+const MEMORY_LIMIT = 4 * 1024 * 1024 * 1024; // 4GB
+
+export type WriteQueueItem = {
+  archiveKey?: string;
+  /**
+   * writePromise() returns a Promise that will be awaited in Promise.allSettled(promises);
+   * Arguments for this call are specified in writeQueue.enqueue call like this:
+   * await writeQueue.enqueue({
+   *     archiveKey: `nodePages/xxx.json.gz`,
+   *     writePromise: () => writeFileForSlpk(slpkPath, data, `xxx.json`)
+   * });
+   * Note, a function like writeFileForSlpk should NOT be called when initializing the object for enqueue().
+   * If he function is called, the promise will be created
+   * and the function will allocate resources (file descriptors) for file writing.
+   * It will be done for ALL items in the queue, which is not supposed to happen.
+   * That's why the function should be passed as
+   *   writePromise: () => writeFileForSlpk(slpkPath, content, `xxx.json`)
+   * instead of
+   *  writePromise: writeFileForSlpk(slpkPath, content, `xxx.json`) // INCORRECT !
+   */
+  writePromise: () => Promise<string | null>;
+};
+
+export default class WriteQueue<T extends WriteQueueItem> extends Queue<T> {
+  private intervalId?: NodeJS.Timeout;
+  public writePromise: Promise<void> | null = null;
+  public fileMap: {[key: string]: string} = {};
+  public listeningInterval: number;
+  public writeConcurrency: number;
+
+  constructor(listeningInterval: number = 2000, writeConcurrency: number = 400) {
+    super();
+    this.listeningInterval = listeningInterval;
+    this.writeConcurrency = writeConcurrency;
+  }
+
+  async enqueue(val: T, writeImmediately: boolean = false) {
+    if (writeImmediately) {
+      const {archiveKey, writePromise} = val as WriteQueueItem;
+      const result = await writePromise();
+      if (archiveKey && result) {
+        this.fileMap[archiveKey] = result;
+      }
+    } else {
+      super.enqueue(val);
+      /** https://nodejs.org/docs/latest-v14.x/api/process.html#process_process_memoryusage */
+      if (process.memoryUsage().rss > MEMORY_LIMIT) {
+        await this.startWrite();
+      }
+    }
+  }
+
+  startListening() {
+    this.intervalId = setInterval(this.startWrite.bind(this), this.listeningInterval);
+  }
+
+  stopListening() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+    }
+  }
+
+  async startWrite(): Promise<void> {
+    if (!this.writePromise) {
+      this.writePromise = this.doWrite();
+    }
+    await this.writePromise;
+    this.writePromise = null;
+  }
+
+  async finalize(): Promise<void> {
+    this.stopListening();
+    await this.startWrite();
+  }
+
+  private async doWrite(): Promise<void> {
+    while (this.length) {
+      const promises: Promise<string | null>[] = [];
+      const archiveKeys: (string | undefined)[] = [];
+      for (let i = 0; i < this.writeConcurrency; i++) {
+        const item = this.dequeue();
+        if (!item) {
+          break;
+        }
+        const {archiveKey, writePromise} = item as WriteQueueItem;
+        archiveKeys.push(archiveKey);
+        const promise = writePromise();
+        promises.push(promise);
+      }
+      const writeResults = await Promise.allSettled(promises);
+      this.updateFileMap(archiveKeys, writeResults);
+    }
+  }
+
+  private updateFileMap(
+    archiveKeys: (string | undefined)[],
+    writeResults: PromiseSettledResult<string | null>[]
+  ) {
+    for (let i = 0; i < archiveKeys.length; i++) {
+      const archiveKey = archiveKeys[i];
+      if (archiveKey && 'value' in writeResults[i]) {
+        this.fileMap[archiveKey] = (writeResults[i] as PromiseFulfilledResult<string>).value;
+      }
+    }
+  }
+}

package/src/pgm-loader.ts

@@ -1,11 +1,10 @@
 import type {LoaderWithParser} from '@loaders.gl/loader-utils';
+import {parsePGM} from '@math.gl/geoid';
 
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
 const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
 
-import {parsePgm} from './lib/pgm-parser';
-
 /**
  * Loader for PGM - Netpbm grayscale image format
  */
@@ -15,7 +14,8 @@ export const PGMLoader: LoaderWithParser = {
   module: 'tile-converter',
   version: VERSION,
   mimeTypes: ['image/x-portable-graymap'],
-  parse: (arrayBuffer, options) => parsePgm(new Uint8Array(arrayBuffer), options),
+  // @ts-expect-error LoaderOptions does not have cubic parameter
+  parse: async (arrayBuffer, options) => parsePGM(new Uint8Array(arrayBuffer), options),
   extensions: ['pgm'],
   options: {
     // TODO - use pgm namespace

package/src/workers/3d-tiles-attributes-worker.ts

@@ -0,0 +1,6 @@
+import {createWorker} from '@loaders.gl/worker-utils';
+import B3dmConverter from '../3d-tiles-converter/helpers/b3dm-converter';
+
+const b3dmConverter = new B3dmConverter();
+
+createWorker(async (data, options = {}) => b3dmConverter.convert(data, options.featureAttributes));

package/src/workers/i3s-attributes-worker.ts

@@ -0,0 +1,7 @@
+import {createWorker} from '@loaders.gl/worker-utils';
+import {convertAttributes} from '../i3s-converter/helpers/geometry-converter';
+
+createWorker(
+  async (data, options = {}) =>
+    await convertAttributes(data, options.materialAndTextureList, options.useCartesianPositions)
+);

package/dist/3d-tiles-converter/3d-tiles-converter.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/3d-tiles-converter/3d-tiles-converter.ts"],"names":["join","process","transform","load","I3SLoader","I3SAttributeLoader","Tileset3D","Tile3D","PGMLoader","i3sObbTo3dTilesObb","convertScreenThresholdToGeometricError","writeFile","removeDir","calculateFilesSize","timeConverter","TILESET","tilesetTemplate","B3dmConverter","createObbFromMbs","I3S","Tiles3DConverter","constructor","options","tilesetPath","vertexCounter","conversionStartTime","geoidHeightModel","sourceTileset","attributeStorageInfo","convert","inputUrl","outputPath","tilesetName","maxDepth","egmFilePath","hrtime","console","log","sourceTilesetJson","root","header","obb","mbs","e","rootTile","boundingVolume","box","geometricError","children","_addChildren","tileset","JSON","stringify","_finishConversion","slpk","parentSourceNode","parentNode","level","childNodeInfo","sourceChild","_loadChildNode","push","contentUrl","_loadTile","content","vertexCount","attributes","_loadChildAttributes","child","b3dm","uri","id","Uint8Array","unloadContent","nodePages","nodePagesTile","formTileFromNodePages","loader","nodeUrl","_relativeUrlToFullUrl","url","href","i3s","loadOptions","isTileHeader","loadContent","baseUrl","relativeUrl","resultArray","split","relativeUrlArray","folder","slice","promises","attributeUrls","index","length","attribute","attributeName","name","attributeType","_getAttributeType","attributesList","Promise","all","_replaceNestedArrays","Object","assign","attributeValues","valueType","objectIds","attributeObject","key","Array","from","params","filesSize","diff","conversionTime"],"mappings":"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","sourcesContent":["import type {AttributeStorageInfo, FeatureAttribute, NodeReference} from '@loaders.gl/i3s';\nimport type {Node3D} from '@loaders.gl/3d-tiles';\n\nimport {join} from 'path';\nimport process from 'process';\nimport transform from 'json-map-transform';\nimport {load} from '@loaders.gl/core';\nimport {I3SLoader, I3SAttributeLoader} from '@loaders.gl/i3s';\nimport {Tileset3D, Tile3D} from '@loaders.gl/tiles';\n\nimport {PGMLoader} from '../pgm-loader';\nimport {i3sObbTo3dTilesObb} from './helpers/i3s-obb-to-3d-tiles-obb';\nimport {convertScreenThresholdToGeometricError} from '../lib/utils/lod-conversion-utils';\nimport {writeFile, removeDir} from '../lib/utils/file-utils';\nimport {calculateFilesSize, timeConverter} from '../lib/utils/statistic-utills';\nimport {TILESET as tilesetTemplate} from './json-templates/tileset';\nimport B3dmConverter from './helpers/b3dm-converter';\nimport {createObbFromMbs} from '../i3s-converter/helpers/coordinate-converter';\nimport {GeoidHeightModel} from '../lib/geoid-height-model';\n\nconst I3S = 'I3S';\n\n/**\n * Converter from i3s to 3d-tiles\n */\nexport default class Tiles3DConverter {\n  options: any;\n  tilesetPath: string;\n  vertexCounter: number;\n  conversionStartTime: [number, number];\n  geoidHeightModel: GeoidHeightModel;\n  sourceTileset: Tileset3D;\n  attributeStorageInfo: AttributeStorageInfo;\n\n  constructor() {\n    this.options = {};\n    this.tilesetPath = '';\n    this.vertexCounter = 0;\n    this.conversionStartTime = [0, 0];\n    this.geoidHeightModel = null;\n    this.sourceTileset = null;\n    this.attributeStorageInfo = null;\n  }\n\n  /**\n   * Convert i3s format data to 3dTiles\n   * @param options\n   * @param options.inputUrl the url to read the tileset from\n   * @param options.outputPath the output filename\n   * @param options.tilesetName the output name of the tileset\n   * @param options.egmFilePath location of *.pgm file to convert heights from ellipsoidal to gravity-related format\n   * @param options.maxDepth The max tree depth of conversion\n   */\n  private async convert(options: {\n    inputUrl: string;\n    outputPath: string;\n    tilesetName: string;\n    maxDepth: number;\n    egmFilePath: string;\n  }): Promise<any> {\n    const {inputUrl, outputPath, tilesetName, maxDepth, egmFilePath} = options;\n    this.conversionStartTime = process.hrtime();\n    this.options = {maxDepth};\n\n    console.log('Loading egm file...'); // eslint-disable-line\n    this.geoidHeightModel = await load(egmFilePath, PGMLoader);\n    console.log('Loading egm file completed!'); // eslint-disable-line\n\n    const sourceTilesetJson = await load(inputUrl, I3SLoader, {});\n    this.sourceTileset = new Tileset3D(sourceTilesetJson, {});\n\n    if (!this.sourceTileset.root.header.obb) {\n      this.sourceTileset.root.header.obb = createObbFromMbs(this.sourceTileset.root.header.mbs);\n    }\n\n    this.tilesetPath = join(`${outputPath}`, `${tilesetName}`);\n    this.attributeStorageInfo = sourceTilesetJson.attributeStorageInfo;\n    // Removing the tilesetPath needed to exclude erroneous files after conversion\n    try {\n      await removeDir(this.tilesetPath);\n    } catch (e) {\n      // do nothing\n    }\n\n    const rootTile: Node3D = {\n      boundingVolume: {\n        box: i3sObbTo3dTilesObb(this.sourceTileset.root.header.obb, this.geoidHeightModel)\n      },\n      geometricError: convertScreenThresholdToGeometricError(this.sourceTileset.root),\n      children: []\n    };\n\n    await this._addChildren(this.sourceTileset.root, rootTile, 1);\n\n    const tileset = transform({root: rootTile}, tilesetTemplate);\n    await writeFile(this.tilesetPath, JSON.stringify(tileset), 'tileset.json');\n\n    this._finishConversion({slpk: false, outputPath, tilesetName});\n  }\n\n  /**\n   * The recursive function of traversal of a nodes tree\n   * @param parentSourceNode the parent node tile object (@loaders.gl/tiles/Tile3D)\n   * @param parentNode object in resulting tileset\n   * @param level a current level of a tree depth\n   */\n  private async _addChildren(\n    parentSourceNode: Tile3D,\n    parentNode: Node3D,\n    level: number\n  ): Promise<void> {\n    if (this.options.maxDepth && level > this.options.maxDepth) {\n      return;\n    }\n    for (const childNodeInfo of parentSourceNode.header.children || []) {\n      const sourceChild = await this._loadChildNode(parentSourceNode, childNodeInfo);\n      parentSourceNode.children.push(sourceChild);\n      if (sourceChild.contentUrl) {\n        await this.sourceTileset._loadTile(sourceChild);\n        this.vertexCounter += sourceChild.content.vertexCount;\n\n        let attributes = null;\n        if (this.attributeStorageInfo) {\n          attributes = await this._loadChildAttributes(sourceChild, this.attributeStorageInfo);\n        }\n\n        if (!sourceChild.header.obb) {\n          sourceChild.header.obb = createObbFromMbs(sourceChild.header.mbs);\n        }\n\n        const boundingVolume = {\n          box: i3sObbTo3dTilesObb(sourceChild.header.obb, this.geoidHeightModel)\n        };\n        const child: Node3D = {\n          boundingVolume,\n          geometricError: convertScreenThresholdToGeometricError(sourceChild),\n          children: []\n        };\n\n        const b3dm = await new B3dmConverter().convert(sourceChild, attributes);\n        child.content = {\n          uri: `${sourceChild.id}.b3dm`,\n          boundingVolume\n        };\n        await writeFile(this.tilesetPath, new Uint8Array(b3dm), `${sourceChild.id}.b3dm`);\n        parentNode.children.push(child);\n\n        sourceChild.unloadContent();\n        await this._addChildren(sourceChild, child, level + 1);\n      } else {\n        await this._addChildren(sourceChild, parentNode, level + 1);\n      }\n    }\n  }\n\n  /**\n   * Load a child node having information from the node header\n   * @param parentNode a parent node tile object (@loaders.gl/tiles/Tile3D)\n   * @param childNodeInfo child information from 3DNodeIndexDocument\n   *   (https://github.com/Esri/i3s-spec/blob/master/docs/1.7/nodeReference.cmn.md)\n   */\n  private async _loadChildNode(parentNode: Tile3D, childNodeInfo: NodeReference): Promise<Tile3D> {\n    let header;\n    if (this.sourceTileset.tileset.nodePages) {\n      console.log(`Node conversion: ${childNodeInfo.id}`); // eslint-disable-line no-console,no-undef\n      header = await this.sourceTileset.tileset.nodePagesTile.formTileFromNodePages(\n        childNodeInfo.id\n      );\n    } else {\n      const {loader} = this.sourceTileset;\n      const nodeUrl = this._relativeUrlToFullUrl(parentNode.url, childNodeInfo.href);\n      // load metadata\n      const options = {\n        i3s: {\n          ...this.sourceTileset.loadOptions,\n          isTileHeader: true,\n          loadContent: false\n        }\n      };\n\n      console.log(`Node conversion: ${nodeUrl}`); // eslint-disable-line no-console,no-undef\n      header = await load(nodeUrl, loader, options);\n    }\n    return new Tile3D(this.sourceTileset, header, parentNode);\n  }\n\n  /**\n   * Make an url of a resource from its relative url having the base url\n   * @param baseUrl the base url. A resulting url will be related from this url\n   * @param relativeUrl a realtive url of a resource\n   */\n  private _relativeUrlToFullUrl(baseUrl: string, relativeUrl: string): string {\n    let resultArray = baseUrl.split('/');\n    const relativeUrlArray = relativeUrl.split('/');\n    for (const folder of relativeUrlArray) {\n      switch (folder) {\n        case '.':\n          continue; // eslint-disable-line no-continue\n        case '..':\n          resultArray = resultArray.slice(0, -1);\n          break;\n        default:\n          resultArray.push(folder);\n      }\n    }\n    return resultArray.join('/');\n  }\n\n  /**\n   * Do loading all attributes related to particular node.\n   * @param sourceChild\n   * @param attributeStorageInfo\n   * @returns Promise of attributes object.\n   */\n  private async _loadChildAttributes(\n    sourceChild: Tile3D,\n    attributeStorageInfo: AttributeStorageInfo\n  ): Promise<FeatureAttribute> {\n    const promises = [];\n    const {attributeUrls} = sourceChild.header;\n\n    for (let index = 0; index < attributeUrls.length; index++) {\n      const inputUrl = attributeUrls[index];\n      const attribute = attributeStorageInfo[index];\n      const options = {\n        attributeName: attribute.name,\n        attributeType: this._getAttributeType(attribute)\n      };\n\n      promises.push(load(inputUrl, I3SAttributeLoader, options));\n    }\n    const attributesList = await Promise.all(promises);\n    this._replaceNestedArrays(attributesList);\n    return Object.assign({}, ...attributesList);\n  }\n\n  /**\n   * Returns attribute type for loading attributes\n   * @param attribute\n   * Workaround for I3S v1.6. There is no attribute.attributeValues.valueType field in attribute.\n   * There is an 'Oid32' type if attribute has objectIds property.\n   * Doc: https://github.com/Esri/i3s-spec/blob/master/docs/1.6/attributeStorageInfo.cmn.md\n   */\n  private _getAttributeType(attribute: AttributeStorageInfo): string {\n    if (attribute.attributeValues) {\n      return attribute.attributeValues.valueType;\n    } else if (attribute.objectIds) {\n      return 'Oid32';\n    }\n    return '';\n  }\n\n  /**\n   * Make simple arrays from attribute typed arrays.\n   * @param attributesList\n   */\n  private _replaceNestedArrays(attributesList: FeatureAttribute[]): void {\n    for (let index = 0; index < attributesList.length; index++) {\n      const attributeObject = attributesList[index];\n\n      for (const key in attributeObject) {\n        attributeObject[key] = Array.from(attributeObject[key]);\n      }\n    }\n  }\n\n  /**\n   * Print statistics in the end of conversion\n   * @param params - output files data\n   */\n  private async _finishConversion(params: {\n    slpk: boolean;\n    outputPath: string;\n    tilesetName: string;\n  }): Promise<void> {\n    const filesSize = await calculateFilesSize(params);\n    const diff = process.hrtime(this.conversionStartTime);\n    const conversionTime = timeConverter(diff);\n\n    console.log(`------------------------------------------------`); // eslint-disable-line\n    console.log(`Finish conversion of ${I3S}`); // eslint-disable-line\n    console.log(`Total conversion time: ${conversionTime}`); // eslint-disable-line\n    console.log(`Vertex count: `, this.vertexCounter); // eslint-disable-line\n    console.log(`File(s) size: `, filesSize, ' bytes'); // eslint-disable-line\n    console.log(`------------------------------------------------`); // eslint-disable-line\n  }\n}\n"],"file":"3d-tiles-converter.js"}